1

在试图强迫 Windsor 用随机数量的装饰器包装实现时，我偶然发现了以下内容：

我有 3 个装饰器和一个实现，它们都使用相同的接口。

如果您运行此代码，windsor 将解析icommandhandler<stringcommand>为implementation，据我所知，这是预期的行为，因为类型化实现无法使用开放类型化装饰器注册。

但是，如果您取消注释该行container.Register(Component.For<ICommandHandler<stringCommand>>().ImplementedBy<Decorator1<stringCommand>>());，所有三个装饰器都将用于解析implementation，这是所需的结果（类似于 : ）。

class Program
{
    static void Main(string[] args)
    {
        var container = new WindsorContainer();

        container.Register(Component.For(typeof(ICommandHandler<>)).ImplementedBy(typeof(Decorator1<>)));
        container.Register(Component.For(typeof(ICommandHandler<>)).ImplementedBy(typeof(Decorator2<>)));
        container.Register(Component.For(typeof(ICommandHandler<>)).ImplementedBy(typeof(Decorator3<>)));

        //uncomment the line below and watch the magic happen
        //container.Register(Component.For<ICommandHandler<stringCommand>>().ImplementedBy<Decorator1<stringCommand>>());
        container.Register(Component.For<ICommandHandler<stringCommand>>().ImplementedBy<implementation>());

        var stringCommandHandler = container.Resolve<ICommandHandler<stringCommand>>();
        var command = new stringCommand();
        stringCommandHandler.Handle(command);

        Console.WriteLine(command.s);
        Console.ReadKey();
    }
}

public interface ICommandHandler<T>
{
    void Handle(T t);
}

public class stringCommand
{
    public string s { get; set; }
}

public abstract class Decorator<T> : ICommandHandler<T>
{
    public abstract void Handle(T t);
};

public class Decorator1<T> : Decorator<T>
    where T : stringCommand
{
    private ICommandHandler<T> _handler;
    public Decorator1(ICommandHandler<T> handler)
    {
        _handler = handler;
    }

    public override void Handle(T t)
    {
        t.s += "Decorator1;";
        _handler.Handle(t);
    }
}

public class Decorator2<T> : Decorator<T>
    where T : stringCommand
{
    private ICommandHandler<T> _handler;
    public Decorator2(ICommandHandler<T> handler)
    {
        _handler = handler;
    }

    public override void Handle(T t)
    {
        t.s += "Decorator2;";
        _handler.Handle(t);
    }
}
public class Decorator3<T> : Decorator<T>
    where T : stringCommand
{
    private ICommandHandler<T> _handler;
    public Decorator3(ICommandHandler<T> handler)
    {
        _handler = handler;
    }

    public override void Handle(T t)
    {
        t.s += "Decorator3;";
        _handler.Handle(t);
    }
}

public class implementation : ICommandHandler<stringCommand>
{
    public void Handle(stringCommand t)
    {
        t.s += "implementation;";
    }
}

为什么会发生这种情况，这是我不知道的温莎特色吗？是否有不同的方法可以达到相同的效果？（不诉诸反思）

4

1 回答 1

1

当 windsor 尝试解析组件时，它会首先尝试解析更具体的接口。因此，当您注册 Component.For 时，它将更愿意通过开放的泛型类型来解决此问题。

如果多次注册同一个接口，它将使用第一个指定的接口。

因此，如果您不取消注释您的应用程序将解决实施的行，因为这是最具体的组件。

如果您取消注释，则装饰器 1 行将被解析，并且魔法确实开始了。装饰器现在将开始寻找第一个满足其构造函数的注册组件，在这种情况下，这将是 decorator1（您确实注意到您的输出显示 decorator1 2 次？）。哪个将解析下一个注册的组件，依此类推，直到实际实现。

所以我唯一能想到的就是不将 decorator1 注册为一个开放的泛型，而是注册为一个特定的类型。

亲切的问候，马尔维恩。

于 2013-06-14T07:53:30.127 回答