Microsoft.Practices.Unity

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

using UnityStudyConsole.IDemo;
using UnityStudyConsole.Demo;
using UnityStudyConsole.InterceptionBehavior;

using Microsoft.Practices.Unity;
using Microsoft.Practices.Unity.Configuration;
using Microsoft.Practices.Unity.InterceptionExtension;
using System.Configuration;


namespace UnityStudyConsole
{
    class Program
    {
        static IUnityContainer container = new UnityContainer();
        static void Main(string[] args)
        {
            //ContainerCode();
            //ContainerConfigurationFromFile("unity.config");
            //RegisterTypeCode();
            //RegisterTypeCodeConfiguration();
            //RegisterInstance();
            //TransientLifetimeManagerCode();
            //TransientLifetimeManagerConfiguration();
            //ContainerControlledLifetimeManagerCode();
            //HierarchicalLifetimeManagerCode();
            //PerResolveLifetimeManagerCode();
            //PerResolveLifetimeManagerConfiguration();
            //PerThreadLifetimeManagerCode();
            //ExternallyControlledLifetimeManagerCode();
            //ResolveParameter();
            //ResolveProperty();
            //ResolveDependency();
            //DeferringResolve();
            //RegisterAll();
            //ConstructorInjection();
            //PropertyInjection();
            //MethodInjection();
            //DIConfiguration();
            //BuildUp();
            //TestInterception();
            TestVirtualMethodInterceptor();
            //TestInterceptionConfiguration();
        }

        #region 基础
        public static void ContainerCode()
        {
            container.RegisterType<IClass, MyClass>();
            //另一种注册方法，不过没有RegisterType<>()方法来的方便
            //container.RegisterType(typeof(IClass), typeof(MyClass));
            IClass classInfo = container.Resolve<IClass>();
            //另一种通过container获取具体对象的方法
            //IClass classInfo = container.Resolve(typeof(IClass));
            classInfo.ShowInfo();
        }

        public static void ContainerConfiguration()
        {
            //获取指定名称的配置节
            UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
            //默认方法，默认获取名称为"unity"配置节下配置信息
            //container.LoadConfiguration();
            //获取已命名的配置节<container name="First">下的配置信息
            //container.LoadConfiguration("First");
            //获取特定配置节下配置信息
            //container.LoadConfiguration(section);
            //获取特定配置节下已命名的配置节<container name="First">下的配置信息
            container.LoadConfiguration(section, "First");
           // section.Containers[1].Configure();
            IClass classInfo = container.Resolve<IClass>();
            classInfo.ShowInfo();
        }

        public static void ContainerConfigurationFromFile(string configFile)
        {
            //根据文件名获取指定config文件
            var fileMap = new ExeConfigurationFileMap { ExeConfigFilename = configFile };
            //从config文件中读取配置信息
            Configuration configuration =
                ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None);
            var unitySection = (UnityConfigurationSection)configuration.GetSection("unity");

            var container = new UnityContainer()
                .LoadConfiguration(unitySection, "First");

            IClass classInfo = container.Resolve<IClass>();
            classInfo.ShowInfo();
        }
        #endregion

        #region 基础2
        public static void RegisterTypeCode()
        {
            //注册IClass与MyClass之间的关系
            //此处为IClass的默认注册，每次调用Resolve<IClass>都会返回MyClass
            container.RegisterType<IClass, MyClass>();
            //如果再次进行默认注册，将会覆盖原来的注册
            //container.RegisterType<IClass, YourClass>();
            //注册IClass与YourClass之间的关系
            //此处多了一个参数"your"，表示一个命名注册，只有当调用Resolve<IClass>("your")时才会返回YourClass
            //这种注册方法解决了当需要为某个对象注册多个对应关系时的冲突
            container.RegisterType<IClass, YourClass>("your");

            //获取具体的对象并调用
            IClass myClass = container.Resolve<IClass>();
            IClass yourClass = container.Resolve<IClass>("your");
            myClass.ShowInfo();
            yourClass.ShowInfo();

            //ResolveAll<IClass>方法可以一次性获取与IClass有注册关系的非默认对象实例
            //也就是已命名注册的对象，所以列表中只有一个对象YourClass
            IEnumerable<IClass> classList = container.ResolveAll<IClass>();
            foreach (var item in classList)
            {
                item.ShowInfo();
            }
        }

