C# Autofac：注册函数<&燃气轮机；还是工厂？

我必须在运行时根据从服务器收到的一些消息/属性创建实现，这些消息/属性也需要由新创建的对象进行转换。我是Autofac的新手，但据我所知，有两种方法可以解决这个问题

方法1：注册专用工厂

...
builder.RegisterType<MTextField>().Keyed<IComponent>(typeof(TextFieldProperties));
builder.RegisterType<ComponentFactory>().As<IComponentFactory>();

public class ComponentFactory : IComponentFactory
{
    private readonly IIndex<Type, IComponent> _lookup;

    public ComponentFactory(IIndex<Type, IComponent> lookup)
    {
        _lookup = lookup;
    }

    public IComponent Create(ComponentProperties properties)
    {
        var component = _lookup[properties.GetType()];
        component.Transform(properties);
        return component;
    }
}

...
builder.RegisterType<MTextField>().Keyed<IComponent>(typeof(TextFieldProperties));
builder.Register<Func<ComponentProperties, IComponent>>(c =>
{
    var context = c.Resolve<IComponentContext>();
    return properties =>
    {
        var component = context.ResolveKeyed<IComponent>(properties.GetType());
        component.Transform(properties);
        return component;
    };
});

。。。
builder.RegisterType（）.Keyed（typeof（TextFieldProperties））；
builder.RegisterType（）.As（）；
公共类组件工厂：IComponentFactory
{
专用只读索引查找；
公共组件工厂（IIndex查找）
{
_查找=查找；
}
公共IComponent创建（组件属性）
{
var component=_lookup[properties.GetType（）]；
变换（属性）；
返回组件；
}
}

方法2：根据funcs注册

...
builder.RegisterType<MTextField>().Keyed<IComponent>(typeof(TextFieldProperties));
builder.RegisterType<ComponentFactory>().As<IComponentFactory>();

public class ComponentFactory : IComponentFactory
{
    private readonly IIndex<Type, IComponent> _lookup;

    public ComponentFactory(IIndex<Type, IComponent> lookup)
    {
        _lookup = lookup;
    }

    public IComponent Create(ComponentProperties properties)
    {
        var component = _lookup[properties.GetType()];
        component.Transform(properties);
        return component;
    }
}

...
builder.RegisterType<MTextField>().Keyed<IComponent>(typeof(TextFieldProperties));
builder.Register<Func<ComponentProperties, IComponent>>(c =>
{
    var context = c.Resolve<IComponentContext>();
    return properties =>
    {
        var component = context.ResolveKeyed<IComponent>(properties.GetType());
        component.Transform(properties);
        return component;
    };
});

。。。
builder.RegisterType（）.Keyed（typeof（TextFieldProperties））；
builder.Register（c=>
{
var context=c.Resolve（）；
返回属性=>
{
var component=context.ResolveKeyed（properties.GetType（））；
变换（属性）；
返回组件；
};
});

问题：

我想这可能是一件主观的事情，但我还是想问

• 哪种方法更可取？为什么
• 还有更好的解决办法吗
• 是否真的有必要在“方法2”中存储上下文

编辑

好的，我在autofac上玩了更多。以下是我目前的做法：

public class TransformerFactory<D, T> : ITransformFactory<D, T>
    where T : ITransform<D>
{
    private readonly IIndex<Type, T> _lookup;


    public TransformerFactory(IIndex<Type, T> lookup)
    {
        _lookup = lookup;
    }


    public T Create(D data, Action<T> prepareInstance = null)
    {
        var instance = _lookup[data.GetType()];
        if (prepareInstance != null)
        {
            prepareInstance(instance);
        }
        instance.Transform(data);
        return instance;
    }
}

builder.RegisterGeneric(typeof(TransformerFactory<,>)).As(typeof(ITransformFactory<,>)); 
// e.g. var x = container.Resolve<ITransformFactory<ComponentProperties, IComponent>>();

公共类TransformerFactory:ITransformFactory
其中T:ITransform
{
专用只读索引查找；
公共TransformerFactory（IIndex查找）
{
_查找=查找；
}
public T Create（D数据，Action prepareInstance=null）
{
var实例=_查找[data.GetType（）]；
如果（准备状态！=null）
{
准备就绪（实例）；
}
实例转换（数据）；
返回实例；
}
}
builder.RegisterGeneric（typeof（TransformerFactory））.As（typeof（ITransformFactory））；
//例如，var x=container.Resolve（）；

第一种方法似乎是更好的方法。我提出的两个理由是：

Keyed和IIndex为手头的任务提供了充分且干净的开箱即用的解决方案。然而，方法2使用的是一个更通用的工具，它要求您使用额外的逻辑（即，您编写代码来调用ResolveKeyed）。如果有一个简单的针对特定目的的解决方案，请优先使用它，而不是更一般化的解决方案

方法1将能够正确管理生命周期和范围。正如您所提出的，方法2捕获了上下文，并将根据该上下文解析各个实例。这意味着单个实例的生存期将基于工厂的范围和生存期，而不是为单个服务指定的生存期策略

你检查过工厂方法了吗？虽然没有Ninject那么优雅，但我仍然喜欢使用这种模式来生成具体类的运行时。