Tạo một từ điển không đổi trong C #

Cách hiệu quả nhất để tạo ánh xạ hằng (không bao giờ thay đổi trong thời gian chạy) của strings thành ints là gì?

Tôi đã thử sử dụng từ điển const , nhưng không được.

Tôi có thể thực hiện một trình bao bọc bất biến với ngữ nghĩa phù hợp, nhưng điều đó dường như vẫn chưa hoàn toàn đúng.

Đối với những người đã hỏi, tôi đang triển khai IDataErrorInfo trong một lớp được tạo và đang tìm cách để làm cho cột Tên tra cứu vào mảng mô tả của tôi.

Tôi đã không biết (lỗi đánh máy khi kiểm tra! D'O!) Công tắc đó chấp nhận chuỗi, vì vậy đó là những gì tôi sẽ sử dụng. Cảm ơn!

Tạo một từ điển hằng số được tạo theo thời gian thực sự biên dịch trong C # không thực sự là một nhiệm vụ đơn giản. Trên thực tế, không có câu trả lời nào ở đây thực sự đạt được điều đó.

Có một giải pháp mặc dù đáp ứng yêu cầu của bạn, mặc dù không nhất thiết phải là một giải pháp tốt đẹp; hãy nhớ rằng theo đặc tả C #, các bảng trường hợp chuyển đổi được biên dịch thành các bảng nhảy băm không đổi. Đó là, chúng là từ điển không đổi, không phải là một loạt các câu lệnh if-other. Vì vậy, hãy xem xét một tuyên bố trường hợp chuyển đổi như thế này:

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

Đây chính xác là những gì bạn muốn. Và vâng, tôi biết, nó xấu.

Có rất ít bộ sưu tập bất biến trong khuôn khổ hiện tại. Tôi có thể nghĩ về một tùy chọn tương đối không đau trong .NET 3.5:

Sử dụng Enumerable.ToLookup()- Lookup<,>lớp là bất biến (nhưng đa giá trị trên rhs); bạn có thể làm điều này từ một cách Dictionary<,>khá dễ dàng:

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

Đây là thứ gần nhất bạn có thể nhận được từ "CONST Dictionary":

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

Trình biên dịch sẽ đủ thông minh để xây dựng mã càng sạch càng tốt.

Nếu sử dụng 4.5+ Framework, tôi sẽ sử dụng ReadOnlyDipedia (cũng là Bộ sưu tập ReadOnly cho danh sách) để thực hiện ánh xạ / hằng số chỉ đọc. Nó được thực hiện theo cách sau.

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

Tại sao không sử dụng không gian tên hoặc các lớp để lồng các giá trị của bạn? Nó có thể không hoàn hảo, nhưng nó rất sạch sẽ.

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

Bây giờ bạn có thể truy cập .ParentClass.FooDipedia.Key1, v.v.

Dường như không có bất kỳ giao diện bất biến tiêu chuẩn nào cho từ điển, vì vậy, việc tạo một trình bao bọc có vẻ như là lựa chọn hợp lý duy nhất, thật không may.

Chỉnh sửa : Marc Gravell đã tìm thấy ILookup mà tôi đã bỏ lỡ - điều đó sẽ cho phép bạn ít nhất tránh việc tạo một trình bao bọc mới, mặc dù bạn vẫn cần phải chuyển đổi Từ điển với .ToLookup ().

Nếu đây là một nhu cầu bị ràng buộc trong một kịch bản cụ thể, bạn có thể tốt hơn với giao diện định hướng logic kinh doanh hơn:

interface IActiveUserCountProvider
{
    int GetMaxForServer(string serverName);
}

Tôi không chắc tại sao không ai đề cập đến điều này nhưng trong C # cho những thứ mà tôi không thể gán const, tôi sử dụng các thuộc tính chỉ đọc tĩnh.

Thí dụ:

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

Chỉ là một ý tưởng khác vì tôi liên kết với 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;

Để lấy giá trị int từ tên hiển thị từ :

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

sử dụng:

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

Tại sao không:

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