C# 如何将复合处理程序与嵌套的OpenGeneric一起使用？ 公共接口IMessage{} 公共接口ICommand:IMessage{} 公共接口IEvent:IMessage{} 公共接口IMessageHandler{ 无效句柄（T消息）； } 公共类ItemCreatedEvent:IEEvent{ 公共字符串名称{get；set；} } 公共类ValidateMessageInvelope{ 公共TMessage消息{get；set；} 公共ValidateMessageInvelope（TMessage消息）{ 消息=消息； } } 公共类ValidateMessageInvolopeHandler ：IMessageHandler{ 私有只读IMessageHandler\u innerHandler； 公共ValidateMessageInvelopeHandler（IMessageHandler innerHandler）{ _innerHandler=innerHandler； } 公共无效句柄（ValidateMessageInvelope消息）{ _Handle（message.message）； } } 公共类SecureMessageEnvelope{ 公共TMessage消息{get；set；} 公共字符串UserToken{get；set；} public SecureMessageEnvelope（TMessage message，字符串userToken）{ 消息=消息； UserToken=UserToken； } } 公共类SecureMessageEnveloperHandler ：IMessageHandler { 私有只读IMessageHandler\u innerHandler； public SecureMessageEnvelopeHandler（IMessageHandler innerHandler）{ _innerHandler=innerHandler； } 公共无效句柄（SecureMessageEnvelope消息）{ _Handle（message.message）； } } 公共类MessageLogDecorator:IMessageHandler where-TMessage:IEvent{ 私有只读IMessageHandler _messageHandler； public MessageLogDecorator（IMessageHandler messageHandler）{ _messageHandler=messageHandler； } 公共无效句柄（TMessage消息）{ WriteLine（“事件日志：{0}”，JsonConvert.SerializeObject（消息））； _Handle（message）； } } 公共类CompositeMessageHandler:IMessageHandler{ 私有只读IEnumerable\u处理程序； 公共复合消息处理程序（IEnumerable处理程序）{ _处理者=处理者； } 公共无效句柄（TMessage消息）{ foreach（var messageHandler in_handlers）{ Handle（message）； } } } 公共类日志服务：IMessageHandler{ 公共无效句柄（ItemCreatedEvent消息）{} } 公共类ProjectionService:IMessageHandler{ 公共无效句柄（ItemCreatedEvent消息）{} } 公共静态类扩展{ 公共静态SecureMessageEnvelope AssetCure( 此TMessage消息（字符串userToken）{ 返回新的SecureMessageEnvelope（消息、用户令牌）； } 公共静态ValidateMessageInvelope ASValidable( 此TMessage消息）{ 返回新的ValidateMessageInvelope（消息）； } }

登记册：

public interface IMessage { }
public interface ICommand : IMessage { }
public interface IEvent : IMessage { }

public interface IMessageHandler<T> {
    void Handle(T message);
}

public class ItemCreatedEvent : IEvent {
    public string Name { get; set; }
}

public class ValidateMessageEnvelope<TMessage> {
    public TMessage Message { get; set; }
    public ValidateMessageEnvelope(TMessage message){
        Message = message;
    }
}

public class ValidateMessageEnvelopeHandler<TMessage> 
    : IMessageHandler<ValidateMessageEnvelope<TMessage>> {
    private readonly IMessageHandler<TMessage> _innerHandler;
    public ValidateMessageEnvelopeHandler(IMessageHandler<TMessage> innerHandler){
        _innerHandler = innerHandler;
    }
    public void Handle(ValidateMessageEnvelope<TMessage> message){
        _innerHandler.Handle(message.Message);
    }
}

public class SecureMessageEnvelope<TMessage> {
    public TMessage Message { get; set; }
    public string UserToken { get; set; }
    public SecureMessageEnvelope(TMessage message, string userToken){
        Message = message;
        UserToken = userToken;
    }
}

