處理創建大量子類型對象的最佳方法

Question

我有一個基類消息類和大約100個不同的消息子類，它們表示可以處理的每種消息類型。我目前正在考慮的是使用巨大的switch語句來創建消息對象。例如：

switch (MsgType) 
{ 
    case MessageType.ChatMsg: 
     Msg = new MsgChat(Buf); 
     break; 
    case MessageType.ResultMsg: 
     Msg = new MsgResult(Buf); 
     break; 
    ... // 98 more case statements 
} 
Msg.ProcessMsg(); // Use a polymorphic call to process the message. 

有沒有更好的方法來做到這一點？如果是這樣，你可以展示一個簡單的代碼示例。

編輯

於是，我試着這樣做：

public class Test 
{ 
    public Test() 
    { 
     IEnumerable<Type> myEnumerable = GetTypesWith<MyAttribute>(true); 
    } 

    IEnumerable<Type> GetTypesWith<TAttribute>(bool inherit) 
     where TAttribute : System.Attribute 
    { 
     return from a in AppDomain.CurrentDomain.GetAssemblies() 
      from t in a.GetTypes() 
      where t.IsDefined(typeof(TAttribute), inherit) 
      select t; 
    } 
} 

這似乎在myEnumerable工作現在包含消息亞型的所有100個，加上基本消息類型爲好。但是，雖然我並不介意在程序開始時使用反射來加載類型，但使用它來實時訪問適當的對象可能會太慢。所以，我想嘗試使用委託。

在下面從@馬克希爾德雷思註釋的例子：那麼，有

」你>然後，你的映射會映射[MessageType.ChatMsg] = X =>新MsgChat的字典（ X）;」

有幾種方法來解釋這段代碼。一個想法是刪除所有100個子類，並使用100個委託方法使用一個大型類。這是一個遙遠的第二選擇。另一個想法和我的第一選擇是讓上面的代碼以某種方式創建一個消息子類對象。但是，我不太明白它會如何做到這一點。另外，在我的Test類中保留上面的技巧並獲得所有類型或委託而不必寫出所有類型或委託，這將是非常好的。你或其他人可以解釋如何做到這一點嗎？

Answer 1

而不是使用一個巨型switch聲明，你可以定義一個Dictionary映射每個MessageType價值，其定義Message派生類，並創建使用該地圖數據的實例。

字典的定義：

Dictionary<int, Type> mappings = new Dictionary<int, Type>(); 
mappings.Add(MessageType.ChatMsg, typeof(MsgChat)); 
mappings.Add(MessageType.ResultMsg, typeof(MsgResult)); 

...

字典消費：

ConstructorInfo ctor = mappings[MessageType.ChatMsg].GetConstructor(new[] { typeof(Buf) }); 
Message message = (Message)ctor.Invoke(new object[] { Buf }); 

請注意，我不編譯這個代碼，以驗證是否正確，或者不。我只想告訴你這個想法。

編輯

還有就是我的新的答案，以改善第一個。我正在考慮你編輯的問題，使用@MikeSW和@Mark Hildreth。

public class FactoryMethodDelegateAttribute : Attribute 
{ 
    public FactoryMethodDelegateAttribute(Type type, string factoryMethodField, Message.MessageType typeId) 
    { 
     this.TypeId = typeId; 
     var field = type.GetField(factoryMethodField); 
     if (field != null) 
     { 
      this.FactoryMethod = (Func<byte[], Message>)field.GetValue(null); 
     } 
    } 

    public Func<byte[], Message> FactoryMethod { get; private set; } 
    public Message.MessageType TypeId { get; private set; } 
} 

public class Message 
{ 
    public enum MessageType 
    { 
     ChatMsg, 
    } 
} 

[FactoryMethodDelegate(typeof(ChatMsg), "FactoryMethodDelegate", Message.MessageType.ChatMsg)] 
public class ChatMsg : Message 
{ 
    public static readonly MessageType MessageTypeId = MessageType.ChatMsg; 
    public static readonly Func<byte[], Message> FactoryMethodDelegate = buffer => new ChatMsg(buffer); 
    public ChatMsg(byte[] buffer) 
    { 
     this.Buffer = buffer; 
    } 

    private byte[] Buffer { get; set; } 
} 

public class TestClass 
{ 
    private IEnumerable<Type> GetTypesWith<TAttribute>(bool inherit) where TAttribute : Attribute 
    { 
     return from a in AppDomain.CurrentDomain.GetAssemblies() 
       from t in a.GetTypes() 
       where t.IsDefined(typeof(TAttribute), inherit) 
       select t; 
    } 

    [Test] 
    public void Test() 
    { 
     var buffer = new byte[1]; 
     var mappings = new Dictionary<Message.MessageType, Func<byte[], Message>>(); 
     IEnumerable<Type> types = this.GetTypesWith<FactoryMethodDelegateAttribute>(true); 
     foreach (var type in types) 
     { 
      var attribute = 
       (FactoryMethodDelegateAttribute) 
       type.GetCustomAttributes(typeof(FactoryMethodDelegateAttribute), true).First(); 

      mappings.Add(attribute.TypeId, attribute.FactoryMethod); 
     } 

     var message = mappings[Message.MessageType.ChatMsg](buffer); 
    } 
} 

Answer 2

你在正確的軌道上，使用字典是一個好主意。如果反射太慢，你可以使用表達式，就像這樣（我假設你使用MessageTypeAttribute來裝飾Messages類）。

public class Test 
{ 
public Test() 
    { 
    var dict=new Dictionary<MessageType,Func<Buffer,Mesage>>(); 
    var types=from a in AppDomain.CurrentDomain.GetAssemblies() 
     from t in a.GetTypes() 
     where t.IsDefined(MessageTypeAttribute, inherit) 
     select t; 
    foreach(var t in types) { 
     var attr = t.GetCustomAttributes(typeof (MessageTypeAttribute), false).First(); 
     dict[attr.MessageType] = CreateFactory(t); 
     } 

     var msg=dict[MessageType.Chat](Buf); 
    } 

Func<Buffer,Message> CreateFactory(Type t) 
{ 
     var arg = Expression.Parameter(typeof (Buffer)); 
     var newMsg = Expression.New(t.GetConstructor(new[] {typeof (Buffer)}),arg); 
     return Expression.Lambda<Func<Buffer, Message>>(newMsg, arg).Compile(); 
} 

}