c# - 如何将消息反序列化为强类型对象，然后为该消息动态调用运行时分配的处理程序
问题描述
呸，什么标题……
我正在为一个学习项目开发服务器。我花了很长时间试图弄清楚如何正确地提出这个问题。一开始，我认为我什至不知道自己想要达到什么目标。
我正在使用的是具有 N 个组件（N >= 0）的服务器。
- 每个组件都是在运行时使用 DI 添加的。
- 每个组件都是一个“黑匣子”。当它收到一条消息时，它被认为是一个“工作单元”，并拥有从头到尾所需的一切。
- 每个组件负责为
subscribinga提供信息，并为该消息message提供 a 。handler我计划使用函数上的属性来实现这一点handler。
“处理程序”的示例：
[Handles(ExampleMessage)]
private void handleExampleMessage(ExampleMessage message)
{
DoStuff();
}
这是我能想到的提出问题的最清晰的方法：
如何实现类型化的“消息代理”系统，例如 ASP.NET MVC 如何从序列化输入中向 a 提供类型化模型。controller action
所以我想要实现的是：
Serialized message-> Strongly typed message-> message service->call handler function with *strongly typed* message as an argument
我想到了几件事：
我尝试的第一件事就是简单地将消息反序列化为 a dynamic，但没有 inellisense 和编译时检查dynamic对我来说成本太高了。
然后我尝试在运行时使用反射创建静态反序列化方法，并使用这些方法的返回值来调用“处理程序”，但它变得如此丑陋和意大利面，我不得不放弃它（虽然我当然仍然开放如果有人有优雅、注重性能的方式，则选择此选项）
最后，我尝试使用所有消息都继承自的类型，但是当我尝试使用 a调用适当的处理程序Message时，我最终陷入困境Dictionary<Action<Message>, Message>
解决方案
这是可能的，只是有点复杂。您要做的是在组件中搜索具有您的Handles属性的方法，并通过反射调用它们。
假设我们有以下接口：
public interface IComponent
{
}
public interface IMessage
{
};
让我们还创建一个Handles属性，让我们将方法标记为处理特定的消息类型：
[AttributeUsage(AttributeTargets.Method)]
public class HandlesAttribute : Attribute
{
public Type MessageType { get; private set; }
public HandlesAttribute(Type messageType)
{
MessageType = messageType;
}
};
现在我们将创建一个消息代理，它将负责在给定的组件列表中查找所有消息处理方法。我们将使用反射来做到这一点。首先，我们将找到所有具有该Handles属性的方法，然后我们将检查它们是否具有所需的单个IMessage参数：
public class MessageBroker
{
// Encapsulates a target object and a method to call on that object.
// This is essentially our own version of a delegate that doesn't require
// us to explicitly name the type of the arguments the method takes.
private class Handler
{
public IComponent Component;
public MethodInfo Method;
};
private Dictionary<Type, List<Handler>> m_messageHandlers = new Dictionary<Type, List<Handler>>();
public MessageBroker(List<IComponent> components)
{
foreach (var component in components)
{
var componentType = component.GetType();
// Get all private and public methods.
var methods = componentType.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
foreach (var method in methods)
{
// If this method doesn't have the Handles attribute then ignore it.
var handlesAttributes = (HandlesAttribute[])method.GetCustomAttributes(typeof(HandlesAttribute), false);
if (handlesAttributes.Length != 1)
continue;
// The method must have only one argument.
var parameters = method.GetParameters();
if (parameters.Length != 1)
{
Console.WriteLine(string.Format("Method {0} has too many arguments", method.Name));
continue;
}
// That one argument must be derived from IMessage.
if (!typeof(IMessage).IsAssignableFrom(parameters[0].ParameterType))
{
Console.WriteLine(string.Format("Method {0} does not have an IMessage as an argument", method.Name));
continue;
}
// Success, so register!
RegisterHandler(handlesAttributes[0].MessageType, component, method);
}
}
}
// Register methodInfo on component as a handler for messageType messages.
private void RegisterHandler(Type messageType, IComponent component, MethodInfo methodInfo)
{
List<Handler> handlers = null;
if (!m_messageHandlers.TryGetValue(messageType, out handlers))
{
// If there are no handlers attached to this message type, create a new list.
handlers = new List<Handler>();
m_messageHandlers[messageType] = handlers;
}
var handler = new Handler() { Component = component, Method = methodInfo };
handlers.Add(handler);
}
}
上面的构造函数记录了一条警告消息并忽略了任何与我们需要的签名不匹配的方法（即，从 IMessage 派生的一个参数）。
现在让我们添加一个方法来处理消息。这将使用以下方法调用任何已注册的处理程序Invoke：
// Passes the given message to all registered handlers that are capable of handling this message.
public void HandleMessage(IMessage message)
{
List<Handler> handlers = null;
var messageType = message.GetType();
if (m_messageHandlers.TryGetValue(messageType, out handlers))
{
foreach (var handler in handlers)
{
var target = handler.Component;
var methodInfo = handler.Method;
// Invoke the method directly and pass in the method object.
// Note that this assumes that the target method takes only one parameter of type IMessage.
methodInfo.Invoke(target, new object[] { message });
}
}
else
{
Console.WriteLine(string.Format("No handler found for message of type {0}", messageType.FullName));
}
}
};
现在为了测试它，我们将使用这些示例消息和组件。我还添加了一些错误配置的测试方法（即错误的参数）：
public class ExampleMessageA : IMessage
{
};
public class ExampleMessageB : IMessage
{
};
public class ExampleComponent : IComponent
{
[Handles(typeof(ExampleMessageA))]
public void HandleMessageA(ExampleMessageA message)
{
Console.WriteLine(string.Format("Handling message of type ExampleMessageA: {0}", message.GetType().FullName));
}
[Handles(typeof(ExampleMessageB))]
public void HandleMessageB(ExampleMessageB message)
{
Console.WriteLine(string.Format("Handling message of type ExampleMessageB: {0}", message.GetType().FullName));
}
[Handles(typeof(ExampleMessageA))]
public void HandleMessageA_WrongType(object foo)
{
Console.WriteLine(string.Format("HandleMessageA_WrongType: {0}", foo.GetType().FullName));
}
[Handles(typeof(ExampleMessageA))]
public void HandleMessageA_MultipleArgs(object foo, object bar)
{
Console.WriteLine(string.Format("HandleMessageA_WrongType: {0}", foo.GetType().FullName));
}
}
最后把它们放在一起：
var components = new List<IComponent>() { new ExampleComponent() };
var messageBroker = new MessageBroker(components);
// A message has been received and deserialised into the correct type.
// For prototyping here we will just instantiate it.
var messageA = new ExampleMessageA();
messageBroker.HandleMessage(messageA);
var messageB = new ExampleMessageB();
messageBroker.HandleMessage(messageB);
您应该得到以下输出：
Method HandleMessageA_WrongType does not have an IMessage as an argument
Method HandleMessageA_MultipleArgs has too many arguments
Handling message of type ExampleMessageA: Program+ExampleMessageA
Handling message of type ExampleMessageB: Program+ExampleMessageB
您可以玩的完整小提琴就在这里。
要提高方法调用性能，您可以使用此处MethodInfo.Invoke提到的技术重写。