public class SecureMessageEnvelopeHandler<TMessage> 
    : IMessageHandler<SecureMessageEnvelope<TMessage>>
{
    private readonly IMessageHandler<TMessage> _innerHandler;
    public SecureMessageEnvelopeHandler(IMessageHandler<TMessage> innerHandler){
         _innerHandler = innerHandler;
    }
    public void Handle(SecureMessageEnvelope<TMessage> message){
         _innerHandler.Handle(message.Message);
    }
}

public class MessageLogDecorator<TMessage> : IMessageHandler<TMessage> 
    where TMessage : IEvent {
    private readonly IMessageHandler<TMessage> _messageHandler;
    public MessageLogDecorator(IMessageHandler<TMessage> messageHandler) {
        _messageHandler = messageHandler;
    }
    public void Handle(TMessage message){
        Console.WriteLine("Event Log: {0}",JsonConvert.SerializeObject(message));
        _messageHandler.Handle(message);
    }
}

public class CompositeMessageHandler<TMessage> : IMessageHandler<TMessage> {
    private readonly IEnumerable<IMessageHandler<TMessage>> _handlers;
    public CompositeMessageHandler(IEnumerable<IMessageHandler<TMessage>> handlers){
        _handlers = handlers;
    }
    public void Handle(TMessage message) {
        foreach (var messageHandler in _handlers) {
            messageHandler.Handle(message);
        }
    }
}

public class LogService :IMessageHandler<ItemCreatedEvent> {
    public void Handle(ItemCreatedEvent message) {}
}

public class ProjectionService: IMessageHandler<ItemCreatedEvent> {
    public void Handle(ItemCreatedEvent message) { }
}

public static class Extensions{
    public static SecureMessageEnvelope<TMessage> AsSecure<TMessage>(
        this TMessage message, string userToken){
        return new SecureMessageEnvelope<TMessage>(message, userToken);
    }
    public static ValidateMessageEnvelope<TMessage> AsValidatable<TMessage>(
        this TMessage message){
        return new ValidateMessageEnvelope<TMessage>(message);
    }
}

Container.RegisterManyForOpenGeneric（typeof（IMessageHandler），
容器注册，
Assembly.getExecutionGassembly（））；
//处理所有ValidateMessageInvelope消息
Container.RegisterOpenGeneric（typeof（IMessageHandler）），
类型（ValidateMessageInvelopeHandler））；
//处理所有SecureMessageEnvelope消息
Container.RegisterOpenGeneric（typeof（IMessageHandler）），
类型（SecureMessageEnvelopeHandler））；
//处理所有IEvent消息
容器.RegisterDecorator（类型为（IMessageHandler），
类型（MessageLogDecorator））；

事件呼叫

Container.RegisterManyForOpenGeneric(typeof (IMessageHandler<>),
    Container.RegisterAll,
    Assembly.GetExecutingAssembly());

// handle all ValidateMessageEnvelope<TMessage> messages
Container.RegisterOpenGeneric(typeof(IMessageHandler<>),
    typeof(ValidateMessageEnvelopeHandler<>)); 

// handle all SecureMessageEnvelope<TMessage> messages
Container.RegisterOpenGeneric(typeof(IMessageHandler<>),
    typeof(SecureMessageEnvelopeHandler<>));

// handle all IEvent messages
Container.RegisterDecorator(typeof(IMessageHandler<>), 
    typeof(MessageLogDecorator<>));

var ev=new ItemCreatedEvent（）.AsSecure（“token/1”）.asvalidable（）；
var handlerType=typeof（IMessageHandler）.MakeGenericType（ev.GetType（））；
foreach（容器.GetAllInstances（handlerType）中的动态处理程序）{
handler.Handle（（动态）ev）；
}

返回空，但必须返回两个处理程序：

var ev = new ItemCreatedEvent().AsSecure("token/1").AsValidatable();
    var handlerType = typeof(IMessageHandler<>).MakeGenericType(ev.GetType());
    foreach (dynamic handler in _container.GetAllInstances(handlerType)){
        handler.Handle((dynamic)ev);    
    }

