我有一个字典来将某种类型映射到该类型的某个通用对象。例如：
typeof(LoginMessage) maps to MessageProcessor<LoginMessage>
现在的问题是在运行时从字典中检索这个通用对象。或者更具体一点：将检索到的对象转换为特定的泛型类型。
我需要它来做这样的事情：
Type key = message.GetType();
MessageProcessor<key> processor = messageProcessors[key] as MessageProcessor<key>;
希望有一个简单的解决方案。
编辑： 我不想使用 Ifs 和开关。由于性能问题，我也不能使用某种反射。
【问题讨论】：
以下似乎也有效，并且比其他答案短一点：
T result = (T)Convert.ChangeType(otherTypeObject, typeof(T));
【讨论】：
这对你有用吗？
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);
}
}
这会给你正确的对象。我唯一不确定的是，在您的情况下，将其作为抽象 MessageProcessor 是否足够。
编辑：我添加了一个 IMessage 接口。实际的处理代码现在应该成为应该实现这个接口的不同消息类的一部分。
【讨论】：
Message<string>，而不是 string。这个想法是正确的。
我遇到了类似的问题。我有课；
Action<T>
具有类型 T 的属性。
当我不知道 T 时，我如何获得该属性？除非我知道 T，否则我无法投射到 Action。
解决方案：
实现一个非泛型接口；
public interface IGetGenericTypeInstance
{
object GenericTypeInstance();
}
现在我可以将对象转换为 IGetGenericTypeInstance 并且 GenericTypeInstance 会将属性作为类型对象返回。
【讨论】：
Type type = typeof(MessageProcessor<>).MakeGenericType(key);
这是你能做的最好的事情，但是在不知道它是什么类型的情况下，你真的无能为力。
编辑：我应该澄清一下。我从 var 类型更改为 Type 类型。我的意思是，现在你可以这样做：
object obj = Activator.CreateInstance(type);
obj 现在将是正确的类型，但是由于您在编译时不知道“key”是什么类型，因此无法对其进行强制转换并对其进行任何有用的操作。
【讨论】：
var 只是在编译时解析的语法糖。 type 变量的类型将是 System.Type。
您可以编写一个将类型作为泛型参数的方法：
void GenericProcessMessage<T>(T message)
{
MessageProcessor<T> processor = messageProcessors[typeof(T)]
as MessageProcessor<T>;
// Call method processor or whatever you need to do
}
然后您需要一种方法来使用正确的泛型参数调用该方法。您可以通过反射来做到这一点：
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});
}
【讨论】：
请查看以下解决方案是否适合您。诀窍是定义一个基本处理器接口，它采用基本类型的消息。
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();
}
}
【讨论】：
你不能那样做。您可以尝试从更高级别的角度（即您想使用转换变量完成什么）来解决您的问题，以获得不同的解决方案。
你可以这样做：
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);
【讨论】：
key 类型...
这是绝对不允许的：
Type key = message.GetType();
MessageProcessor<key> processor = messageProcessors[key] as MessageProcessor<key>;
您不能将泛型类型作为变量值。
您必须进行切换或其他操作：
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
}
...
【讨论】：
如前所述，您不能直接施放它。一种可能的解决方案是让这些泛型类型从非泛型接口继承，在这种情况下，您仍然可以在其上调用方法而无需反射。使用反射，您可以将映射对象传递给任何期望它的方法，然后将为您执行转换。因此，如果您有一个名为 Accept 的方法，期望 MessageProcessor 作为参数，然后你可以找到它并动态调用它。
【讨论】：
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);
}
}
}
【讨论】：
@DanielPlaisted 之前的回答一般都可以，但是泛型方法必须是 public 或者必须使用BindingFlags.NonPublic | BindingFlags.Instance！由于缺乏声誉，无法将其作为评论发布。
【讨论】：
我努力解决围绕数据表类而不是消息的类似问题。上面提到的将类的非泛型版本转换为派生的泛型版本的根本问题是相同的。
为了允许注入到不支持数据库的可移植类库中，我引入了一组接口类，目的是我可以传递一个类型并获得一个匹配的泛型。它最终需要实现一个泛型方法。
// 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>();
}
这是使用上述通用方法的整个实现。
将从字典中强制转换的泛型类。
// 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))
{
}
}
这是存储泛型类并对其进行强制转换以满足接口中的泛型方法的类
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>;
}
}
最后是接口方法的调用。
IDatatable<CustomerAccount> table = _database.GetDataTable<CustomerAccount>();
【讨论】：
要将任何类型对象转换为泛型类型T，诀窍是首先分配给任何更高类型的对象，然后将其强制转换为泛型类型。
object temp = otherTypeObject;
T result = (T)temp;
【讨论】：