制定自定义IoC - 如何实施具有范围的DI？

Question

我正在为自己的学习/成长写一个IoC容器。通常我会写一些像下面这样：

using(DisposableObject dispObj = new DisposableObject()) 
{ 
    UserRepository users = new UserRepository(dispObj); 

    // Do stuff with user. 
} 

将转向：

using(IDisposableObject dispObj = Container.Resolve<IDisposableObject>()) 
{ 
    IUserRepository users = Container.Resolve<IUserRepository>(); 

    // Do stuff with user. 
} 

我怎么能抽象的DisposableObject使其在using范围内使用IOC时的唯一实例化的使用？我试图弄清楚Autofac如何做，但我不完全确定。

编辑：当一个对象被与using范围实例化，所有呼叫解决类型（在这种情况下IDisposableObject）应返回范围的变量，而不是一个新的实例。同样重要的是，在using声明和另一个Resolve<IDisposableObject>被调用后，它会返回一个新的实例。

Answer 1

以这种方式使用可丢弃对象时要记住的事情是容器中的引用也会被丢弃，所以最好在通过Resolve返回实例时它需要每次都返回一个新实例。

你需要做的，就是注册时的类型与你的容器，允许它指定的行为，无论是共享（单身），或者非共享，如：

Container.RegisterType<IDisposableObject>(CreationPolicy.NonShared); 

using (var disposable = Container.Resolve<IDisposableObject>()) { 

} 

以上将工作的非共享实例，因为每次都创建一个新实例，所以我们可以安全地处理它。如果您使用CreationPolicy = Shared来尝试上述操作，则Singleton将被丢弃，因此以后的访问可能会导致ObjectDisposedException。

通过，你可以通过传递的creationPolicy =共享创建辛格尔顿情况下，建立这种行为，例如：

Container.RegisterType<IUserRepository>(CreationPolicy.Shared); 

using (var disposable = Container.Resolve<IDisposableObject>()) { 
    var userRepository = Container.Resolve<IUserRepository>(); 
    // only one instance of user repository is created and persisted by the container. 
} 

希望帮助？

如果您以前使用过MEF，这个术语可能很熟悉。

编辑：所以，我的理解是，你想要做的事，如：

using (var repository = Container.Resolve<IUserRepository>()) 
{ 
    var other = Container.Resolve<IUserRepository>(); 
    // should resolve to the same instance. 
} 

你需要找到在容器监测一次性对象的某种方式。也许引进一个额外的创建策略，SharedScope，e.g：

Container.Register<IUserRepository, UserRepository>(CreationPolicy.SharedScope); 

现在，当您使用容器解决型，你需要弄清楚的项目把creationPolicy。如果项目是SharedScope，并且尚未创建，请创建它的一个实例并返回。

如果您解析实例并且它已经创建，则返回现有实例。

当在该项目上调用Dispose时，需要一些回调容器的方法来移除实例。

编辑两个：

那么，有没有搞清楚了这一点的一个简单的方法。我能想到的唯一方法是你引入另一个接口：

public interface IMonitoredDisposable : IDisposable 
{ 
    bool IsDisposed { get; set; } 
} 

当一个对象被处置时，确保它设置了IsDisposed属性。那么您可以从您的容器中监控该财产吗？

Answer 2

您可以返回类型为Owned<Foo>的对象而不是Foo。

Owned<T>可能是这样的：

public class Owned<T> : IDisposable 
{ 
    private readonly Container container; 
    private readonly T value; 

    public Owned(Container container, T value) 
    { 
     this.container = container; 
     this.value = value; 
    } 

    public T Value { get { return value; } } 

    public void Dispose() 
    { 
     this.container.ReleaseOwned(this); 
    } 

} 

现在客户端拉Owned<Foo>可以通知通过布置它这个对象的容器，即使Foo本身不是一次性的。通过这种方式，容器知道何时清理对象及其依赖关系（这可能也是一次性的，但对客户端不可见），并且可以实现您之后的行为。

Autofac做的事情非常相似。见Nicholas Blumhardt的博客文章The Relationship Zoo，他介绍了这个概念。