Generics Azure服务总线代理消息泵，等待多种消息类型

我有一个消息泵，看起来像这样：

public class MessagePump<T> where T : class
    {
        public async Task Run( string inQueue, IMessageProcessor<T> processor, CancellationToken cancellationToken)
        {
            var connectionString = Settings.ServiceBusConnectionString;
            var factory = MessagingFactory.CreateFromConnectionString(connectionString);
            var client = factory.CreateQueueClient(inQueue);
            var msgOptions = new OnMessageOptions
            {
                AutoComplete = false,
                MaxConcurrentCalls = 5,
                AutoRenewTimeout = TimeSpan.FromMinutes(10)
            };
            await Task.Run(() =>
            client.OnMessageAsync(
              async message =>
              {
                  await OnReceived(message, processor);
                  await message.CompleteAsync();
              }, msgOptions),
              cancellationToken);
        }
        static async Task OnReceived(BrokeredMessage brokeredMessage, IMessageProcessor<T> processor)
        {
            var message = brokeredMessage.GetBody<T>();
            try
            {
                await processor.Process(message);
            }
            catch (Exception e)
            {
                var er = new ErrorLog();
                await er.Create(new {error = e.Message});
            }

        }
    }

公共类消息泵，其中T:class
{
公共异步任务运行（队列中的字符串、IMessageProcessor处理器、CancellationToken CancellationToken）
{
var connectionString=Settings.ServiceBusConnectionString；
var factory=MessagingFactory.CreateFromConnectionString（connectionString）；
var client=factory.CreateQueueClient（inQueue）；
var msgOptions=新的OnMessageOptions
{
自动完成=错误，
MaxConcurrentCalls=5，
AutoRenewTimeout=TimeSpan.FromMinutes（10）
};
等待任务。运行（（）=>
client.OnMessageAsync(
异步消息=>
{
等待接收（消息、处理器）；
等待消息。CompleteAsync（）；
}，msgOptions），
取消令牌）；
}
静态异步任务OnReceived（BrokeredMessage BrokeredMessage，IMessageProcessor处理器）
{
var message=brokeredMessage.GetBody（）；
尝试
{
等待处理器进程（消息）；
}
捕获（例外e）
{
var er=新的错误日志（）；
wait er.Create（new{error=e.Message}）；
}
}
}

它是从Azure服务结构中的无状态服务调用的

internal sealed class Core : StatelessService
    {
        public Core(StatelessServiceContext context)
            : base(context)
        { }


        protected override IEnumerable<ServiceInstanceListener> CreateServiceInstanceListeners()
        {
            return new ServiceInstanceListener[0];
        }

        protected override async Task RunAsync(CancellationToken cancellationToken)
        {
            var inQueue = Settings.CoreQueue;
            await new MessagePump<Message>().Run(inQueue, new Processor(), cancellationToken);

        }
    }

内部密封类核心：无状态服务
{
公共核心（无状态ServiceContext上下文）
：基本（上下文）
{ }
受保护的重写IEnumerable CreateServiceInstanceListeners（）
{
返回新的ServiceInstanceListener[0]；
}
受保护的覆盖异步任务RunAsync（CancellationToken CancellationToken）
{
var inQueue=Settings.CoreQueue；
等待新消息泵（）.Run（inQueue，新处理器（），cancellationToken）；
}
}

如何创建处理多种类型消息的消息泵？

有几个选项：

将所有类型编码为一个容器类型的一部分（例如，从一个基类派生它们，或者将它们全部放入容器类型的属性中）。始终反序列化此容器，然后根据其内容对其进行处理

将消息类型放入元数据（例如

ContentType

代理消息的

property

属性）。读取此元数据后反序列化为特定类型

调用

GetBody

，它只返回一个字节数组，并自己处理反序列化。如果您不控制发送方，可能是唯一的选项

有几种选择：

将所有类型编码为一个容器类型的一部分（例如，从一个基类派生它们，或将它们全部放入容器类型的属性中）。始终反序列化此容器，然后根据其内容处理它

将消息类型放入元数据（例如

ContentType

代理消息的

property

属性）。读取此元数据后反序列化为特定类型

调用

GetBody

，它只返回一个字节数组，并自己处理反序列化。如果您不控制发送方，可能是唯一的选项

我认为#2是最好的解决方案！！（考虑到有能力设计发送者）#1创造了一个大梅西认为#2是最好的解决方案！！（考虑到有能力设计发送者）#1创造了一个大混乱