        public static void RegisterTypeCodeConfiguration()
        {
            //获取指定名称的配置节
            UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");

            container.LoadConfiguration(section, "First");

            IClass classInfo = container.Resolve<IClass>();
            classInfo.ShowInfo();

            Console.WriteLine(classInfo.GetHashCode());
            Console.WriteLine(container.Resolve<IClass>().GetHashCode());
        }

        public static void RegisterInstance()
        {
            IClass myClass = new MyClass();
            IClass yourClass = new YourClass();
            //为myClass实例注册默认实例
            container.RegisterInstance<IClass>(myClass);
            //为yourClass实例注册命名实例，同RegisterType
            container.RegisterInstance<IClass>("yourInstance", yourClass);

            container.Resolve<IClass>().ShowInfo();

            container.Resolve<IClass>("yourInstance").ShowInfo();
        }
        #endregion

        #region 生命周期管理器
        public static void TransientLifetimeManagerCode()
        {
            //以下2种注册效果是一样的
            container.RegisterType<IClass, MyClass>();
            container.RegisterType<IClass, MyClass>(new TransientLifetimeManager());
            Console.WriteLine("-------TransientLifetimeManager Begin------");
            Console.WriteLine("第一次调用RegisterType注册的对象HashCode:" +
                container.Resolve<IClass>().GetHashCode());
            Console.WriteLine("第二次调用RegisterType注册的对象HashCode:" +
                container.Resolve<IClass>().GetHashCode());
            Console.WriteLine("-------TransientLifetimeManager End------");
        }

        public static void TransientLifetimeManagerConfiguration()
        {
            //获取指定名称的配置节
            UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
            container.LoadConfiguration(section, "First");

            Console.WriteLine("-------TransientLifetimeManager Begin------");
            Console.WriteLine("第一次调用RegisterType注册的对象HashCode:" +
                container.Resolve<IClass>("transient").GetHashCode());
            Console.WriteLine("第二次调用RegisterType注册的对象HashCode:" +
                container.Resolve<IClass>("transient").GetHashCode());
            Console.WriteLine("-------TransientLifetimeManager End------");
        }

        public static void ContainerControlledLifetimeManagerCode()
        {
            IClass myClass = new MyClass();
            //以下2种注册效果是一样的
            container.RegisterInstance<IClass>("ccl", myClass);
            container.RegisterInstance<IClass>("ccl", myClass, new ContainerControlledLifetimeManager());

            container.RegisterType<IClass, MyClass>(new ContainerControlledLifetimeManager());
            Console.WriteLine("-------ContainerControlledLifetimeManager Begin------");
            Console.WriteLine("第一次调用RegisterType注册的对象HashCode:" +
                container.Resolve<IClass>().GetHashCode());
            Console.WriteLine("第二次调用RegisterType注册的对象HashCode:" +
                container.Resolve<IClass>().GetHashCode());
            Console.WriteLine("第一次调用RegisterInstance注册的对象HashCode:" +
                container.Resolve<IClass>("ccl").GetHashCode());
            Console.WriteLine("第二次调用RegisterInstance注册的对象HashCode:" +
                container.Resolve<IClass>("ccl").GetHashCode());
            Console.WriteLine("-------ContainerControlledLifetimeManager End------");
        }

        public static void ContainerControlledLifetimeManagerConfiguration()
        {
            //获取指定名称的配置节
            UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
            container.LoadConfiguration(section, "First");

            Console.WriteLine("-------ContainerControlledLifetimeManager Begin------");
            Console.WriteLine("第一次调用RegisterType注册的对象HashCode:" +
                container.Resolve<IClass>("ccl").GetHashCode());
            Console.WriteLine("第二次调用RegisterType注册的对象HashCode:" +
                container.Resolve<IClass>("ccl").GetHashCode());
            Console.WriteLine("-------ContainerControlledLifetimeManager End------");
        }

