使用autofac解析方法内部的类实例

Question

使用下面的这个PipelineX类，有没有办法解决应用于pipline的过滤器而不注入autofac容器并调用_container.Resolve（）;

 public class PipelineX<T> : FilterBase<T>, IPipelineX<T>
{
    private readonly IContainer _container;

    public PipelineX(IContainer container)
    {
        _container = container;
    }
    protected override T Process(T input)
    {
        return input;
    }

    public PipelineX<T> FilterBy<X>()
    {
        var filter = _container.Resolve(typeof(X)) as IFilter<T>;
        Register(filter);
        return this;
    }                             
}

Answer 1

为避免将Autofac用作服务定位器，您可以在其中注册自己的工厂方法，在这种情况下：

builder.Register<Func<Type, object>>((c, p) =>
{
    var context = c.Resolve<IComponentContext>();
    return type => context.Resolve(type);
});

并在您的PipelineX类中使用它，如下所示：

private readonly Func<Type, object> filterFactory;

public PipelineX(Func<Type, object> filterFactory)
{
    this.filterFactory = filterFactory;
}

protected override T Process(T input)
{
    return input;
}

public PipelineX<T> FilterBy<X>()
{
    var filter = this.filterFactory(typeof(X)) as IFilter<T>;
    Register(filter);
    return this;
}

考虑：这只删除了对Autofac容器的硬引用，它仍然使用一个抽象对象工厂，它不够自我解释，应该由自定义过滤器工厂或选择器实现替换。

Answer 2

这与Péter的答案类似，但使用的是定制工厂：

public class FilterFactory
{
    private readonly Func<Type, object> _factoryFunc;

    public FilterFactory(Func<Type, object> factoryFunc)
    {
        _factoryFunc = factoryFunc ?? throw new ArgumentNullException(nameof(factoryFunc));
    }

    public IFilter<T> Create<X, T>() 
    {
        IFilter<T> filter = Create<T>(typeof(X));

        return filter;
    }

    public IFilter<T> Create<T>(Type type) 
    {
        var filter = _factoryFunc(type) as IFilter<T>;

        if (filter == null)
        {
            throw new ArgumentException($"Could not find filter for type '{type.FullName}'");
        }

        return filter;
    }
}

PipelineX实现将是：

public class PipelineX<T> : FilterBase<T>, IPipelineX<T>
{
    private readonly FilterFactory _factory;

    public PipelineX(FilterFactory factory)
    {
        _factory = factory;
    }

    protected override T Process(T input)
    {
        return input;
    }

    public PipelineX<T> FilterBy<X>()
    {
        var filter = _factory.Create<X,T>() as IFilter<T>;
        Register(filter);
        return this;
    }
}

使用Autofac注册工厂：

builder.Register<FilterFactory>(c =>
{
    var context = c.Resolve<IComponentContext>();
    return new FilterFactory(context.Resolve);
});