Criando um dicionário constante em c #

Qual é a maneira mais eficiente de criar um mapeamento constante (nunca muda em tempo de execução) de strings para ints?

Eu tentei usar um dicionário const , mas isso não deu certo.

Eu poderia implementar um invólucro imutável com semântica apropriada, mas isso ainda não parece totalmente correto.

Para aqueles que perguntaram, estou implementando IDataErrorInfo em uma classe gerada e estou procurando uma maneira de fazer a pesquisa columnName na minha matriz de descritores.

Eu não sabia (erro de digitação ao testar! D'oh!) Que o switch aceita strings, então é isso que eu vou usar. Obrigado!

Criar um dicionário constante gerado em tempo de compilação verdadeiramente em C # não é realmente uma tarefa simples. Na verdade, nenhuma das respostas aqui realmente consegue isso.

Existe uma solução que atende aos seus requisitos, embora não seja necessariamente uma boa; lembre-se de que, de acordo com a especificação C #, as tabelas de casos de comutação são compiladas em tabelas de salto de hash constantes. Ou seja, são dicionários constantes, não uma série de instruções if-else. Portanto, considere uma declaração de caso de troca como esta:

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

É exatamente isso que você deseja. E sim, eu sei, é feio.

Existem poucas coleções imutáveis ​​na estrutura atual. Posso pensar em uma opção relativamente simples no .NET 3.5:

Uso Enumerable.ToLookup()- a Lookup<,>classe é imutável (mas com vários valores no rhs); você pode fazer isso Dictionary<,>facilmente:

    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");

Essa é a coisa mais próxima que você pode obter de um "Dicionário CONST":

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

O compilador será inteligente o suficiente para criar o código o mais limpo possível.

Se estiver usando o 4.5+ Framework, eu usaria o ReadOnlyDictionary (também ReadOnly Collection para listas) para fazer mapeamentos / constantes somente leitura. É implementado da seguinte maneira.

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

Por que não usar namespaces ou classes para aninhar seus valores? Pode ser imperfeito, mas é muito limpo.

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

Agora você pode acessar .ParentClass.FooDictionary.Key1, etc.

Não parece haver nenhuma interface imutável padrão para dicionários; portanto, criar um wrapper parece ser a única opção razoável, infelizmente.

Edit : Marc Gravell encontrou o ILookup que eu perdi - que permitirá pelo menos evitar a criação de um novo wrapper, embora você ainda precise transformar o Dicionário com .ToLookup ().

Se for uma necessidade restrita a um cenário específico, você poderá se beneficiar com uma interface mais orientada à lógica de negócios:

interface IActiveUserCountProvider
{
    int GetMaxForServer(string serverName);
}

Não sei por que ninguém mencionou isso, mas em C # para coisas que não posso atribuir const, uso propriedades estáticas somente leitura.

Exemplo:

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

Apenas outra idéia, pois estou vinculando uma caixa de combinação 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;

Para obter o valor int do nome de exibição 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");
    }
}

uso:

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

Por que não:

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>>(); }
    }
}