温莎城堡临时一次性用品

Question

我知道这已经被讨论得令人作呕......但我对 Windsor 跟踪瞬态 IDisposable 对象的方式有疑问。

我了解让 Windsor 管理我的 IDiposables 的好处...但我不喜欢它。

如果我想将组件包装在 using 块中会发生什么？编码器会假设资源将在 using 块结束时被清理，对吗？错误 - 将调用 Dispose，但 Windsor 会保留该实例，直到显式释放为止。这对我来说一切都很好，因为我知道我在做什么......但是另一个正在编写类并希望像其他 IDisposable 通常使用的方式（在 using 块中）使用 IDisposable 的开发人员呢？

using(factory.CreateInstance()) 
{
   ....  
}

对我来说看起来更清楚：

MyDisposable instance;
try
{
    instance = factory.GetInstance();
}
finally 
{
    factory.Release(instance);
}

为了真正处理我的实例并使它们符合 GC 的条件，我需要引用 WindsorContainer 或使用公开发布方法的类型化工厂。这意味着使用 IDisposable 组件的唯一可接受的方法是使用类型化工厂。在我看来，这不好……如果有人将 IDisposable 接口添加到现有组件中怎么办？ 每个需要注入组件的地方都需要改变。在我看来这真的很糟糕。 （当然，在非 DI 场景中，也需要更改为调用 Dispose...但是对于 Windsor，每个地方都需要更改为使用类型化工厂，这是一个更大的更改）。

好吧，公平地说，我可以使用自定义 ReleasePolicy 对吧？这个怎么样？

public class CustomComponentsReleasePolicy : AllComponentsReleasePolicy
{
    public override void Track(object instance, Burden burden)
    {
        if (burden.Model.LifestyleType == LifestyleType.Pooled) 
            base.Track(instance, burden);
    }
}

好的，太好了，我的 IDisposable Transient 组件现在将被 GC 处理。

如果我想使用 TypedFactory 以便我的类可以生成某个类型的许多实例，该怎么办？

public interface IMyFactory 
{
    MyDisposable GetInstance();
    void Release(MyDisposable instance);
}

[Singleton]
public class TestClass
{
    public TestClass(IMyFactory factory) { }
}

好吧，一方面，在工厂上调用 Release 对在 MyDisposable 上调用 Dispose() 没有任何作用，因为 MyDisposable 没有被跟踪......

我该如何克服这些困难？

谢谢。

Answer 1

首先，您如何知道与您未创建的对象相关的退役问题？您无法控制对象的创建，因为您没有自己创建它（工厂为您创建了此操作）。当您将ioc解析与消费者处置（调用.Dispose而不是factory.Release）结合起来时，您将引入这样的要求：您的对象知道它是如何创建的，但它并没有创建自己。考虑以下示例：

“组件”是您通过容器解析的东西，但您想自行处理

public class Component : IDisposable
{
    private readonly IAmSomething _something;

    public Component(IAmSomething something)
    {
        _something = something;
    }

    public void Dispose()
    {
        // Problem 1: the component doesnt know that an implementation of IAmSomething might be disposable
        // Problem 2: the component did not create "something" so it does not have the right to dispose it
        // Problem 3: What if an implementation of "something" has a depenency on a disposable instance deep down in its object graph?

        // this is just bad..
        IDisposable disposable = _something as IDisposable;

        if (disposable != null)
            disposable.Dispose();

    }
}

public interface IAmSomething
{

}

public class SomethingA : IAmSomething
{

}

public class SomethingB : IAmSomething, IDisposable 
{
    public void Dispose()
    {
    }
}

如上所示，退役可能很复杂，我简单地不知道如何自己优雅地处理这个问题，特别是当 Windsor 这样做时为我。如果您的代码库中充斥着服务定位器反模式（http:// blog.ploeh.dk/2010/02/03/ServiceLocatorisanAnti-Pattern/）我可以看到这如何成为一个问题（我不是说你的代码是），但是你真的有多少更大的问题。

using(factory.CreateInstance()) 
{
   ....  
}

对我来说看起来比……更清晰

嗯，using 语句是一种约定，如果省略它，则不会出现编译时错误，所以从我的角度来看，try/finally 与 release 只是另一个约定，尽管有点冗长。例如，您可以通过创建一个助手来缩短 try/finally ，例如：

[TestFixture]
public class SomeCastleTests
{
    [Test]
    public void Example()
    {
        var container = new WindsorContainer();

        // you would of course use a typed factory instead in real word

        using (var usage = new ComponentUsage<IAmSomething>(container.Resolve<IAmSomething>, container.Release))
        {
            // use..
            usage.Component
        }
    }
}

public class ComponentUsage<T> : IDisposable where T : class
{
    private Func<T> _create;
    private Action<T> _release;

    private T _instance;

    public ComponentUsage(Func<T> create, Action<T> release)
    {
        _create = create;
        _release = release;
    }

    public T Component
    {
        get
        {
            if (_instance == null)
                _instance = _create();

            return _instance;
        }
    }

    public void Dispose()
    {
        if (_instance != null)
        {
            _release(_instance);
            _instance = null;
        }
    }
}

在我看来，这不好......如果有人添加 IDisposable 怎么办？
与现有组件的接口？每一个期待的地方
要注入的组件需要更改。

我不明白这个说法。如何释放组件以及何时需要它是不同的问题，如果组件作为构造函数依赖项提供，则添加 IDisposable 不会改变任何内容。通过构造函数获取依赖项的类并未创建它，因此不负责释放它。

Answer 2

作为背负者，您可以通过创建一个为您释放对象的拦截器来解决您提到的其他一些问题。我这样做是为了一个工作单元。拦截器如下所示：

public class UnitOfWorkReleaseOnDispose : IInterceptor
{
    private readonly IUnitOfWorkFactory unitOfWorkFactory;

    public UnitOfWorkReleaseOnDispose(IUnitOfWorkFactory unitOfWorkFactory)
    {
        this.unitOfWorkFactory = unitOfWorkFactory;
    }

    public void Intercept(IInvocation invocation)
    {
        invocation.Proceed();
        this.unitOfWorkFactory.DestroyUnitOfWork((IUnitOfWork)invocation.Proxy);
    }
}

我的注册代码如下所示：

            Component.For<IUnitOfWork>()
                .ImplementedBy<TransactionalUnitOfWork>()
                .LifestyleTransient()
                .Interceptors<UnitOfWorkReleaseOnDispose>()
                    .Proxy.Hook(h => h.Service<InterfaceMethodsOnlyProxyGenerationHook<IDisposable>>())

代理挂钩只是表明我只想代理 IDiposable 接口方法。该类如下所示：

public class InterfaceMethodsOnlyProxyGenerationHook<TInterface> : IProxyGenerationHook
{
    public void MethodsInspected()
    {

    }

    public void NonProxyableMemberNotification(Type type, System.Reflection.MemberInfo memberInfo)
    {

    }

    public bool ShouldInterceptMethod(Type type, System.Reflection.MethodInfo methodInfo)
    {
        return typeof(TInterface) == type;
    }
}

由于我正在使用我正在使用的钩子的重载，因此也需要注册：

            Component.For<IProxyGenerationHook>()
                .ImplementedBy<InterfaceMethodsOnlyProxyGenerationHook<IDisposable>>()
                .LifestyleSingleton()