        public static void HierarchicalLifetimeManagerCode()
        {
            container.RegisterType<IClass, MyClass>(new HierarchicalLifetimeManager());
            //创建子容器
            var childContainer = container.CreateChildContainer();
            childContainer.RegisterType<IClass, MyClass>(new HierarchicalLifetimeManager());

            Console.WriteLine("-------ContainerControlledLifetimeManager Begin------");
            Console.WriteLine("第一次调用父容器注册的对象HashCode:" +
                container.Resolve<IClass>().GetHashCode());
            Console.WriteLine("第二次调用父容器注册的对象HashCode:" +
                container.Resolve<IClass>().GetHashCode());
            Console.WriteLine("第一次调用子容器注册的对象HashCode:" +
                childContainer.Resolve<IClass>().GetHashCode());
            Console.WriteLine("第二次调用子容器注册的对象HashCode:" +
                childContainer.Resolve<IClass>().GetHashCode());
            Console.WriteLine("-------ContainerControlledLifetimeManager End------");
        }

        public static void PerResolveLifetimeManagerCode()
        {
            var container = new UnityContainer()
            .RegisterType<IPresenter, MockPresenter>()
            .RegisterType<IView, View>(new PerResolveLifetimeManager());

            var view = container.Resolve<IView>();
            var tempPresenter = container.Resolve<IPresenter>();
            var realPresenter = (MockPresenter)view.Presenter;

            Console.WriteLine("-------PerResolveLifetimeManager Begin------");
            Console.WriteLine("使用了PerResolveLifetimeManager的对象 Begin");
            Console.WriteLine("通过Resolve方法获取的View对象：" +
                view.GetHashCode());
            Console.WriteLine("View对象中的Presenter对象所包含的View对象：" +
                realPresenter.View.GetHashCode());
            Console.WriteLine("使用了PerResolveLifetimeManager的对象 End");
            Console.WriteLine("");
            Console.WriteLine("未使用PerResolveLifetimeManager的对象 Begin");
            Console.WriteLine("View对象中的Presenter对象：" +
                realPresenter.GetHashCode());
            Console.WriteLine("通过Resolve方法获取的View对象：" +
                tempPresenter.GetHashCode());
            Console.WriteLine("未使用PerResolveLifetimeManager的对象 End");
            Console.WriteLine("-------PerResolveLifetimeManager Begin------");
        }

        public static void PerResolveLifetimeManagerConfiguration()
        {
            //获取指定名称的配置节
            UnityConfigurationSection section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
            container.LoadConfiguration(section, "Second");

            var view = container.Resolve<IView>();
            var tempPresenter = container.Resolve<IPresenter>();
            var realPresenter = (MockPresenter)view.Presenter;

            Console.WriteLine("-------PerResolveLifetimeManager Begin------");
            Console.WriteLine("使用了PerResolveLifetimeManager的对象 Begin");
            Console.WriteLine("通过Resolve方法获取的View对象：" +
                view.GetHashCode());
            Console.WriteLine("View对象中的Presenter对象所包含的View对象：" +
                realPresenter.View.GetHashCode());
            Console.WriteLine("使用了PerResolveLifetimeManager的对象 End");
            Console.WriteLine("");
            Console.WriteLine("未使用PerResolveLifetimeManager的对象 Begin");
            Console.WriteLine("View对象中的Presenter对象：" +
                realPresenter.GetHashCode());
            Console.WriteLine("通过Resolve方法获取的View对象：" +
                tempPresenter.GetHashCode());
            Console.WriteLine("未使用PerResolveLifetimeManager的对象 End");
            Console.WriteLine("-------PerResolveLifetimeManager Begin------");
        }

        public static void PerThreadLifetimeManagerCode()
        {
            container.RegisterType<IClass, MyClass>(new PerThreadLifetimeManager());
            var thread = new Thread(new ParameterizedThreadStart(Thread1));
            Console.WriteLine("-------PerResolveLifetimeManager Begin------");
            Console.WriteLine("默认线程 Begin");
            Console.WriteLine("第一调用:" +
                container.Resolve<IClass>().GetHashCode());
            Console.WriteLine("第二调用:" +
                container.Resolve<IClass>().GetHashCode());
            Console.WriteLine("默认线程 End");
            thread.Start(container);

        }
        public static void Thread1(object obj)
        {
            var tmpContainer = obj as UnityContainer;
            Console.WriteLine("新建线程 Begin");
            Console.WriteLine("第一调用:" +
                tmpContainer.Resolve<IClass>().GetHashCode());
            Console.WriteLine("第二调用:" +
                tmpContainer.Resolve<IClass>().GetHashCode());
            Console.WriteLine("新建线程 End");

            Console.WriteLine("-------PerResolveLifetimeManager End------");
        }

