C# UnityContainer.AddExtension方法代码示例

      private static IUnityContainer ConfigureContainer(IServiceProvider package, ServiceLocatorOptions options)
      {
         if (package == null)
            throw new ArgumentNullException(nameof(package), $"{nameof(package)} is null.");

         IUnityContainer container = new UnityContainer();
         container.AddExtension(new ServiceProviderUnityExtension(package, options));

         container.RegisterType<IToolkit, TookitImpl>(new ContainerControlledLifetimeManager());
         container.RegisterTypes(new SolutionExplorerNodeFactoryRegistrationConvention());
         container.RegisterType<IEnumerable<ISolutionExplorerNodeFactory>, ISolutionExplorerNodeFactory[]>();
         container.RegisterType<ISolutionExplorerNodeFactory, GlobalSolutionExplorerNodeFactory>();

         container.RegisterType<ISolutionExplorer, SolutionExplorer>();
         container.RegisterType<IOutputWindow, OutputWindow>(new ContainerControlledLifetimeManager());
         container.RegisterType<IDialogService, DialogService>(new ContainerControlledLifetimeManager());

         container.RegisterType<IEnumerable<ICommandImplementation>, ICommandImplementation[]>();

         container.RegisterInstance<IServiceProvider>(package);

         container.RegisterType<ICommandManager, CommandManager>(new ContainerControlledLifetimeManager());

         UnityServiceLocator serviceLocator = new UnityServiceLocator(container);
         container.RegisterInstance<IServiceLocator>(serviceLocator);

         if (!ServiceLocator.IsLocationProviderSet)
            ServiceLocator.SetLocatorProvider(() => serviceLocator);

         return container;
      }

 public void ResolveLooseInterfaceTest()
 {
     var container = new UnityContainer();
     container.AddExtension(MockUnit.Extension);
     var list = container.Resolve<IList>();
     Assert.IsFalse(list.Contains(string.Empty));
 }

 public void Test()
 {
     var container = new UnityContainer();
     var settings = new Settings();
     container.AddExtension(new Bootstrapper(settings));
     container.Resolve<ProjectController>();
 }

        public void Ext_ContainerCallsExtensionsInitializeMethod()
        {
            MockContainerExtension extension = new MockContainerExtension();
            IUnityContainer container = new UnityContainer();
            container.AddExtension(extension);

            Assert.IsTrue(extension.InitializeWasCalled);
        }

        public void CheckExtensionAdded()
        {
            MyCustomExtension extension = new MyCustomExtension();
            IUnityContainer uc = new UnityContainer();
            uc.AddExtension(extension);

            Assert.IsTrue(extension.CheckExtensionValue);
        }

        public void CheckExtensionAddedToContainer()
        {
            MyCustomExtension extension = new MyCustomExtension();
            IUnityContainer uc = new UnityContainer();
            uc.AddExtension(extension);

            Assert.AreSame(uc, extension.Container);
        }

 public void ResolveOnRegisteredTypeShouldNotBeMocked()
 {
     var container = new UnityContainer();
     container.AddExtension(MockUnit.Extension);
     container.RegisterType<IMyInterface, MyClass>(new ContainerControlledLifetimeManager());
     var resolved = container.Resolve<IMyInterface>();
     Assert.IsNotNull(resolved);
     Assert.AreEqual(typeof (MyClass), resolved.GetType());
 }

 public void ResolveLooseInterfaceWithSetupTest()
 {
     var container = new UnityContainer();
     container.AddExtension(MockUnit.Extension);
     var mock = MockUnit.Get<IList>();
     mock.Setup(x => x.Contains(It.IsAny<string>())).Returns(true);
     var list = container.Resolve<IList>();
     Assert.IsTrue(list.Contains(string.Empty));
 }

        public static IUnityContainer Register()
        {
            var container = new UnityContainer();

            // Register types in TextUtilModule
            container.AddExtension(new TextUtilModule());

            return container;
        }

        public void AddExistingMyCustonExtensionToContainer()
        {
            MyCustomExtension extension = new MyCustomExtension();
            IUnityContainer uc = new UnityContainer();
            uc.AddExtension(extension);

            Assert.IsNotNull(uc);
            Assert.IsTrue(extension.CheckPolicyValue);
        }

        public void Ext_ReceivesExtensionContextInInitialize()
        {
            MockContainerExtension extension = new MockContainerExtension();
            IUnityContainer container = new UnityContainer();
            container.AddExtension(extension);

            Assert.IsNotNull(extension.Context);
            Assert.AreSame(container, extension.Context.Container);
        }

        public UnityContainerAdapter CreateNewContainer()
        {
            IUnityContainer container = new UnityContainer();
             foreach ( UnityContainerExtension extension in Extensions )
             {
            container.AddExtension( extension );
             }

             return new UnityContainerAdapter( container, InjectionMembers );
        }

        public void InstallsHandlerInstance()
        {
            // Arrange
            var container = new UnityContainer();
            container.RegisterInstance(new EmbeddableDocumentStore { RunInMemory = true }.Initialize());

            // Act
            var aggregateHandlers = new IEventHandler[] { new AggregateHandler() };
            var extension = EventStoreContainerExtension.FromHandlerInstances(aggregateHandlers);
            container.AddExtension(extension);

            // Assert
            VerifyContainer(new UnityServiceLocator(container), 1);
        }

        public void InstallsHandlerTypes()
        {
            // Arrange
            var container = new UnityContainer();
            container.RegisterInstance(new EmbeddableDocumentStore { RunInMemory = true }.Initialize());

            // Act
            var handlerTypes = new[] { typeof(AggregateHandler), typeof(AnotherAggregateHandler) };
            var extension = EventStoreContainerExtension.FromHandlerTypes(handlerTypes);
            container.AddExtension(extension);

            // Assert
            VerifyContainer(new UnityServiceLocator(container), 2);
        }

        public static UnityContainer Install()
        {
            var container = new UnityContainer();

            container.AddExtension(
                new UnityInterfaceInterceptionRegister(
                    new[] { typeof(IValuesProvider), typeof(IDisposableValuesProvider) },
                    new IInterceptionBehavior[] { new LoggingInterceptionBehaviour() }));

            container.RegisterType(typeof(IValuesProvider), typeof(ValuesProvider), new PerRequestLifetimeManager());
            container.RegisterType(
                typeof(IDisposableValuesProvider),
                typeof(DisposableValuesProvider),
                new PerRequestLifetimeManager());
            container.RegisterType(typeof(System.Web.Http.Tracing.ITraceWriter), typeof(NLogger), new HierarchicalLifetimeManager());
            
            return container;
        }