向自己注册 IOC 容器

Question

假设我有一个接口 IDependencyResolver:

public interface IDependencyResolver{
    T Resolve<T>() where T: class;
    object Resolve(Type source);
}

以及使用 SimpleInjector 的实现：

public class SIDependencyResolver:IDependencyResolver{
    private readonly Container _container;
    public SIDependencyResolver(Container container){
        _container = container;
        _container.Options.DefaultScopedLifestyle = new WcfOperationLifeStyle();
        RegisterDependencies(_container, LifeStyle.Scoped);
    }
    public T Resolve<T>() where T:class{
        return _container.GetInstance<T>();
    }
    public object Resolve(Type source){
        return _container.GetInstance(source);
    }
    public void RegisterDependencies(Container container, LifeStyle lifeStyle){
        //register dependencies + register self
    }
}

如果我需要在使用服务定位器模式的构造函数中注入 IDependencyResolver，我需要做什么？（是的，我知道......一个反模式......但除此之外）

public class UnitOfWork: IUnitOfWork{
    private readonly IDependencyResolver _resolver;
    public UnitOfWork(IDependencyResolver resolver){
        _resolver = resolver;
    }
    public IReadRepository<T> Read<T>(){
        return _resolver.Resolve<IReadRepository<T>>();
    }
    public IWriteRepository<T> Write<T>(){
        return _resolve.Resolve<IWriteRepository<T>>();
    }
}

过去我总是将依赖解析器 self 注册为一个单例，所以不使用 scoped 生活方式，因为这给我带来了问题。

container.Register<IDependencyResolver, SIDependencyResolver>(LifeStyle.Singleton);

首先，这是执行此操作的正确方法（例如，在 WCF 范围内，采用单例生活方式）还是有其他方法可以执行此操作？
其次，将 SimpleInjector.Container 传递给我的 dependencyResolver 的构造函数是否正确？

Answer 1

What do I need to do if I need the IDependencyResolver injected in a constructor which uses the Service locator pattern? (yes, I know... an anti-pattern... but this aside)

这不应该放在一边。尽管您像在 UnitOfWork 中那样对容器进行回调的方法很好，但这种 IDependencyResolver 抽象的（滥用）使用可以通过代码库快速传播到它所在的地方绝对不行。

此 IDependencyResolver 抽象的使用应限于合成根。但是由于组合根已经知道您正在使用的确切 DI 库的存在，因此具有此 IDependencyResolver 抽象与直接依赖 Container 本身没有任何好处。

因此，您的 IUnitOfWork 实现应该定义在内部您的 Composition Root 中，并且应该如下所示：

private sealed class SimpleInjectorUnitOfWork : IUnitOfWork {
    private readonly Container _container;
    public UnitOfWork(Container container){
        _container = container;
    }
    public IReadRepository<T> Read<T>() => _container.GetInstance<IReadRepository<T>>();
    public IWriteRepository<T> Write<T>() => _container.GetInstance<IWriteRepository<T>>();
}

报名方式如下：

container.RegisterSingleton<IUnitOfWork>(new SimpleInjectorUnitOfWork(container));

In the past I always registered the dependency resolver self as a singleton, so not with a scoped lifestyle since that gave me problems.

我不清楚你遇到了什么问题，但会导致麻烦的一件事是在构造函数中设置 DefaultScopedLifestyle，而类型由容器自动连接。最好将此调用移出此类构造函数；它使它更清楚：

var container = new Container();
container.Options.DefaultScopedLifestyle = new WcfOperationLifeStyle();

向自己注册 IOC 容器

Register IOC container to self

c#

dependency-injection

inversion-of-control

constructor-injection

simple-injector