处理程序[0]=
新的ValidateMessageInvelopeHandler(
新SecureMessageEnvelopeHandler(
新MessageLogDecorator(
新日志服务（））；
处理程序[1]=
新的ValidateMessageInvelopeHandler(
新SecureMessageEnvelopeHandler(
新MessageLogDecorator(
新ProjectionService（））；

尽管这样会很好：

handler[0] = 
    new ValidateMessageEnvelopeHandler<SecureMessageEnvelope<ItemCreatedEvent>>(
        new SecureMessageEnvelopeHandler<ItemCreatedEvent>(
            new MessageLogDecorator<ItemCreatedEvent>(
                new LogService())));

handler[1] = 
    new ValidateMessageEnvelopeHandler<SecureMessageEnvelope<ItemCreatedEvent>>(
        new SecureMessageEnvelopeHandler<ItemCreatedEvent>(
            new MessageLogDecorator<ItemCreatedEvent>(
                new ProjectionService())));

新建ValidateMessageInvelopeHandler(
新SecureMessageEnvelopeHandler(
新型复合机(
新MessageLogDecorator(
新日志服务（）），
新MessageLogDecorator(
新ProjectionService（））；

如果我调用“\u container.GetInstance（handlerType）”而不是“GetAllInstances”，则会发生错误：

注册开放泛型类型时出错 IMessageHandler。未能为类型生成注册 ValidateMessageInvlopeHandler>。 注册开放泛型类型时出错 IMessageHandler。未能为类型生成注册 安全信息信封管理员。构造 SecureMessageEnveloperHandler类型包含 名为的IMessageHandler类型的参数 未注册的“innerHandler”。请确保 IMessageHandler已在容器中注册，或 更改的构造函数 安全信息信封管理员

注册CompositeHandler（）时出现错误。（Container.RegisterOpenGeneric（typeof（IMessageHandler），typeof（CompositeMessageHandler））；）

注册开放泛型类型时出错 IMessageHandler。未能为类型生成注册 ValidateMessageInvlopeHandler>。 ResolveUnregisteredType事件的多个观察者是 为同一服务类型注册委托： IMessageHandler>。确保 只有一个已注册的处理程序调用 ResolveUnregistedType。给定服务类型的Register方法

---

如何修复此问题？

您的配置不起作用，因为您做错了两件事：

您没有注册

CompositeMessageHandler

您正在调用

GetAllInstances

，而不是

GetInstance

当您调用

GetAllInstances

时，只会得到一组处理程序

new ValidateMessageEnvelopeHandler<SecureMessageEnvelope<ItemCreatedEvent>>(
    new SecureMessageEnvelopeHandler<ItemCreatedEvent>(
        new CompositeHandler(
            new MessageLogDecorator<ItemCreatedEvent>(
                new LogService()),
            new MessageLogDecorator<ItemCreatedEvent>(
                new ProjectionService()))));

container.RegisterOpenGeneric(
    typeof(IMessageHandler<>), 
    typeof(CompositeMessageHandler<>),
    Lifestyle.Singleton, 
    context => !context.Handled);

var ev = new ItemCreatedEvent().AsSecure("token/1").AsValidatable();
var handlerType = typeof(IMessageHandler<>).MakeGenericType(ev.GetType());

dynamic handler = container.GetInstance(handlerType);

handler.Handle((dynamic)ev);

container.RegisterDecorator(typeof(IMessageHandler<>),
    typeof(MessageLogDecorator<>), context =>
    {
        var type = context.ImplementationType;
        return !type.IsGenericType ||
            type.GetGenericTypeDefinition() != typeof(CompositeMessageHandler<>));
    });

container.RegisterDecorator(typeof(IMessageHandler<>),
    typeof(MessageLogDecorator<>), 
    context => !context.ImplementationType.IsGenericType);