Truyền sang loại chung trong C#

Question

Tôi có một từ điển để ánh xạ một loại nhất định cho một đối tượng chung nhất định cho loại đó. Ví dụ:

typeof(LoginMessage) maps to MessageProcessor<LoginMessage> 

Bây giờ, vấn đề là truy xuất đối tượng chung này khi chạy từ điển. Hoặc cụ thể hơn: Để truyền đối tượng đã truy xuất đến loại chung chung cụ thể.

tôi cần nó để làm việc gì đó như thế này:

Type key = message.GetType(); 
MessageProcessor<key> processor = messageProcessors[key] as MessageProcessor<key>; 

Hope có một giải pháp dễ dàng cho việc này.

Chỉnh sửa: Tôi không muốn sử dụng If và switch. Do các vấn đề hiệu suất, tôi không thể sử dụng sự phản chiếu của một số loại nào đó.

Answer 1

Điều này làm việc cho bạn?

interface IMessage 
{ 
    void Process(object source); 
} 

class LoginMessage : IMessage 
{ 
    public void Process(object source) 
    { 
    } 
} 

abstract class MessageProcessor 
{ 
    public abstract void ProcessMessage(object source, object type); 
} 

class MessageProcessor<T> : MessageProcessor where T: IMessage 
{ 
    public override void ProcessMessage(object source, object o) 
    { 
     if (!(o is T)) { 
      throw new NotImplementedException(); 
     } 
     ProcessMessage(source, (T)o); 
    } 

    public void ProcessMessage(object source, T type) 
    { 
     type.Process(source); 
    } 
} 


class Program 
{ 
    static void Main(string[] args) 
    { 
     Dictionary<Type, MessageProcessor> messageProcessors = new Dictionary<Type, MessageProcessor>(); 
     messageProcessors.Add(typeof(string), new MessageProcessor<LoginMessage>()); 
     LoginMessage message = new LoginMessage(); 
     Type key = message.GetType(); 
     MessageProcessor processor = messageProcessors[key]; 
     object source = null; 
     processor.ProcessMessage(source, message); 
    } 
} 

Điều này cung cấp cho bạn đối tượng chính xác. Điều duy nhất tôi không chắc chắn về việc liệu nó là đủ trong trường hợp của bạn để có nó như là một MessageProcessor trừu tượng.

Chỉnh sửa: Tôi đã thêm giao diện IMessage. Mã xử lý thực tế bây giờ sẽ trở thành một phần của các lớp thông báo khác nhau mà tất cả nên thực hiện giao diện này.

Answer 2

Bạn không thể làm điều đó. Bạn có thể thử nói với vấn đề của bạn từ một quan điểm cấp cao hơn (tức là chính xác bạn muốn đạt được gì với biến được đúc) cho một giải pháp khác.

Bạn có thể đi với một cái gì đó như thế này:

public abstract class Message { 
    // ... 
} 
public class Message<T> : Message { 
} 

public abstract class MessageProcessor { 
    public abstract void ProcessMessage(Message msg); 
} 
public class SayMessageProcessor : MessageProcessor { 
    public override void ProcessMessage(Message msg) { 
     ProcessMessage((Message<Say>)msg); 
    } 
    public void ProcessMessage(Message<Say> msg) { 
     // do the actual processing 
    } 
} 

// Dispatcher logic: 
Dictionary<Type, MessageProcessor> messageProcessors = { 
    { typeof(Say), new SayMessageProcessor() }, 
    { typeof(string), new StringMessageProcessor() } 
}; // properly initialized 

messageProcessors[msg.GetType().GetGenericArguments()[0]].ProcessMessage(msg); 

Answer 3

Type type = typeof(MessageProcessor<>).MakeGenericType(key); 

Đó là tốt nhất bạn có thể làm, tuy nhiên mà không thực sự biết những gì loại đó là, có thực sự không nhiều hơn nữa bạn có thể làm gì với nó.

CHỈNH SỬA: Tôi nên làm rõ. Tôi đã thay đổi từ loại var thành Type type. Quan điểm của tôi là, bây giờ bạn có thể làm một cái gì đó như thế này:

object obj = Activator.CreateInstance(type); 

tại obj sẽ đúng loại, nhưng kể từ khi bạn không biết những gì kiểu "chìa khóa" là tại thời gian biên dịch, không có cách nào để cast nó và làm bất cứ điều gì hữu ích với nó.

Answer 4

