Autofac 将参数传递给嵌套类型 [英] Autofac passing parameter to nested types

问题描述

我在 WCF 服务中使用 Autofac 作为 IoC.我有一种情况，我想将对象传递给嵌套类型(即未直接解析的类型，但在解析另一种类型时).据我了解，将此对象作为构造函数参数传递是 Autofac 中的首选方式.下面是这种情况的一个例子.

I am using Autofac as my IoC in my WCF service. I have a situation where I want to pass an object to a nested type (ie a type that is not resolved directly, but when resolving another type). As far as I understood, passing this object as a constructor parameter is the preferred way in Autofac. Here is an example of such a situation.

嵌套类型:

public class EventLogger<T> : IEventLogger<T>
{
    public EventLogger(IRepository<T> repository, User currentUser) { ... }  
}

我实际尝试解析的类型:

The type I am actually trying to resolve:

public class SomeBusinessObject  
{  
    public SomeBusinessObject(IEventLogger<SomeLogEventType> logger, ...) { ... }  
}

注册:

var builder = new ContainerBuilder();
builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>));
builder.RegisterGeneric(typeof(EventLogger<>)).As(typeof(IEventLogger<>));
builder.RegisterType<SomeBusinessObject>();

我的WCF服务操作里面的解析:

The resolving inside my WCF service operation:

var currentUser = GetUserFromServiceContext();  
var bo = lifetimeScope.Resolve<SomeBusinessObject>();

我应该如何以及在哪里将当前用户传递给我的记录器?我是否应该假设 WCF 操作必须知道解析 SomeBusinessObject 需要首先解析 IEventLogger 并在解析 SomeBusinessObject 时传递已解析的实例?像这样的东西(如果这不起作用，请原谅我，这只是一个想法):

How and where should I pass the current user to my logger? Should I assume that the WCF operation has to know that resolving SomeBusinessObject requires to resolve IEventLogger first and pass a resolved instance when resolving SomeBusinessObject? Something like this (pardon me if this does not work, it is just an idea):

var currentUser = GetUserFromServiceContext();  
var logger = lifetimeScope.Resolve<IEventLogger<SomeLogEventType>>(new NamedParameter("currentUser", currentUser));  
var bo = lifetimeScope.Resolve<SomeBusinessObject>(new NamedParameter("logger", logger));

如果这是解决方案，如果类型嵌套更深会发生什么?这至少不会破坏依赖注入的某些目的吗?

If this is the solution, what happens if the type is nested deeper? Doesn't that defeat at least some of the purpose of dependency injection?

推荐答案

恕我直言，我认为您违反了 IOC 的原则之一，因为组件不需要知道其依赖项的依赖项.在您的情况下，容器不知道 SomeBusinessObject 依赖于 User.

IMHO, I think you're violating one of the principles of IOC in that a component should not need to know about the dependencies of it's dependencies. In your case, the container doesn't know that SomeBusinessObject has a dependency on User.

话虽如此，您或许可以利用 Autofac 的委托工厂.您可以手动注册一个 Func 以隐藏客户端代码中的依赖链详细信息:

That being said, you may be able to leverage Autofac's Delegate Factories. You could manually register a Func<User, SomeBusinessObject> to hide the dependency chain details from the client code:

var builder = new ContainerBuilder();
builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>));
builder.RegisterGeneric(typeof(EventLogger<>)).As(typeof(IEventLogger<>));
builder.RegisterType<SomeBusinessObject>();

builder.Register<Func<User, SomeBusinessObject>>(c => {
    // Autofac should be able to resolve these Func<> automatically:
    var loggerFactory = c.Resolve<Func<User, IEventLogger<SomeLogEventType>>>();
    var sboFactory = c.Resolve<Func<IEventLogger<SomeLogEventType>, SomeBusinessObject>>();

        // Now we can chain the Funcs:
    return u => sboFactory(loggerFactory(u));
});

现在在您的客户端代码中，您可以:

Now in your client code, you can do:

var currentUser = GetUserFromServiceContext();  
var sboFactory = lifetimeScope.Resolve<Func<User, SomeBusinessObject>>();
var bo = sboFactory(currentUser);

顺便说一句，我认为 Lamba/Func 支持使 Autofac 成为最好的 IOC 容器.如果您知道如何编写 Func，就可以做一些疯狂而强大的事情.

As an aside, I think the lamba/Func support is what makes Autofac the best IOC container. You can do some crazy powerful things if you know how to compose Funcs.

这篇关于Autofac 将参数传递给嵌套类型的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！