C# UnityContainer.ResolveAll方法代码示例

        public void ResolveAllOnlyReturnsInterfaceRegistrations()
        {
            ITest iTest;

            ATest objA = new ATest();
            BTest objB = new BTest();
            CTest objC = new CTest();

            objA.Strtest = "Hi";

            UnityContainer uc1 = new UnityContainer();

            uc1.RegisterType<ITest, ATest>();

            iTest = objA;
            uc1.RegisterInstance("ATest", iTest);
            iTest = objB;
            uc1.RegisterInstance("BTest", iTest);
            iTest = objC;
            uc1.RegisterInstance("CTest", iTest);

            List<ATest> list = new List<ATest>(uc1.ResolveAll<ATest>());
            List<ITest> list3 = new List<ITest>(uc1.ResolveAll<ITest>());

            Assert.AreEqual(0, list.Count);
            Assert.AreEqual(3, list3.Count);
        }

        public void Can_add_all_as_singletons()
        {
            var container = new UnityContainer();

            container.Configure(x => x.Scan(scan =>
            {
                scan.AssemblyContaining<FooRegistry>();
                scan.WithAddAllConvention().TypesImplementing<IHaveManyImplementations>().AsSingleton();
            }));

            Assert.That(container.ResolveAll<IHaveManyImplementations>().First(), Is.SameAs(container.ResolveAll<IHaveManyImplementations>().First()));
        }

        public void Adds_all_types_implementing_the_specified_type_with_default_name()
        {
            var container = new UnityContainer();

            container.Configure(x => x.Scan(scan =>
            {
                scan.AssemblyContaining<FooRegistry>();
                scan.WithAddAllConvention().TypesImplementing<IHaveManyImplementations>();
            }));

            Assert.That(container.ResolveAll<IHaveManyImplementations>().Count(), Is.EqualTo(2));
            Assert.That(container.ResolveAll<IHaveManyImplementations>().First(), Is.Not.SameAs(container.ResolveAll<IHaveManyImplementations>().First()));
        }

        public void RegisterSameType()
        {
            IUnityContainer uc = new UnityContainer()
                .RegisterType<ITemporary, Temp>("First");

            List<ITemporary> temporaries = new List<ITemporary>(uc.ResolveAll<ITemporary>());

            Assert.AreEqual(1, temporaries.Count);

            uc.RegisterType<ITemporary, Temp2>("First");
            temporaries = new List<ITemporary>(uc.ResolveAll<ITemporary>());

            Assert.AreEqual(1, temporaries.Count);
        }

        static void Main(string[] args)
        {
            IUnityContainer container = new UnityContainer();

            // only do this if CSLA DataPortal is NOT deployed on a physical server
            // if this Appsetting has value, it means that DataPortal is on a separate physical server
            if (string.IsNullOrEmpty(ConfigurationManager.AppSettings["CslaDataPortalProxy"]))
            {
                // register all the composers you need to properly register dependencies that are used in your business objects
                // add a name to properly distinguish each belonging to type IContainerComposer
                // so that ResolveAll<IContainerComposer>() will actually return a value
                container.RegisterType(typeof(IContainerComposer), typeof(DataContextComposer), typeof(DataContextComposer).ToString());
                container.RegisterType(typeof(IContainerComposer), typeof(JustAnotherSampleServiceComposer), typeof(JustAnotherSampleServiceComposer).ToString());

                ApplicationContext.DataPortalActivator = new CustomDataPortalActivator(container.ResolveAll<IContainerComposer>());
                CS.DataPortal.InterceptorType = typeof(CustomDataPortalInterceptor);
            }

            // call your bootstrapper for your UI dependencies
            bootstrapUIDependencies(container);


            MyExecutionClass runner = container.Resolve<MyExecutionClass>();
            runner.Run();
        }

        private void UnityWithConfiguration()
        {
            // Create and populate a new Unity container from configuration            
            UnityConfigurationSection UnityConfigurationSectionObject = (UnityConfigurationSection)ConfigurationManager.GetSection("UnityBlockConfiguration");
            IUnityContainer UnityContainerObject = new UnityContainer();

            UnityConfigurationSectionObject.Containers["ContainerOne"].Configure(UnityContainerObject);
            Console.WriteLine("\nRetrieved the populated Unity Container.");

            // Get the logger to write a message and display the result. No name in config file.
            ILogger ILoggerInstance = UnityContainerObject.Resolve < ILogger>();            
            Console.WriteLine("\n" + ILoggerInstance.WriteMessage("HELLO Default UNITY!"));

            // Resolve an instance of the appropriate class registered for ILogger 
            // Using the specified mapping name in the configuration file (may be empty for the default mapping)
            ILoggerInstance = UnityContainerObject.Resolve<ILogger>("StandardLoggerMappedInConfig");
            
            // Get the logger to write a message and display the result
            Console.WriteLine("\n" + ILoggerInstance.WriteMessage("HELLO StandardLogger!"));
            
            // Resolve an instance of the appropriate class registered for ILogger 
            // Using the specified mapping name (may be empty for the default mapping)
            ILoggerInstance = UnityContainerObject.Resolve<ILogger>("SuperFastLoggerMappedInConfig");
            
            // Get the logger to write a message and display the result
            Console.WriteLine("\n" + ILoggerInstance.WriteMessage("HELLO SuperFastLogger!"));

            // Constructor Injection.
            // Resolve an instance of the concrete MyObjectWithInjectedLogger class 
            // This class contains a reference to ILogger in the constructor parameters 
            MyObjectWithInjectedLogger MyObjectWithInjectedLoggerInstance = UnityContainerObject.Resolve<MyObjectWithInjectedLogger>();
            // Get the injected logger to write a message and display the result
            Console.WriteLine("\n" + MyObjectWithInjectedLoggerInstance.GetObjectStringResult());

            // Throws error as we are trying to create instance for interface.
            //IMyInterface IMyInterfaceObject = UnityContainerObject.Resolve<IMyInterface>();

            IMyInterface IMyInterfaceObject = UnityContainerObject.Resolve<IMyInterface>();
            Console.WriteLine("\n" + IMyInterfaceObject.GetObjectStringResult());

            //If we are not sure whether a named registration exists for an object, 
            // we can use the ResolveAll method to obtain a list of registrations and mappings, and then check for the object we need in the list returned by this method. 
            // However, this will cause the container to generate all the objects for all named registrations for the specified object type, which will affect performance.
            IEnumerable<object> IEnumerableObjects = UnityContainerObject.ResolveAll(typeof(ILogger));
            int i = 0;
            foreach (ILogger foundObject in IEnumerableObjects)
            {
                // Convert the object reference to the "real" type
                ILogger theObject = foundObject as ILogger;
                i++;
                if (null != theObject)
                {
                    Console.WriteLine(theObject.WriteMessage("Reading Object " + i.ToString()));
                }
            }
            
            UnityContainerObject.Teardown(IMyInterfaceObject);

            Console.ReadLine();
        }

        public static IUnityContainer CreateUnityContainer()
        {
            var container = new UnityContainer();
            container.RegisterType<IMediator, Mediator>();
            var types = AllClasses.FromAssemblies( typeof( Program ).Assembly );

            container.RegisterTypes(
                types,
                WithMappings.FromAllInterfaces,
                GetName,
                GetLifetimeManager,
                null,
                true );

            container.RegisterInstance<SingleInstanceFactory>( t =>
             {
                 var pipeline = container.Resolve(
                     typeof( MediatorPipeline<,> ).MakeGenericType( t.GetGenericArguments() )
                 );

                 return pipeline;

             } );
            container.RegisterInstance<MultiInstanceFactory>( t => container.ResolveAll( t ) );

            return container;
        }

        public void FixtureSetup()
        {
            this.unityContainer = new UnityContainer();
            IoC.Initialize(
                (x, y) => this.unityContainer.RegisterType(x, y),
                (x, y) => this.unityContainer.RegisterInstance(x, y),
                (x) => { return unityContainer.Resolve(x); },
                (x) => { return unityContainer.ResolveAll(x); });

            // Context Factory
            RavenUnitOfWorkFactory ctxFactory = new RavenUnitOfWorkFactory();
            Raven.Client.Document.DocumentStore sessionFactory = ctxFactory.CreateDocumentStore();

            IoC.RegisterInstance<IDatabaseManager>(ctxFactory);
            IoC.RegisterInstance<IUnitOfWorkFactory>(ctxFactory);

            this.unityContainer.RegisterType<IDocumentSession, IDocumentSession>(new InjectionFactory((c) =>
            {
                return ctxFactory.CurrentDocumentSession;
            }));

            // Repositories
            this.unityContainer.RegisterType<IEntityARepository, EntityARavenRepository>();

            // Services
            if (!ctxFactory.DatabaseExists())
            {
                ctxFactory.CreateDatabase();
            }

            ctxFactory.ValidateDatabaseSchema();
        }

        public void RegisterTypeWithoutNameandGetAll()
        {
            IUnityContainer uc = new UnityContainer().RegisterType<ITemporary, Temp>().RegisterType<ITemporary, Temporary>();

            List<ITemporary> temporaries = new List<ITemporary>(uc.ResolveAll<ITemporary>());

            Assert.AreEqual(0, temporaries.Count);
        }

 public void ConfigureContainerbyAddingExteralPolicy()
 {
     IUnityContainer container = new UnityContainer();
     container.AddNewExtension<Interception>();
     container.Configure<Interception>().AddPolicy("myRDP");
     List<InjectionPolicy> policy = new List<InjectionPolicy>(container.ResolveAll<InjectionPolicy>());
     Assert.AreEqual("myRDP", policy[1].Name);
 }

        public void ResolvingAllRegistratiosnForaTypeReturnsAnEmptyArrayWhenNothingIsRegisterd()
        {
            IUnityContainer container = new UnityContainer();

            IEnumerable<CollectionSupportTestClass> resolved = container.ResolveAll<CollectionSupportTestClass>();
            List<CollectionSupportTestClass> resolvedList = new List<CollectionSupportTestClass>(resolved);

            Assert.AreEqual(0, resolvedList.Count);
        }

 public void ConfigureContainerbyAddingEmptyHandlerRuleThrowException()
 {
     IUnityContainer container = new UnityContainer();
     container.AddNewExtension<Interception>();
     container.Configure<Interception>().
         AddPolicy("myRDP").
         AddCallHandler(String.Empty).
         AddMatchingRule(String.Empty);
     List<InjectionPolicy> policy = new List<InjectionPolicy>(container.ResolveAll<InjectionPolicy>());
 }

        private static IUnityContainer BuildUnityContainer()
        {
            var container = new UnityContainer();

            container.RegisterType<IMovieDataAccess, YoutubeService>("YoutubeService");
            container.RegisterType<IMovieDataAccess, OMDBService>("OMDBService");
            container.RegisterInstance<IAppCache>(MovieTrailers.DataAccess.AppCache.Instance);
            container.RegisterInstance<IMovieTrailerService>(new MovieTrailerService(container.ResolveAll<IMovieDataAccess>()));
            return container;
        }

        public void RegisterMultipleImplementationsOfTheSameType()
        {
            var container = new UnityContainer();
            container.RegisterType<IIngredient, Steak>("meat");
            container.RegisterType<IIngredient, SauceBéarnaise>("sauce");

            var ingredients = container.ResolveAll<IIngredient>();

            Assert.True(ingredients.OfType<Steak>().Any());
            Assert.True(ingredients.OfType<SauceBéarnaise>().Any());
        }

        public void Can_add_all_implementations_of_an_open_generic()
        {
            var container = new UnityContainer();

            container.Configure(x => x.Scan(scan =>
            {
                scan.AssemblyContaining<FooRegistry>();
                scan.WithAddAllConvention().TypesImplementing(typeof(IHandler<>));
            }));

            Assert.That(container.ResolveAll<IHandler<Message>>().Count(), Is.EqualTo(2));
        }