<類型，列表字典<Type>>

Question

字典我想實現一個字典的包裝類，將類型映射到該類型的泛型列表。例如：

**Key**    **Value** 
typeof(InterfaceA), List<InterfaceA> 
typeof(InterfaceB), List<InterfaceB> 
typeof(MyClass), List<MyClass> 
... 

然後我想通過使用類型與包裝類進行交互。

public void NewEntry<T>() 
{ 
    MyDict.Add(typeof(T), new List<T>()); 
} 

public List<T> GetEntry<T>() 
{ 
    return MyDict[typeof(T)]; 
} 

public void RemoveEntry<T>() 
{ 
    MyDict.Remove(typeof(T)); 
} 

是否有任何優雅的方式來做到這一點？

編輯：澄清，這點是如此，隨着

GetEntry<MyInterface>() 

在列表中的項目，保證遵守MyInterface的合同。每個條目將具有不同的類型鍵，並且每個項目列表將遵循該類型的合同。

Answer 1

您可以使用下面的靜態類

public static class GenericLists 
{ 
    private static Dictionary<Type, object> MyDict = new Dictionary<Type, object>(); 
    public static void NewEntry<T>() 
    { 
     MyDict.Add(typeof(T), new List<T>()); 
    } 

    public static List<T> GetEntry<T>() 
    { 
     return (List<T>)MyDict[typeof(T)]; 
    } 

    public static void RemoveEntry<T>() 
    { 
     MyDict.Remove(typeof(T)); 
    } 

} 

或者你可以使用

public class GenericLists<T> 
{ 
    private Dictionary<Type, List<T>> MyDict = new Dictionary<Type, List<T>>(); 

    public void NewEntry() 
    { 
     MyDict.Add(typeof(T), new List<T>()); 
    } 

    public List<T> GetEntry() 
    { 
     return MyDict[typeof(T)]; 
    } 

    public void RemoveEntry() 
    { 
     MyDict.Remove(typeof(T)); 
    } 
} 

，如果你真的想初始化它，但我想靜會更好地工作。

Answer 2

如果你願意來存儲靜態的一切，你可以使用類型系統：

static class MyDict { 
    private static class Data<T> { 
     public static readonly List<T> items = new List<T>(); 
    } 
    public static List<T> Get<T>() { return Data<T>.items; } 
    public static void Add<T>(T item) { Data<T>.items.Add(item); } 
} 

注意，這使得它不可能刪除鍵（你不能卸載型），雖然你可以Clear()吧。

Answer 3

您也可以將它作爲基於實例的類來實現（請參閱下文），但是我的首選項（如果它適用於您）是在靜態類中使用靜態變量，因爲SLak在「使用類型系統「後。

public class GenericTypeListDictionary 
{ 
    private readonly Dictionary<Type, object> _dictionaryOfLists = new Dictionary<Type, object>(); 

    public List<T> NewEntry<T>() 
    { 
     var newList = new List<T>(); 
     _dictionaryOfLists.Add(typeof(T), newList); 
     return newList; 
    } 

    public List<T> GetEntry<T>() 
    { 
     object value; 

     if (_dictionaryOfLists.TryGetValue(typeof(T), out value)) 
     { 
      return (List<T>)value; 
     } 

     return null; 
    } 

    public void RemoveEntry<T>() 
    { 
     _dictionaryOfLists.Remove(typeof(T)); 
    } 
}