        public static void ExternallyControlledLifetimeManagerCode()
        {
            container.RegisterType<IClass, MyClass>(new ExternallyControlledLifetimeManager());
            var myClass1 = container.Resolve<IClass>();
            var myClass2 = container.Resolve<IClass>();
            Console.WriteLine("-------ExternallyControlledLifetimeManager Begin------");
            Console.WriteLine("第一次调用：" +
                myClass1.GetHashCode());
            Console.WriteLine("第二次调用：" +
                myClass2.GetHashCode());
            myClass1 = myClass2 = null;
            GC.Collect();
            Console.WriteLine("****GC回收过后****");
            Console.WriteLine("第一次调用：" +
               container.Resolve<IClass>().GetHashCode());
            Console.WriteLine("第二次调用：" +
               container.Resolve<IClass>().GetHashCode());

            Console.WriteLine("-------ExternallyControlledLifetimeManager End------");
        }
        #endregion

        #region 高级
        public static void ResolveParameter()
        {
            //由于所注册的对象的有带有参数的构造函数，所以注册类型时需要提供相应的参数
            //这边采用InjectionConstructor这个类来实现
            container.RegisterType<IClass, YourClass>(
                new InjectionConstructor("a", new MyClass()));
            Console.WriteLine("-----------默认调用输出-------------");
            container.Resolve<IClass>();

            Console.WriteLine("-----------重载后调用输出-------------");
            //以下2种Resolve方法效果是一样的
            //对于参数过多的时候可以采用第2种方法，如果参数仅仅只有1个可以用第1种
            //container.Resolve<IClass>(new ParameterOverride("test", "test"),
            //    new ParameterOverride("my", "new MyClass").OnType<MyClass>());
            container.Resolve<IClass>(new ParameterOverrides()
            {
                {"test","test"},
                {"my",new MyClass()}
            }.OnType<YourClass>());
        }

        public static void ResolveProperty()
        {
            //注册对象关系时初始化对象的属性
            container.RegisterType<IClass, MyClass>(
                new InjectionProperty("Name", "A班"),
                new InjectionProperty("Description", "A班的描述"));
            Console.WriteLine("-----------默认调用输出-------------");
            Console.WriteLine(container.Resolve<IClass>().Name);
            Console.WriteLine(container.Resolve<IClass>().Description);
            Console.WriteLine("-----------重载后调用输出-------------");
            //以下2种写法效果是一样的，同上面的构造函数参数重载
            //var myClass = container.Resolve<IClass>(new PropertyOverride("Name", "重载后的A班"),
            //    new PropertyOverride("Description", "重载后的A班的描述"));
            var myClass = container.Resolve<IClass>(new PropertyOverrides()
            {
                {"Name","重载后的A班"},
                {"Description","重载后的A班的描述"}
            }.OnType<MyClass>());

            Console.WriteLine(myClass.Name);
            Console.WriteLine(myClass.Description);
        }

        public static void ResolveDependency()
        {
            container.RegisterType<Subject1>(
                new InjectionProperty("My")).
                RegisterType<MyClass>(new InjectionConstructor());
            Console.WriteLine("---------未注册依赖关系前--------------");
            container.Resolve<Subject1>();
            Console.WriteLine(container.Resolve<Subject1>().My.Name);
            Console.WriteLine("---------未注册依赖关系后--------------");
            var myClass = new MyClass() { Name = "测试" };
            var subject = container.Resolve<Subject1>(new DependencyOverride<MyClass>(myClass));
            Console.WriteLine(subject.My.Name);
        }

        public static void DeferringResolve()
        {
            var resolver = container.Resolve<Func<IClass>>();

            //根据业务逻辑做其他事情。

            //注册IClass与MyClass之间的关系
            container.RegisterType<IClass, MyClass>();
            //获取MyClass实例
            var myClass = resolver();

            var resolver2 = container.Resolve<Func<IEnumerable<IClass>>>();

            //根据业务逻辑做其他事情。

            //注册与IClass相关的对象。
            container.RegisterType<IClass, MyClass>("my");
            container.RegisterType<IClass, YourClass>("your");
            //获取与IClass关联的所有命名实例
            var classList = resolver2();
        }

