Créer un dictionnaire constant en C #

Quelle est la manière la plus efficace de créer un mappage constant (ne change jamais à l'exécution) de strings à ints?

J'ai essayé d'utiliser un dictionnaire const , mais cela n'a pas fonctionné.

Je pourrais implémenter un wrapper immuable avec une sémantique appropriée, mais cela ne semble toujours pas tout à fait correct.

Pour ceux qui ont demandé, j'implémente IDataErrorInfo dans une classe générée et je cherche un moyen d'effectuer la recherche columnName dans mon tableau de descripteurs.

Je n'étais pas au courant (faute de frappe lors du test! D'oh!) Que le commutateur accepte les chaînes, c'est donc ce que je vais utiliser. Merci!

La création d'un dictionnaire de constantes réellement généré au moment de la compilation en C # n'est pas vraiment une tâche simple. En fait, aucune des réponses ici n'y parvient vraiment.

Il existe cependant une solution qui répond à vos besoins, mais pas nécessairement une solution intéressante; rappelez-vous que selon la spécification C #, les tables de commutation sont compilées en tables de sauts de hachage constant. Autrement dit, ce sont des dictionnaires constants, pas une série d'instructions if-else. Considérons donc une instruction switch-case comme celle-ci:

switch (myString)
{
   case "cat": return 0;
   case "dog": return 1;
   case "elephant": return 3;
}

C'est exactement ce que vous voulez. Et oui, je sais, c'est moche.

Il existe quelques précieuses collections immuables dans le cadre actuel. Je peux penser à une option relativement simple dans .NET 3.5:

Utilisation Enumerable.ToLookup()- la Lookup<,>classe est immuable (mais à valeurs multiples sur les rhs); vous pouvez le faire Dictionary<,>assez facilement:

    Dictionary<string, int> ids = new Dictionary<string, int> {
      {"abc",1}, {"def",2}, {"ghi",3}
    };
    ILookup<string, int> lookup = ids.ToLookup(x => x.Key, x => x.Value);
    int i = lookup["def"].Single();

enum Constants
{
    Abc = 1,
    Def = 2,
    Ghi = 3
}

...

int i = (int)Enum.Parse(typeof(Constants), "Def");

Voici la chose la plus proche que vous puissiez obtenir dans un "Dictionnaire CONST":

public static int GetValueByName(string name)
{
    switch (name)
    {
        case "bob": return 1;
        case "billy": return 2;
        default: return -1;
    }
}

Le compilateur sera suffisamment intelligent pour créer le code aussi propre que possible.

Si vous utilisez 4.5+ Framework, j'utiliserais ReadOnlyDictionary (également ReadOnly Collection pour les listes) pour faire des mappages / constantes en lecture seule. Il est mis en œuvre de la manière suivante.

static class SomeClass
{
    static readonly ReadOnlyDictionary<string,int> SOME_MAPPING 
        = new ReadOnlyDictionary<string,int>(
            new Dictionary<string,int>()
            {
                { "One", 1 },
                { "Two", 2 }
            }
        )
}        

Pourquoi ne pas utiliser des espaces de noms ou des classes pour imbriquer vos valeurs? C'est peut-être imparfait, mais c'est très propre.

public static class ParentClass
{
    // here is the "dictionary" class
    public static class FooDictionary
    {
        public const string Key1 = "somevalue";
        public const string Foobar = "fubar";
    }
}

Vous pouvez maintenant accéder à .ParentClass.FooDictionary.Key1, etc.

Il ne semble pas y avoir d'interface immuable standard pour les dictionnaires, donc la création d'un wrapper semble être la seule option raisonnable, malheureusement.

Edit : Marc Gravell a trouvé le ILookup que j'ai manqué - cela vous permettra au moins d'éviter de créer un nouveau wrapper, même si vous devez encore transformer le dictionnaire avec .ToLookup ().

S'il s'agit d'un besoin limité à un scénario spécifique, vous pourriez être mieux avec une interface plus orientée vers la logique métier:

interface IActiveUserCountProvider
{
    int GetMaxForServer(string serverName);
}

Je ne sais pas pourquoi personne n'a mentionné cela, mais en C # pour les choses que je ne peux pas attribuer à const, j'utilise des propriétés statiques en lecture seule.

Exemple:

public static readonly Dictionary<string, string[]> NewDictionary = new Dictionary<string, string[]>()
        {
            { "Reference1", Array1 },
            { "Reference2", Array2 },
            { "Reference3", Array3 },
            { "Reference4", Array4 },
            { "Reference5", Array5 }
        };

Juste une autre idée puisque je suis lié à une combobox winforms:

public enum DateRange {
    [Display(Name = "None")]
    None = 0,
    [Display(Name = "Today")]
    Today = 1,
    [Display(Name = "Tomorrow")]
    Tomorrow = 2,
    [Display(Name = "Yesterday")]
    Yesterday = 3,
    [Display(Name = "Last 7 Days")]
    LastSeven = 4,
    [Display(Name = "Custom")]
    Custom = 99
    };

int something = (int)DateRange.None;

Pour obtenir la valeur int à partir du nom d'affichage à partir de :

public static class EnumHelper<T>
{
    public static T GetValueFromName(string name)
    {
        var type = typeof(T);
        if (!type.IsEnum) throw new InvalidOperationException();

        foreach (var field in type.GetFields())
        {
            var attribute = Attribute.GetCustomAttribute(field,
                typeof(DisplayAttribute)) as DisplayAttribute;
            if (attribute != null)
            {
                if (attribute.Name == name)
                {
                    return (T)field.GetValue(null);
                }
            }
            else
            {
                if (field.Name == name)
                    return (T)field.GetValue(null);
            }
        }

        throw new ArgumentOutOfRangeException("name");
    }
}

usage:

var z = (int)EnumHelper<DateRange>.GetValueFromName("Last 7 Days");

Pourquoi pas:

public class MyClass
{
    private Dictionary<string, int> _myCollection = new Dictionary<string, int>() { { "A", 1 }, { "B", 2 }, { "C", 3 } };

    public IEnumerable<KeyValuePair<string,int>> MyCollection
    {
        get { return _myCollection.AsEnumerable<KeyValuePair<string, int>>(); }
    }
}