C# 将依赖项作为方法参数而不是构造函数参数注入

我们可以使用MEF或Autofac将依赖项作为方法参数而不是构造函数参数注入吗

---

谢谢

我不知道MEF，因为我从未使用过它。你可以

统一 来自MSFT文档

Unity实例化在目标对象范围内携带InjectionMethod属性的方法的参数中定义的依赖对象。然后在将对象返回给调用方之前调用目标对象的属性化方法。必须在目标类中应用InjectionMethod属性才能启动方法调用注入

这会将类标记为具有依赖项方法，该方法必须在实例化该类时调用，并注入其方法参数

IUnityContainer uContainer = new UnityContainer();
MyObject myInstance = uContainer.Resolve<MyObject>();

// access the dependent object
myInstance.dependentObject.SomeProperty = "Some value";

IUnityContainer uContainer=newunitycontainer（）；
MyObject myInstance=uContainer.Resolve（）；
//访问依赖对象
myInstance.dependentObject.SomeProperty=“某些值”；

自动传真 Autofac在激活服务期间通过lambdas或回调来完成此操作。从Autofac文档中

虽然构造函数参数注入是将值传递给正在构造的组件的首选方法，但也可以使用属性或方法注入来提供值

属性注入使用可写属性而不是构造函数参数来执行注入。方法注入通过调用方法来设置依赖项

//使用解析回调注册要解析的类型。在回调中，使用已解析的依赖项调用该方法。
builder.Register（c=>{
var result=新的MyObjectType（）；
var dep=c.Resolve（）；
结果：设置依赖性（dep）；
返回结果；
});

另一种方法是注册回调

builder
  .Register<MyObjectType>()
  .OnActivating(e => {
      var dep = e.Context.Resolve<TheDependency>();
      e.Instance.SetTheDependency(dep);
  });

builder
.Register（）
.on正在激活（e=>{
var dep=e.Context.Resolve（）；
e、 实例。设置依赖性（dep）；
});

这两个框架只能在解析时进行方法注入。但是，在对象实例化后，不能向方法中注入依赖项。在这些场景中，您应该使用工厂来获取您拥有的依赖项，让工厂通过DI容器来解析它

工厂

//创建工厂。工厂将有一个静态方法，DI系统可以使用该方法注册lambda，这样工厂就可以通过DI容器进行解析，而无需与它紧密耦合。
公营酒吧
{
私人静态功能内部工厂；
公共静态无效设置工厂（Func工厂）
{
this.internalFactory=工厂；
}
公共IBarDependency CreateBar（）
{
//使用SetFactory中分配的DI容器lambda来解决依赖关系。
返回内部工厂（）；
}
}
公共类依赖注入引导
{
集装箱；
公营机构
{
var builder=new ContainerBuilder（）；
builder.RegisterType（）.As（）；
container=builder.Build（）；
//告诉工厂通过我们的IContainer解决所有iBardependency问题。
SetFactory（（）=>container.Resolve（））；
}
}
公共类视图模型
{
public void ExecuteSave（）
{
var barFactory=新的barFactory（）；
IBarDependency bar=barFactory.CreateBar（）；
}
}

// Register the type that you want to resolve with a resolution callback. Within the callback, invoke the method with a resolved dependency.
builder.Register(c => {
  var result = new MyObjectType();
  var dep = c.Resolve<TheDependency>();
  result.SetTheDependency(dep);
  return result;
});

builder
  .Register<MyObjectType>()
  .OnActivating(e => {
      var dep = e.Context.Resolve<TheDependency>();
      e.Instance.SetTheDependency(dep);
  });

// Create the factory. The factory will have a static method that the DI system can register a lambda with, so that the factory can resolve through the DI container without being tightly coupled to it.
public class BarFactory
{
    private static Func<IBarDependency> internalFactory;

    public static void SetFactory(Func<IBarDependency> factory)
    {
        this.internalFactory = factory;
    }

    public IBarDependency CreateBar()
    {
        // Use the DI container lambda assigned in SetFactory to resolve the dependency.
        return internalFactory();
    }
}

public class DependencyInjectionBootstrap
{
    IContainer container;

    public void SetupDI()
    {
        var builder = new ContainerBuilder();
        builder.RegisterType<BarDependency>().As<IBarDependency>();
        container = builder.Build();

        // Tell the factory to resolve all IBarDependencies through our IContainer.
        BarFactory.SetFactory(() => container.Resolve<IBarDependency>());
    }
}

public class FooViewModel
{
    public void ExecuteSave()
    {
        var barFactory = new BarFactory();
        IBarDependency bar = barFactory.CreateBar();
    }
}