Từ điển với số lượng giới hạn các loại

Question

Đầu tiên, xin lỗi tên khá buồn cười của câu hỏi của tôi. Tôi không phải là người bản xứ và tôi mất 10 phút để thể hiện suy nghĩ của mình trong vài nhân vật này.

Điều tôi đang cố làm là tạo từ điển trong C# cho phép giá trị là int, một số string hoặc bool. Điều đầu tiên tôi nghĩ đến là sử dụng Generics, nhưng theo như tôi biết, tôi chỉ có thể định nghĩa một kiểu như kiểu giá trị có thể, chứ không phải "là một trong số đó". Sử dụng object cũng sẽ có thể, nhưng boxing có vẻ là một kẻ giết người thực hiện khá.

Có cách nào để thực hiện việc này không?

Dưới đây là một ví dụ về những gì đã đến với tâm trí tôi:

Dictionary<string, (string, int, bool)> foo = new Dictionary<string, (string, int, bool)>(); 
foo.Add("key1", "Hello, World!"); //Correct - Value is a string 
foo.Add("key2", 37); //Correct - Value is an int 
foo.Add("key3", true); //Correct - Value is a boolean 
foo.Add("key4", new Foobar()); //Compiler error - Value is a Foobar 

mục tiêu cuối cùng của tôi là để cung cấp một thư viện cho các nhà phát triển khác. Tính năng này sẽ cho phép chúng xác định "biến" trong thời gian chạy và cung cấp cho chúng một loại.

Edit: // Firefox' about: config trang có cái gì đó rất gần với những gì tôi muốn đạt được

Answer 1

Tại sao không tạo ra một lớp mới tươi mà thực hiện các IDictionary và sử dụng một từ điển như là một biến tư nhân.

Sau đó, trong phương pháp add, bạn có thể cung cấp logic riêng của bạn và không phù hợp

Mẫu mã

public class MyDic : IDictionary<object, object> 
{ 
    private Dictionary<object, object> privateDic= new Dictionary<object,object>(); 


    public void Add(object key, object value) 
    { 
     if (value.GetType() == typeof(string)) 
      throw new ArgumentException(); 
     privateDic.Add(key, value); 
    } 
    //Rest of the interface follows 
} 

Answer 2

tôi sẽ đề nghị để:

1. Tạo một kiểu cơ sở cho các giá trị từ điển của bạn ví dụ MyDictionaryBaseType
2. Mở rộng loại cơ bản này cho từng loại giá trị từ điển bạn có, ví dụ: StringDictionryType: MyDictionaryBaseType, IntegerDictionryType: MyDictionaryBaseType ... v.v.
3. Tạo loại từ điển chung với MyDictionaryBaseType và giới hạn loại để mở rộng loại cơ sở này.

Bằng cách này bạn giới hạn dictionry của bạn để ba loại specifed

Answer 3

Bạn có thể đặt các giá trị vào wrapper classs như thế này:

class Value 
{ 
} 

class TypedValue<T> : Value 
{ 
    public T Val; 
} 

class IntValue : TypedValue<int> 
{ 
} 

class StringValue : TypedValue<string> 
{ 
} 

class BoolValue : TypedValue<bool> 
{ 
} 

Dictionary<string,Value> foo; 

foo.Add("key1", new StringValue{Val="Hello World!"}); 

Một khả năng khác là sử dụng từ điển và thực hiện kiểm tra thời gian chạy cho các loại đúng hoặc sai được thêm vào. Tôi không nghĩ rằng có một giải pháp mà không liên quan đến quyền anh.

Answer 4

Những gì bạn đang cố gắng hoàn thành không an toàn kiểu khi nó đứng. Ví dụ, giả sử bạn có một từ điển như:

var foo = new Dictionary<string, (string, int, bool)>(); 
var x = foo["key1"]; 
// What type is x? How could the compiler know? 

Một ý tưởng sẽ được đưa ra một lớp container có sức chứa một trong hai string, int, hoặc bool.

public class StringIntBool { 
    private bool _isSet; 
    private bool _isString; 
    public bool IsString { 
     get { return _isString; } 
    } 
    // ... 

    private string _innerString; 
    public string InnerString { 
     get { 
      return _innerString; 
     } 
     set { 
      if (_isSet) { 
       throw new Exception("StringIntBool is already set"); 
      } 
      _isSet = true; 
      _isString = true; 
      _innerString = value; 
     } 
    } 

    // etc... 
} 

Điều này khá xấu và không thực sự mang lại nhiều lợi ích.Thay vào đó, bạn có thể lưu trữ tất cả ba giá trị là object s và sau đó sử dụng kỹ thuật/thư viện như Functional C# để thực hiện khớp mẫu, giống như nhiều ngôn ngữ chức năng có thể.

object x = "str"; 
int res = x.Match() 
    .With<string>(s => s == "str" ? 10 : 20) 
    .With<int>(i => i) 
    .With<bool>(b => b ? 50 : 60) 
    .Return<int>(); 

Mô hình lập trình này thực sự khá phổ biến ở một số ngôn ngữ chức năng nhất định. Ví dụ, trong SML, bạn có thể định nghĩa một kiểu dữ liệu, và sau đó mô hình phù hợp với nó khi cần thiết.

(* StringIntBool *) 
datatype sib = SibString of string | SibInt of int | SibBool of bool 

val x = (* some instance of sib *) 
val y = case x of 
    SibString s => if s = "hello" then 50 else -50 
    | SibInt i => i 
    | SibBool b => if b then 10 else 20