C# 注入工厂并让它执行创建，还是注入所有内容？

注入工厂，然后在构造函数中执行许多对象的实例化，这是一种好的做法吗

private readonly SafeClient<AccountProxy, IAccountService> _accountProxy;
private readonly SafeClient<AccountClassProxy, IAccountClassService> _accountClassProxy;
private readonly SafeClient<CarrierProxy, ICarrierService> _carrierProxy;
private readonly SafeClient<TransportationTypeProxy, ITransportationTypeService> _transportationTypeProxy;

public AccountController(ISafeClientFactory clientFactory)
{
    clientFactory.UserName = "user";
    clientFactory.Password = "password";
    _accountProxy = clientFactory.CreateClient<AccountProxy, IAccountService>();
    _accountClassProxy = clientFactory.CreateClient<AccountClassProxy, IAccountClassService>();
    _carrierProxy = clientFactory.CreateClient<CarrierProxy, ICarrierService>();
    _transportationTypeProxy = clientFactory.CreateClient<TransportationTypeProxy, ITransportationTypeService>();
}

private readonly SafeClient\u accountProxy；
私有只读安全客户端\u accountClassProxy；
私有只读安全客户端_carrierProxy；
私有只读安全客户端_transportationTypeProxy；
公共帐户控制器（ISafeClientFactory客户端工厂）
{
clientFactory.UserName=“user”；
clientFactory.Password=“Password”；
_accountProxy=clientFactory.CreateClient（）；
_accountClassProxy=clientFactory.CreateClient（）；
_carrierProxy=clientFactory.CreateClient（）；
_transportationTypeProxy=clientFactory.CreateClient（）；
}

还是把所有东西都注射进去更好？利与弊是什么？对不起，我对这整件事还不熟悉。谢谢

public AccountController(
    ISafeClient<IAccountService> accountProxy,
    ISafeClient<IAccountClassService> accountClassService,
    ISafeClient<ICarrierService> carrierService,
    ISafeClient<ITransportationTypeService> transportService) 
{
     //assignment here
}

公共帐户控制器(
IsAffect accountProxy，
IsAffect accountClassService，
我的客户服务很好，
ISafeClient传输服务）
{
//这里的任务
}

我通常使用第二个例子，这就是我赖以生存的理由：

如果a的依赖项B可以在a的构建时被实例化，那么它应该在a之外被实例化，并且构造函数被注入a。如果没有足够的信息在a的构建时实例化B，那么就注入一个工厂，当存在足够的信息时可以实例化B

---

通过向构造函数中注入工厂，您隐藏了真正的依赖项，并且具有与构造函数相同的缺点。这些不利因素包括：

• 它隐藏类的依赖项，导致运行时错误而不是编译时错误
• 这使得代码更难维护，因为不清楚何时会引入突破性的更改
• 这使得组件的消费者更难看到组件是否有错误，并且使工具变得盲目；他们将无法发现这些错误
• 可能会隐藏类使用太多依赖项的事实。换句话说，它隐藏了类可能违反单一责任原则的事实

您通常会使用工厂来延迟部分对象图的构建，但如果在构造函数内部调用工厂，则根本不会延迟构建。你没有得到额外的好处，只有坏处

---

因此，直接注入依赖项绝对更好。

我认为唯一的答案是依赖项。@Liam:不，不依赖项。从构造器内部调用工厂总是不好的。如果您将一个对象传递到构造函数中，然后使用它获取其他对象并存储，那么这就是一种气味。只需传入您实际需要的对象即可。