Question

我在下面有一个完整的（破坏的）C＃应用程序，它会生成堆栈溢出异常。如果您查看源代码，您将会看到为什么存在堆栈溢出异常，所以我并不是真的在考虑为什么会发生这种情况，我想知道处理它的最佳方法是什么。

1）所有对unity的引用都封装在一个名为Registry的类中，因此我可以毫无困难地升级。我不希望unitycontainer尽可能乱扔其他类。理论上，我应该能够升级到5，如果它出来的话，或者甚至可以用ninject或其他DI框架交换出来，如果我的性格发生了剧烈的变化。

2）我希望Registry由unity容器控制，以便它可以在容器控制类的构造函数中使用。（例如FirstSingleInstance）

3）IRegistry和Registry都继承自IDisposable，因为我认为处理统一容器是一种好习惯。

4）Registry在它自己的构造函数中构造Unity容器，所以我假设我还应该在调用registry.dispose时处理unity容器。

5）由Registry控制的所有其他类都应该是单实例类，所以我用ContainerControlledLifetimeManager注册它们。我希望这些实例在容器处理时会被处理掉。

处理这种情况的最佳做法是什么？

a）不要在注册表上调用dispose - 让它在进程线程的生命周期内生效吗？

b）不要试图让Unity容器控制注册表（以及扩展名为UnityContainer）。这样在Registry上调用dispose不会导致stackoverflow异常。我将如何构建FirstSingleInstance类是我必须要审查的内容。

d）其他？

这是我写的具有所有相关部分的应用程序

using System;
using Microsoft.Practices.Unity;

namespace DIProblem.Console
{
    class Program
    {
        static void Main(string[] args)
        {
            IRegistry registry = CreateRegistry();
            IFirstSingleInstance theInstance = registry.Resolve<IFirstSingleInstance>();
            theInstance.DoThis();
            registry.Dispose();   // stack overflow here because of infinite dispose loop
        }

        static IRegistry CreateRegistry() => new Registry();
    }

    public class FirstSingleInstance : IFirstSingleInstance
    {
        private IRegistry _registry;

        public FirstSingleInstance(IRegistry reg)
        {
            _registry = reg;
        }

        public void DoThis()
        {

            System.Console.WriteLine("This Was Done.");

            _registry.Resolve<ISecondSingleInstance>().DoThisToo();

        }
    }

    public class SecondSingleInstance : ISecondSingleInstance
    {
        private IRegistry _registry;

        public SecondSingleInstance(IRegistry reg)
        {
            _registry = reg;
        }

        public void DoThisToo()
        {
            System.Console.WriteLine("This Was Done too.");
        }
    }

    public interface ISecondSingleInstance
    {
        void DoThisToo();
    }


    public interface IFirstSingleInstance
    {
        void DoThis();
    }


    public class Registry : IRegistry, IDisposable
    {
        public Registry()
        {
            _container = new UnityContainer();

            RegisterInstance<IFirstSingleInstance, FirstSingleInstance>();
            RegisterInstance<ISecondSingleInstance, SecondSingleInstance>();

            _container.RegisterInstance<IRegistry>(this);
        }

        private UnityContainer _container;

        public void RegisterInstance<T1, T2>() where T2 : class, T1 => _container.RegisterType<T1, T2>(new ContainerControlledLifetimeManager());

        public T Resolve<T>() => _container.Resolve<T>();

        public void Dispose()
        {
            Dispose(true);
            System.GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            _container?.Dispose();
            _container = null;
        }
    }

    public interface IRegistry : IDisposable
    {
        T Resolve<T>();
        void RegisterInstance<T1, T2>() where T2 : class, T1;
    }
}

感谢您以任何合理的方式提供帮助。

Answer 1

以下代码避免使用Service Locator anti-pattern，而只依赖构造函数注入作为应用控制反转的模式。结果是一个更简单，更易维护且更可测试的应用程序，不会导致任何stackoverflow异常。

class Program
{
    static void Main(string[] args)
    {
        using (var container = Registry.BuildContainer())
        {
            var theInstance = registry.Resolve<IFirstSingleInstance>();
            theInstance.DoThis();
        }
    }
}

public static class Registry
{
    public static UnityContainer BuildContainer()
    {
        var container = new UnityContainer();

        container.RegisterType<IFirstSingleInstance, FirstSingleInstance>(Singleton);
        container.RegisterType<ISecondSingleInstance, SecondSingleInstance>(Singleton);

        return container;
    }

    private static ContainerControlledLifetimeManager Singleton => 
        new ContainerControlledLifetimeManager();
}

public interface ISecondSingleInstance
{
    void DoThisToo();
}

public interface IFirstSingleInstance
{
    void DoThis();
}

public class FirstSingleInstance : IFirstSingleInstance
{
    private ISecondSingleInstance _second;

    public FirstSingleInstance(ISecondSingleInstance second)
    {
        _second = second;
    }

    public void DoThis()
    {
        System.Console.WriteLine("This Was Done.");
        _second.DoThisToo();
    }
}

public class SecondSingleInstance : ISecondSingleInstance
{
    public SecondSingleInstance(/* other dependencies here */)
    {
    }

    public void DoThisToo()
    {
        System.Console.WriteLine("This Was Done too.");
    }
}

在Unity Containers上调用dispose的最佳方法是什么？

1 个答案: