Создание постоянного словаря в C #

Каков наиболее эффективный способ создать постоянное (никогда не изменяется во время выполнения) сопоставление strings с ints?

Я пробовал использовать const Dictionary , но это не сработало.

Я мог бы реализовать неизменяемую оболочку с соответствующей семантикой, но это все еще кажется не совсем правильным.

Для тех, кто спросил, я реализую IDataErrorInfo в сгенерированном классе и ищу способ выполнить поиск columnName в моем массиве дескрипторов.

Я не знал (опечатка при тестировании! Ох!), Что переключатель принимает строки, так что я собираюсь использовать его. Спасибо!

Создание действительно сгенерированного во время компиляции словаря констант в C # на самом деле не является простой задачей. На самом деле ни один из ответов здесь не дает этого.

Однако есть одно решение, которое соответствует вашим требованиям, хотя и не обязательно хорошее; помните, что в соответствии со спецификацией C # таблицы вариантов переключения компилируются в таблицы переходов с постоянным хешем. То есть это постоянные словари, а не серия операторов if-else. Рассмотрим такой оператор switch-case:

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

Это именно то, что вам нужно. И да, я знаю, это некрасиво.

В текущей структуре очень мало неизменяемых коллекций. Я могу придумать один относительно безболезненный вариант в .NET 3.5:

Использование Enumerable.ToLookup()- Lookup<,>класс неизменяемый (но многозначный по правому краю); вы можете сделать это Dictionary<,>довольно легко:

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

Это самое близкое к "словарю CONST":

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

Компилятор будет достаточно умен, чтобы собрать код как можно более чистым.

При использовании 4.5+ Framework я бы использовал ReadOnlyDictionary (также ReadOnly Collection для списков), чтобы делать сопоставления / константы только для чтения. Это реализовано следующим образом.

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

Почему бы не использовать пространства имен или классы для вложенности ваших значений? Он может быть несовершенным, но очень чистый.

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

Теперь вы можете получить доступ к .ParentClass.FooDictionary.Key1 и т. Д.

Кажется, что не существует стандартного неизменяемого интерфейса для словарей, поэтому, к сожалению, создание оболочки кажется единственным разумным вариантом.

Изменить : Марк Гравелл нашел ILookup, который я пропустил, - это позволит вам, по крайней мере, избежать создания новой оболочки, хотя вам все равно нужно преобразовать словарь с помощью .ToLookup ().

Если это необходимость, ограниченная конкретным сценарием, вам может быть лучше с интерфейсом, более ориентированным на бизнес-логику:

interface IActiveUserCountProvider
{
    int GetMaxForServer(string serverName);
}

Я не уверен, почему никто не упомянул об этом, но в C # для вещей, которым я не могу назначить const, я использую статические свойства только для чтения.

Пример:

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

Еще одна идея, поскольку я привязываюсь к комбинированному списку 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;

Чтобы получить значение int из отображаемого имени из :

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

использование:

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

Почему нет:

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