Question

我在autofac中乱七八糟，我遇到了一些与特定构造函数绑定的问题。

我有以下代码：

var builder = new ContainerBuilder();

builder
    .RegisterType<GenericIocFactory>()
    .As<IGenericIocFactory>();

builder
    .RegisterType<Product>()
    .As<IProduct>()
    .PropertiesAutowired();

IContainer Container = builder.Build();

IGenericIocFactory Fac = Container.Resolve<IGenericIocFactory>();

_product = Fac.Get<IProduct>(new Dictionary<string,object>() { {"returnEmpty" , false} }) as Product;

然后在工厂：

public interface IGenericIocFactory
{
    T Get<T>(Dictionary<string,object> options) where T: class;
}

public class GenericIocFactory : IGenericIocFactory
{
    private readonly IComponentContext  _icoContext;
    private object _options;

    public GenericIocFactory(IComponentContext icoContext,bool isInjected = true)
    {
         _icoContext= icoContext;
    }

    public T Get<T>(Dictionary<string,object> options) where T: class
    {
        var _parameters = new List<Parameter>();
        foreach (var parameter in options)
        {
            _parameters.Add(new NamedParameter(parameter.Key, parameter.Value));
        }
        return _icoContext.Resolve<T>(_parameters);
        //operate on new object

        // tried this as well
        //return _icoContext.Resolve<T>(
            //new NamedParameter("returnEmpty" , false)
            //new TypedParameter(typeof(bool),false)
        //);
    }
}

这解析了一个产品，但不是我期望的构造函数。

目标构造函数

public Product(bool returnEmpty)

解析构造函数

public Product(IList<string> productCodes, string fields = "", string orderBy = "ProductCode")

总共有23个构造函数，而且一个解析不是最大的（所以我不认为它是贪婪的）

即

public Product(string strFields, string strFrom, string strFilter, string strOrderBy, string whseCode,
        bool addExistsInWharehouse, string additionalAfterorderBy, bool forceUniqueRecords = false)

也不是定义中的第一个或最后一个。

我很难过，任何人都可以看到我做错了什么。

Answer 1

不幸的是 Autofac 不提供此机制。

您可以实现IConstructorSelector，当多个构造函数可用时选择构造函数，并使用UsingSelector方法将其设置为注册，但遗憾的是无法访问可用的参数当前解析操作。

另一种解决方案是实现IInstanceActivator，它负责根据类型和参数创建实例。要使用自定义IInstanceActivator，您还需要实施IRegistrationBuilder，这非常困难。为了保证良好的性能，我还建议使用ConstructorParameterBinding，它将使用动态编译表达式创建优化工厂。

如果您无法更改构造函数，我能看到的唯一解决方案是实现您自己的工厂。由于您的对象没有任何依赖关系，因此您可以在不使用 Autofac 的情况下创建它们。

public class GenericIocFactory : IGenericIocFactory
{
    public GenericIocFactory(ILifetimeScope scope)
    {
        this._scope = scope; 
    }

    private readonly ILifetimeScope _scope; 

    public T Get<T>(params object[] args) where T: class
    {           
        ConstructorInfo ci = this.GetConstructorInfo(args);
        if (ci == null) 
        {
            throw ...
        }

        var binder = new ConstructorParameterBinding(ci, args, this._scope);

        T value = binder.Instanciate() as T; 

        if (value == null) 
        {
            throw ...
        }
        if(value is IDisposable)
        {
            this._scope.Disposer.AddInstanceForDisposal(value);
        }
        return value; 
    }


    protected virtual ConstructorInfo GetConstructorInfo<T>(params object[] args)
    {
      // TODO 
    }
}

Answer 2

所以再次阅读doco。我需要在开始时绑定构造函数。但这不会解决我的问题所以我做了另一个容器，一次请求一个实例，并根据params构建它。它有点不正确，但这是一个现实世界的解决方案，适用于任何正在转换为autofac的现有解决方案。

希望这有助于某人。

public interface IGenericIocFactory
{
    T Get<T>(params object[] constructorParams) where T: class;
}

public interface ICustomAutoFacContainer
{
    IContainer BindAndReturnCustom<T>(IComponentContext context, Type[] paramsList);
}

public class CustomAutoFacContainer : ICustomAutoFacContainer
{
    public IContainer BindAndReturnCustom<T>(IComponentContext context, Type[] paramsList)
    {
        if (context.IsRegistered<T>())
        {
            // Get the current DI binding type target
            var targetType = context
                .ComponentRegistry
                .Registrations
                .First(r => ((TypedService) r.Services.First()).ServiceType == typeof(T))
                .Target
                .Activator
                .LimitType;

            // todo: exception handling and what not .targetType

            var builder = new ContainerBuilder();

            builder
               .RegisterType(targetType)
               .As<T>()
               .UsingConstructor(paramsList)
               .PropertiesAutowired();

            return builder.Build();
        }
        return null;
    }
}

public class GenericIocFactory : IGenericIocFactory
{
    private ICustomAutoFacContainer _iCustomContainer;
    private readonly IComponentContext _icoContext;
    public GenericIocFactory(ICustomAutoFacContainer iCustomContainer, IComponentContext icoContext)
    {
         _iCustomContainer = iCustomContainer;
        _icoContext = icoContext;
    }

    public T Get<T>(params object[] constructorParams) where T: class
    {
        //TODO handle reflection generation? ?? ?not needed?? ??

        var parameters = constructorParams
            .Select((t, index) => new PositionalParameter(index, t))
            .Cast<Parameter>()
            .ToList();

        var parameterTypes = constructorParams
            .Select((t, index) => t.GetType())
            .ToArray();

        return _iCustomContainer
            .BindAndReturnCustom<T>(_icoContext,parameterTypes)
            .Resolve<T>(parameters);
    }
}

设置和使用情况如下所示：

var builder = new ContainerBuilder();

// Usually you're only interested in exposing the type
// via its interface:
builder
    .RegisterType<GenericIocFactory>()
    .As<IGenericIocFactory>();

builder
    .RegisterType<CustomAutoFacContainer>()
    .As<ICustomAutoFacContainer>();

builder
    .RegisterType<Product>()
    .As<IProduct>()
    .PropertiesAutowired();

var container = builder.Build();

var factory = container.Resolve<IGenericIocFactory>();

_product = factory.Get<IProduct>(false) as Product;
_product = factory.Get<IProduct>("","") as Product;

AutoFac NamedParameter无法正确解析

2 个答案: