如何清除泛型靜態類中的字段？

Question

我有一個類，它是這樣的：

public static class Messenger<T> 
{ 
    private static readonly Dictionary<string, Delegate> eventTable = new Dictionary<string, Delegate>(); 
    public static void DoSomethingWithEventTable() //Somehow fills eventTable 
    public static void Clear() 
    { 
     eventTable.Clear(); 
    } 
} 

現在，我打電話的地方DoSomethingWithEventTable兩次在我的節目，像這樣：

Messenger<int>.DoSomethingWithEventTable(); 
Messenger<float>.DoSomethingWithEventTable(); 

我想清楚了eventTable每一個Messenger<T>。我應該怎麼做？我應該叫Clear爲每一個我已經把泛型類型，像這樣：

Messenger<int>.Clear(); 
Messenger<float>.Clear(); 

還是會足以做一些愚蠢像這一次，

Messenger<string>.Clear(); 

UPD：基本實驗表明我應該爲每個使用過的T清除Messenger。現在有人能夠爲這些課程提供更好的設計嗎？

什麼，我現在使用的更詳細的版本：

static public class Messenger<T> 
{ 
    private static readonly Dictionary<string, Delegate> eventTable = new Dictionary<string, Delegate>(); 

    static public void AddListener(string eventType, Callback<T> handler) 
    { 
     // Obtain a lock on the event table to keep this thread-safe. 
     lock (eventTable) 
     { 
      // Create an entry for this event type if it doesn't already exist. 
      if (!eventTable.ContainsKey(eventType)) 
      { 
       eventTable.Add(eventType, null); 
      } 
      // Add the handler to the event. 
      eventTable[eventType] = (Callback<T>)eventTable[eventType] + handler; 
     } 
    } 

    static public void RemoveListener(string eventType, Callback<T> handler) 
    { 
     // Obtain a lock on the event table to keep this thread-safe. 
     lock (eventTable) 
     { 
      // Only take action if this event type exists. 
      if (eventTable.ContainsKey(eventType)) 
      { 
       // Remove the event handler from this event. 
       eventTable[eventType] = (Callback<T>)eventTable[eventType] - handler; 

       // If there's nothing left then remove the event type from the event table. 
       if (eventTable[eventType] == null) 
       { 
        eventTable.Remove(eventType); 
       } 
      } 
     } 
    } 

    static public void Invoke(string eventType, T arg1) 
    { 
     Delegate d; 
     // Invoke the delegate only if the event type is in the dictionary. 
     if (eventTable.TryGetValue(eventType, out d)) 
     { 
      // Take a local copy to prevent a race condition if another thread 
      // were to unsubscribe from this event. 
      Callback<T> callback = (Callback<T>)d; 

      // Invoke the delegate if it's not null. 
      if (callback != null) 
      { 
       callback(arg1); 
      } 
     } 
    } 

    static public void Clear() 
    { 
     eventTable.Clear(); 
    } 
} 

同樣重要的是，我有另一班Messenger（非通用，是啊）和Messenger<T,M>，也許有一天我甚至會需要的東西像Messenger<T,M,N>等

Answer 1

每個Messenger<T>類型都有它的事件表的自己的副本，所以你需要調用清除（）爲您使用的每個不同的T。

如通過該測試：

[TestFixture] 
    public class Tests 
    {  
     static class MyClass<T> 
     { 
      public static List<int> Member = new List<int>(); 
     } 

     [Test] 
     public void StaticTest() 
     { 
      var m1 = MyClass<int>.Member; 
      var m2 = MyClass<string>.Member; 

      Assert.AreNotSame(m1, m2); 
     } 
} 

Answer 2

由於

private static readonly Dictionary<string, Delegate> eventTable = new Dictionary<string, Delegate>(); 

不依賴於<T>，爲所有事件表一個靜態的 「處理程序」。

IE

public static class TableHandler { 
    ICollection<Dictionary<string, Delegate>> tables = new List<Dictionary<string, Delegate>>(); 

    public void Add(Dictionary<string, Delegate> item) 
    { 
     tables.Add(item); 
    } 

    public void Clear() 
    { 
     foreach (var item in tables) item.Clear(); 
     tables.Clear(); 
    } 
} 

並確保DoSomethingWithEventTable()添加事件表的TableHandler。

可能不是最好的整體解決方案，但它可以幫助您跟蹤當前設計的表格。

編輯：

我想谷歌的方式來找到一個靜態類的所有通用的變種，但我沒有找到一個方法。有誰知道一種方法來做到這一點？