基于Unity容器中的对象生存期管理分析

public interface IExample : IDisposable
    {
      void SayHello();
    }

    public class Example : IExample
    {
      private bool _disposed = false;
      private readonly Guid _key = Guid.NewGuid();

      public void SayHello()
      {
        if (_disposed)
        {
          throw new ObjectDisposedException("Example",
              string.Format("{0} is already disposed!", _key));
        }

        Console.WriteLine("{0} says hello in thread {1}!", _key,
            Thread.CurrentThread.ManagedThreadId);
      }

      public void Dispose()
      {
        if (!_disposed)
        {
          _disposed = true;
        }
      }
    }

private static void TestTransientLifetimeManager()
    {
      IExample example;
      using (IUnityContainer cOntainer= new UnityContainer())
      {
        container.RegisterType(typeof(IExample), typeof(Example),
          new TransientLifetimeManager());

        // each one gets its own instance
        container.Resolve().SayHello();
        example = container.Resolve();
      }
      // container is disposed but Example instance still lives
      // all previously created instances weren't disposed!
      example.SayHello();

      Console.ReadKey();
    }

private static void TestContainerControlledLifetimeManager()
    {
      IExample example;
      using (IUnityContainer cOntainer= new UnityContainer())
      {
        container.RegisterType(typeof(IExample), typeof(Example),
          new ContainerControlledLifetimeManager());

        IUnityContainer firstSub = null;
        IUnityContainer secOndSub= null;

        try
        {
          firstSub = container.CreateChildContainer();
          secOndSub= container.CreateChildContainer();

          // all containers share same instance
          // each resolve returns same instance
          firstSub.Resolve().SayHello();

          // run one resolving in other thread and still receive same instance
          Thread thread = new Thread(
            () => secondSub.Resolve().SayHello());
          thread.Start();

          container.Resolve().SayHello();
          example = container.Resolve();
          thread.Join();
        }
        finally
        {
          if (firstSub != null) firstSub.Dispose();
          if (secondSub != null) secondSub.Dispose();
        }
      }

      try
      {
        // exception - instance has been disposed with container
        example.SayHello();
      }
      catch (ObjectDisposedException ex)
      {
        Console.WriteLine(ex.Message);
      }

      Console.ReadKey();
    }

private static void TestHierarchicalLifetimeManager()
    {
      IExample example;
      using (IUnityContainer cOntainer= new UnityContainer())
      {
        container.RegisterType(typeof(IExample), typeof(Example),
          new HierarchicalLifetimeManager());

        IUnityContainer firstSub = null;
        IUnityContainer secOndSub= null;

        try
        {
          firstSub = container.CreateChildContainer();
          secOndSub= container.CreateChildContainer();

          // each subcontainer has its own instance
          firstSub.Resolve().SayHello();
          secondSub.Resolve().SayHello();
          container.Resolve().SayHello();
          example = firstSub.Resolve();
        }
        finally
        {
          if (firstSub != null) firstSub.Dispose();
          if (secondSub != null) secondSub.Dispose();
        }
      }

      try
      {
        // exception - instance has been disposed with container
        example.SayHello();
      }
      catch (ObjectDisposedException ex)
      {
        Console.WriteLine(ex.Message);
      }

      Console.ReadKey();
    }

private static void TestExternallyControlledLifetimeManager()
    {
      IExample example;
      using (IUnityContainer cOntainer= new UnityContainer())
      {
        container.RegisterType(typeof(IExample), typeof(Example),
          new ExternallyControlledLifetimeManager());

        // same instance is used in following
        container.Resolve().SayHello();
        container.Resolve().SayHello();

        // run garbate collector. Stored Example instance will be released
        // beacuse there is no reference for it and LifetimeManager holds
        // only WeakReference       
        GC.Collect();

        // object stored targeted by WeakReference was released
        // new instance is created!
        container.Resolve().SayHello();
        example = container.Resolve();
      }

      example.SayHello();

      Console.ReadKey();
    }

private static void TestPerThreadLifetimeManager()
    {
      IExample example;
      using (IUnityContainer cOntainer= new UnityContainer())
      {
        container.RegisterType(typeof(IExample), typeof(Example),
          new PerThreadLifetimeManager());

        Action action = delegate(int sleep)
        {
          // both calls use same instance per thread
          container.Resolve().SayHello();
          Thread.Sleep(sleep);
          container.Resolve().SayHello();
        };

        Thread thread1 = new Thread((a) => action.Invoke((int)a));
        Thread thread2 = new Thread((a) => action.Invoke((int)a));
        thread1.Start(50);
        thread2.Start(50);

        thread1.Join();
        thread2.Join();

        example = container.Resolve();
      }

      example.SayHello();

      Console.ReadKey();
    }

private static void TestPerResolveLifetimeManager()
    {
      IExample example;
      using (IUnityContainer cOntainer= new UnityContainer())
      {
        container.RegisterType(typeof(IExample), typeof(Example),
          new PerResolveLifetimeManager());

        container.Resolve().SayHello();
        container.Resolve().SayHello();

        example = container.Resolve();
      }

      example.SayHello();

      Console.ReadKey();
    }