Như đã đề cập, bạn không thể truyền trực tiếp. Một giải pháp có thể là có những kiểu generic này kế thừa từ một giao diện không chung chung, trong trường hợp này bạn vẫn có thể gọi các phương thức trên nó mà không cần phản ánh. Sử dụng sự phản chiếu, bạn có thể truyền đối tượng được ánh xạ tới bất kỳ phương thức nào mong đợi nó, sau đó diễn viên sẽ được thực hiện cho bạn. Vì vậy, nếu bạn có một phương pháp được gọi là Chấp nhận mong đợi một MessageProcessor như một tham số, sau đó bạn có thể tìm thấy nó và gọi nó tự động.

Answer 5

này chỉ đơn giản là không được phép:

Type key = message.GetType(); 
MessageProcessor<key> processor = messageProcessors[key] as MessageProcessor<key>; 

Bạn không thể có được một kiểu generic như một giá trị biến.

Bạn sẽ phải làm một switch hoặc một cái gì đó:

Type key = message.GetType(); 
if (key == typeof(Foo)) 
{ 
    MessageProcessor<Foo> processor = (MessageProcessor<Foo>)messageProcessors[key]; 
    // Do stuff with processor 
} 
else if (key == typeof(Bar)) 
{ 
    MessageProcessor<bar> processor = (MessageProcessor<Bar>)messageProcessors[key]; 
    // Do stuff with processor 
} 
... 

Answer 6

Bạn có thể viết một phương pháp mà có loại như một tham số chung:

void GenericProcessMessage<T>(T message) 
{ 
    MessageProcessor<T> processor = messageProcessors[typeof(T)] 
     as MessageProcessor<T>; 

    // Call method processor or whatever you need to do 
} 

Sau đó, bạn cần một cách để gọi các phương pháp với lập luận chung đúng. Bạn có thể làm điều này với sự phản ánh:

public void ProcessMessage(object message) 
{ 
    Type messageType = message.GetType(); 
    MethodInfo method = this.GetType().GetMethod("GenericProcessMessage"); 
    MethodInfo closedMethod = method.MakeGenericMethod(messageType); 
    closedMethod.Invoke(this, new object[] {message}); 
} 

Answer 7

Vui lòng xem giải pháp sau đây có phù hợp với bạn hay không. Bí quyết là xác định một giao diện bộ vi xử lý cơ sở mà lấy một kiểu cơ bản của thông báo.

interface IMessage 
{ 
} 

class LoginMessage : IMessage 
{ 
} 

class LogoutMessage : IMessage 
{ 
} 

class UnknownMessage : IMessage 
{ 
} 

interface IMessageProcessor 
{ 
    void PrcessMessageBase(IMessage msg); 
} 

abstract class MessageProcessor<T> : IMessageProcessor where T : IMessage 
{ 
    public void PrcessMessageBase(IMessage msg) 
    { 
     ProcessMessage((T)msg); 
    } 

    public abstract void ProcessMessage(T msg); 

} 

class LoginMessageProcessor : MessageProcessor<LoginMessage> 
{ 
    public override void ProcessMessage(LoginMessage msg) 
    { 
     System.Console.WriteLine("Handled by LoginMsgProcessor"); 
    } 
} 

class LogoutMessageProcessor : MessageProcessor<LogoutMessage> 
{ 
    public override void ProcessMessage(LogoutMessage msg) 
    { 
     System.Console.WriteLine("Handled by LogoutMsgProcessor"); 
    } 
} 

class MessageProcessorTest 
{ 
    /// <summary> 
    /// IMessage Type and the IMessageProcessor which would process that type. 
    /// It can be further optimized by keeping IMessage type hashcode 
    /// </summary> 
    private Dictionary<Type, IMessageProcessor> msgProcessors = 
           new Dictionary<Type, IMessageProcessor>(); 
    bool processorsLoaded = false; 

    public void EnsureProcessorsLoaded() 
    { 
     if(!processorsLoaded) 
     { 
      var processors = 
       from processorType in Assembly.GetExecutingAssembly().GetTypes() 
       where processorType.IsClass && !processorType.IsAbstract && 
         processorType.GetInterface(typeof(IMessageProcessor).Name) != null 
       select Activator.CreateInstance(processorType); 

      foreach (IMessageProcessor msgProcessor in processors) 
      { 
       MethodInfo processMethod = msgProcessor.GetType().GetMethod("ProcessMessage"); 
       msgProcessors.Add(processMethod.GetParameters()[0].ParameterType, msgProcessor); 
      } 

      processorsLoaded = true; 
     } 
    } 

    public void ProcessMessages() 
    { 
     List<IMessage> msgList = new List<IMessage>(); 
     msgList.Add(new LoginMessage()); 
     msgList.Add(new LogoutMessage()); 
     msgList.Add(new UnknownMessage()); 

     foreach (IMessage msg in msgList) 
     { 
      ProcessMessage(msg); 
     } 
    } 

