Transmettre au type générique en C#

Question

J'ai un dictionnaire pour mapper un certain type à un certain objet générique pour ce type. Par exemple:

typeof(LoginMessage) maps to MessageProcessor<LoginMessage> 

Le problème est maintenant de récupérer cet objet générique à l'exécution à partir du dictionnaire. Ou pour être plus précis: Pour convertir l'objet récupéré en type générique spécifique.

je en ai besoin de travailler quelque chose comme ceci:

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

Hope il y a une solution facile à ce sujet.

Éditer: Je ne souhaite pas utiliser les Ifs et les commutateurs. En raison de problèmes de performance, je ne peux pas non plus utiliser de réflexion.

Answer 1

Est-ce que ce travail pour vous?

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); 
    } 
} 

Ceci vous donne l'objet correct. La seule chose dont je ne suis pas sûr est de savoir si c'est suffisant dans votre cas pour l'avoir en tant que MessageProcessor abstrait.

Modifier: J'ai ajouté une interface IMessage. Le code de traitement réel devrait maintenant faire partie des différentes classes de message qui devraient toutes implémenter cette interface.

Answer 2

Vous ne pouvez pas faire cela. Vous pourriez essayer de dire à votre problème d'un point de vue plus haut niveau (c'est-à-dire ce que vous voulez accomplir avec la variable casted) pour une solution différente.

Vous pouvez aller avec quelque chose comme ceci:

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); 

C'est le meilleur que vous pouvez faire, mais sans réellement savoir quel type il est, il n'y a vraiment pas beaucoup plus que vous pouvez faire avec elle.

EDIT: Je devrais clarifier. Je suis passé du type var au type Type. Mon point est, maintenant, vous pouvez faire quelque chose comme ceci:

object obj = Activator.CreateInstance(type); 

obj sera désormais le bon type, mais puisque vous ne savez pas quel type « clé » est au moment de la compilation, il n'y a aucun moyen de le jeter et faire quelque chose d'utile avec cela.

Answer 4

Comme mentionné, vous ne pouvez pas le lancer directement. Une solution possible consiste à faire hériter ces types génériques d'une interface non générique, auquel cas vous pouvez toujours invoquer des méthodes sans réflexion. En utilisant la réflexion, vous pouvez passer l'objet mappé à n'importe quelle méthode qui l'attend, puis la distribution sera effectuée pour vous. Donc, si vous avez une méthode appelée Accepter un MessageProcessor en tant que paramètre, vous pouvez le trouver et l'appeler dynamiquement.

Answer 5

Cela est tout simplement permis:

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

Vous ne pouvez pas obtenir un type générique en tant que valeur variable.

Vous auriez à faire un interrupteur ou quelque chose:

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

Vous pouvez écrire une méthode qui prend le type comme paramètre générique:

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

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

Ensuite, vous avez besoin d'un moyen d'appeler la méthode avec l'argument générique correct. Vous pouvez le faire avec la réflexion:

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

S'il vous plaît voir si la solution suivante fonctionne pour vous. L'astuce consiste à définir une interface de processeur de base qui prend un type de message de base.

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

J'ai eu un problème similaire. J'ai un cours;

Action<T> 

qui a une propriété de type T.

Comment puis-je obtenir la propriété quand je ne sais pas T? Je ne peux pas jeter à l'action <> à moins que je sais T.

SOLUTION:

Mettre en œuvre une interface non générique;

public interface IGetGenericTypeInstance 
{ 
    object GenericTypeInstance(); 
} 

Maintenant, je peux jeter l'objet à IGetGenericTypeInstance et GenericTypeInstance renverra la propriété comme objet de type.

Answer 9

Ce qui suit semble fonctionner aussi bien, et il est un peu plus courte que les autres réponses:

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

Answer 10

La réponse de @DanielPlaisted avant que les travaux en général, mais la méthode générique doit être public ou il faut utiliser BindingFlags.NonPublic | BindingFlags.Instance! Impossible de poster comme commentaire pour manque de réputation.

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

J'ai eu du mal à résoudre un problème similaire autour des classes de tables de données au lieu des messages. Le problème racine mentionné ci-dessus de la conversion d'une version non générique de la classe en une version générique dérivée était le même. Afin de permettre l'injection dans une bibliothèque de classes portable qui ne supportait pas les bibliothèques de bases de données, j'ai introduit un ensemble de classes d'interface, dans le but de pouvoir transmettre un type et obtenir un générique correspondant. Il a fini par avoir besoin d'implémenter une méthode générique.

// 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>(); 
} 

Et cela l'ensemble de l'implémentation en utilisant la méthode générique ci-dessus.

La classe générique qui sera issue d'un dictionnaire.

// 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)) 
    { 
    } 
} 

C'est la classe qui stocke la classe générique et il jette pour satisfaire la méthode générique dans l'interface

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>; 
    } 
} 

Et enfin l'appel de la méthode d'interface.

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