        public static void RegisterAll()
        {
            container.RegisterType<IClass, MyClass>("my");
            container.RegisterType<IClass, YourClass>("your",
                new ExternallyControlledLifetimeManager());
            container.RegisterType<ISubject, Subject1>("subject1");
            container.RegisterType<ISubject, Subject2>("subject2");
            DisplayContainerRegistrations(container);
        }

        public static void DisplayContainerRegistrations(IUnityContainer theContainer)
        {
            string regName, regType, mapTo, lifetime;
            Console.WriteLine("容器中 {0} 个注册信息:",
                    theContainer.Registrations.Count());
            foreach (ContainerRegistration item in theContainer.Registrations)
            {
                regType = item.RegisteredType.Name;
                mapTo = item.MappedToType.Name;
                regName = item.Name ?? "[默认]";
                lifetime = item.LifetimeManagerType.Name;
                if (mapTo != regType)
                {
                    mapTo = " -> " + mapTo;
                }
                else
                {
                    mapTo = string.Empty;
                }
                lifetime = lifetime.Substring(0, lifetime.Length - "生命周期管理器".Length);
                Console.WriteLine("+ {0}{1}  '{2}'  {3}", regType, mapTo, regName, lifetime);
            }
        }

        #endregion

        #region Dependency Injection
        public static void ConstructorInjection()
        {
            //container.Resolve<Subject2>();

            container.RegisterType<IClass, MyClass>()
                .RegisterType<IClass, YourClass>("your");
            container.Resolve<Subject2>();
        }

        public static void PropertyInjection()
        {
            container.RegisterType<ISubject, Subject1>("Subject1")
                .RegisterType<IClass, MyClass>();
            var classInfo = container.Resolve<IClass>();
            Console.WriteLine(classInfo.Subject.Name);
        }

        public static void MethodInjection()
        {
            container.RegisterType<ISubject, Subject3>("Subject1")
                .RegisterType<ISubject, Subject4>();
            container.RegisterType<IClass, MyClass>();

            var classInfo = container.Resolve<IClass>();
            classInfo.ShowInfo();
        }

        public static void DIConfiguration()
        {
            //获取特定配置节下已命名的配置节<container name="Third">下的配置信息
            container.LoadConfiguration("Third");
            var classInfo = container.Resolve<IClass>();
            classInfo.ShowInfo();
        }
        public static void BuildUp()
        {
            //事先注册好ISubject和MySubject之间的关系
            //并指定一个名称以方便在接口中的属性上应用[Dependency("Subject1")]特性
            //具体请见IDemo.IClass
            container.RegisterType<ISubject, Subject1>("Subject1");
            IClass classInfo = new MyClass();
            IClass classInfo2 = container.BuildUp<IClass>(classInfo);
            Console.WriteLine(classInfo2.Subject.Name);
        }
        #endregion

        public static void TestInterception()
        {
            container.AddNewExtension<Interception>();
            container.RegisterType<IStudent, Student1>(
                      //透明代理拦截
                      //new Interceptor<TransparentProxyInterceptor>(),
                      //接口拦截，与上面的透明拦截效果一样
                      new Interceptor<InterfaceInterceptor>(),
                      new InterceptionBehavior<LogBehavior>(),
                      new InterceptionBehavior<LogBehavior2>());
            var studentInfo = container.Resolve<IStudent>();
            studentInfo.ShowInfo();
        }

        public static void TestVirtualMethodInterceptor()
        {
            container.AddNewExtension<Interception>();
            container.RegisterType<Student1>(
                      new Interceptor<VirtualMethodInterceptor>(),
                      new InterceptionBehavior<LogBehavior3>(),
                      new AdditionalInterface<IStudent>());
            var studentInfo = container.Resolve<Student1>();
            studentInfo.VirtualShowInfo();
        }

        public static void TestInterceptionConfiguration()
        {
            //获取特定配置节下已命名的配置节<container name="Third">下的配置信息
            container.LoadConfiguration("Forth");
            var studentInfo = container.Resolve<IStudent>();
            studentInfo.ShowInfo();

        }

    }
}