    public void ProcessMessage(IMessage msg) 
    { 
     EnsureProcessorsLoaded(); 
     IMessageProcessor msgProcessor = null; 
     if(msgProcessors.TryGetValue(msg.GetType(), out msgProcessor)) 
     { 
      msgProcessor.PrcessMessageBase(msg); 
     } 
     else 
     { 
      System.Console.WriteLine("Processor not found"); 
     } 
    } 

    public static void Test() 
    { 
     new MessageProcessorTest().ProcessMessages(); 
    } 
} 

Answer 8

Tôi gặp sự cố tương tự. Tôi có một lớp học;

Action<T> 

trong đó có một loại tài sản của T.

Làm thế nào để có được tài sản khi tôi không biết T? Tôi không thể đúc to Action <> trừ khi tôi biết T.

SOLUTION:

Thực hiện một giao diện không chung;

public interface IGetGenericTypeInstance 
{ 
    object GenericTypeInstance(); 
} 

Bây giờ tôi có thể đưa đối tượng vào IGetGenericTypeInstance và GenericTypeInstance sẽ trả về thuộc tính làm đối tượng kiểu.

Answer 9

Sau đây dường như làm việc là tốt, và nó ngắn hơn các câu trả lời khác một chút:

T result = (T)Convert.ChangeType(otherTypeObject, typeof(T)); 

Answer 10

Câu trả lời của @DanielPlaisted trước thường hoạt động, nhưng phương pháp chung phải được công khai hoặc người ta phải sử dụng BindingFlags.NonPublic | BindingFlags.Instance! Không thể đăng nó dưới dạng nhận xét vì thiếu danh tiếng.

Answer 11

public delegate void MessageProcessor<T>(T msg) where T : IExternalizable; 


    virtual public void OnRecivedMessage(IExternalizable msg) 
    { 
     Type type = msg.GetType(); 
     ArrayList list = processors.Get(type); 
     if (list != null) 
     { 
      object[] args = new object[]{msg}; 
      for (int i = list.Count - 1; i >= 0; --i) 
      { 
       Delegate e = (Delegate)list[i]; 
       e.Method.Invoke(e.Target, args); 
      } 
     } 
    } 

Answer 12

Tôi cố gắng giải quyết vấn đề tương tự xung quanh lớp bảng dữ liệu thay vì thư. Các vấn đề gốc được đề cập ở trên của đúc một phiên bản không chung chung của lớp để một phiên bản chung có nguồn gốc là như nhau.

Để cho phép tiêm vào thư viện lớp di động không hỗ trợ thư viện cơ sở dữ liệu, tôi đã giới thiệu một tập hợp các lớp giao diện, với mục đích tôi có thể vượt qua một loại và nhận được kết hợp chung. Nó đã kết thúc cần phải thực hiện một phương pháp chung chung.

// Interface for injection 
public interface IDatabase 
{ 
    // Original, non-functional signature: 
    IDatatable<object> GetDataTable(Type dataType); 

    // Functional method using a generic method: 
    IDatatable<T> GetDataTable<T>(); 
} 

Và điều này thực hiện toàn bộ bằng cách sử dụng phương pháp chung ở trên.

Lớp chung sẽ được truyền từ từ điển.

// Non-generic base class allows listing tables together 
abstract class Datatable 
{ 
    Datatable(Type storedClass) 
    { 
     StoredClass = storedClass; 
    } 

    Type StoredClass { get; private set; } 
} 

// Generic inheriting class 
abstract class Datatable<T>: Datatable, IDatatable<T> 
{ 
    protected Datatable() 
     :base(typeof(T)) 
    { 
    } 
} 

Đây là lớp học mà các cửa hàng lớp generic và phôi nó để đáp ứng các phương pháp chung trong giao diện

class Database 
{ 
    // Dictionary storing the classes using the non-generic base class 
    private Dictionary<Type, Datatable> _tableDictionary; 

    protected Database(List<Datatable> tables) 
    { 
     _tableDictionary = new Dictionary<Type, Datatable>(); 
     foreach (var table in tables) 
     { 
      _tableDictionary.Add(table.StoredClass, table); 
     } 
    } 

    // Interface implementation, casts the generic 
    public IDatatable<T> GetDataTable<T>() 
    { 
     Datatable table = null; 

     _tableDictionary.TryGetValue(typeof(T), out table); 

     return table as IDatatable<T>; 
    } 
} 

Và cuối cùng sự kêu gọi của phương pháp giao diện.

IDatatable<CustomerAccount> table = _database.GetDataTable<CustomerAccount>();