命名和非命名类型的Autofac集合

Question

我正在使用autofac并有大量的规则要解决，它们被传递到特定的验证器中，这些验证器使用一些通用规则和一些特定的规则。尼尼姆有一个.WhenInjectedInto属性，我知道.Named<T>("")给了我类似的功能。但

考虑到以下代码：

是否可以使用Foo和FooBar填充IFooValidator的规则。

IBarValidator的规则中填充了Bar和FooBar？

我有以下代码：

public static class Dependencies
    {
        public static IContainer Configure()
        {
            var builder = new ContainerBuilder();

            builder.RegisterType<Foo>().As<IRule>();
            builder.RegisterType<Bar>().As<IRule>();

            builder.RegisterType<FooBar>().As<IRule>();

            builder.RegisterType<Foos>().As<IFooValidator>();
            builder.RegisterType<Bars>().As<IBarValidator>();

            return builder.Build();
        }
    }

    public interface IRule
    {
        string Name { get; }
    }

    public class Foo : IRule
    {
        public string Name { get { return "Foo"; }}
    }

    public class Bar : IRule
    {
        public string Name { get { return "Bar"; } }
    }

    public class FooBar : IRule
    {
        public string Name { get { return "FooBar"; } }
    }

    public interface IFooValidator
    {
        IList<IRule> Rules { get; set; }
    }

    public interface IBarValidator
    {
        IList<IRule> Rules { get; set; }
    }

    public class Foos : IFooValidator
    {
        public IList<IRule> Rules { get; set; }

        public Foos(IList<IRule> foo)
        {
            Rules = foo;
        }
    }

    public class Bars : IBarValidator
    {
        public IList<IRule> Rules { get; set; }

        public Bars(IList<IRule> bars)
        {
            Rules = bars;
        }
    }

我知道可以用以下方法来完成：

builder.Register<IFooValidator>(context =>
            {
                var foos = context.ResolveNamed<IList<IRule>>("Foo");
                var foobar = context.Resolve<IList<IRule>>();

                return new Foos(foos.Concat(foobar).ToList());

            });

但感觉很乱，还有别的办法吗？

Answer 1

我已经解决了：

            builder.RegisterType<Foo>().Named<IRule>("Foo");
            builder.RegisterType<Bar>().Named<IRule>("Bar");

            builder.RegisterType<FooBar>()
                .As<IRule>()
                .Named<IRule>("Foo")
                .Named<IRule>("Bar");

            builder.RegisterType<Foos>().As<IFooValidator>().WithParameter((info, context) => info.Name == "foo", (info, context) => context.ResolveNamed<IList<IRule>>("Foo"));

如果有人能提供一个更好的答案，请这样做，我会很高兴地标记它。

更新

在考虑了这个问题之后，像这样注入依赖是没有意义的。因为任何改变都需要重建。我决定将应用程序的这一部分重构为使用组合和继承，而不是聚合和DI。