C# DependencyInjectionContainer.Configure方法代码示例

        public void BulkLocateWithKey()
        {
            DependencyInjectionContainer container = new DependencyInjectionContainer();

            container.Configure(c => c.Export(Types.FromThisAssembly())
                                      .ByInterface<ISimpleObject>()
                                      .WithKey(t => t.Name.Last()));

            container.Configure(c =>
            {
                foreach (char ch in "ABCDE")
                {
                    c.Export<ImportSingleSimpleObject>()
                     .WithKey(ch)
                     .WithCtorParam<ISimpleObject>()
                     .LocateWithKey(ch);
                }
            });

            ImportSingleSimpleObject single = container.Locate<ImportSingleSimpleObject>(withKey: 'A');

            Assert.NotNull(single);
            Assert.IsType<SimpleObjectA>(single.SimpleObject);

            Assert.Equal(3, container.LocateAll<ImportSingleSimpleObject>(withKey: new[] { 'A', 'C', 'E' }).Count);
        }

		public void CombinedSpecialTest()
		{
			DependencyInjectionContainer container = new DependencyInjectionContainer();

			container.Configure(c => c.Export<LazyService>().As<ILazyService>().WithMetadata("Hello", "World"));

			LazyService.Created = false;

			Lazy<Meta<ILazyService>> lazy = container.Locate<Lazy<Meta<ILazyService>>>();

			Assert.NotNull(lazy);
			Assert.False(LazyService.Created);

			Assert.NotNull(lazy.Value);
			Assert.NotNull(lazy.Value.Value);

			ILazyService service = lazy.Value.Value;

			Assert.NotNull(service);
			Assert.True(LazyService.Created);

			KeyValuePair<string, object> metadata = lazy.Value.Metadata.First();

			Assert.Equal("Hello", metadata.Key);
			Assert.Equal("World", metadata.Value);
		}

        public void OwnedLazyMetaTest()
        {
            DependencyInjectionContainer container = new DependencyInjectionContainer();

            container.Configure(c => c.Export<DisposableService>().As<IDisposableService>().WithMetadata(
                "Hello",
                "World"));

            Owned<Lazy<Meta<IDisposableService>>> ownedLazy =
                container.Locate<Owned<Lazy<Meta<IDisposableService>>>>();

            Assert.NotNull(ownedLazy);
            Assert.NotNull(ownedLazy.Value);
            Assert.NotNull(ownedLazy.Value.Value);
            Assert.NotNull(ownedLazy.Value.Value.Value);

            bool disposedCalled = false;

            ownedLazy.Value.Value.Value.Disposing += (sender, args) => disposedCalled = true;

            ownedLazy.Dispose();

            Assert.True(disposedCalled);

            KeyValuePair<string, object> metadata = ownedLazy.Value.Value.Metadata.First();

            Assert.Equal("Hello", metadata.Key);
            Assert.Equal("World", metadata.Value);
        }

		static int Main(string[] args)
		{
			DependencyInjectionContainer container = new DependencyInjectionContainer();

			container.Configure(c => c.Export(Types.FromThisAssembly()).
											   ByInterface(typeof(IExampleModule)).
											   ByInterface(typeof(IExampleSubModule<>)).
											   ByInterface(typeof(IExample<>)));

			IEnumerable<IExampleModule> exampleModules = container.LocateAll<IExampleModule>();

			try
			{
				foreach (IExampleModule exampleModule in exampleModules)
				{
					exampleModule.Execute();
				}
			}
			catch (Exception exp)
			{
				Console.WriteLine("Exception thrown");
				Console.WriteLine(exp.Message);

			    return -1;
			}

		    return 0;
		}

        public void BeginLifetimeScope()
        {
            DependencyInjectionContainer container = new DependencyInjectionContainer();

            container.Configure(c => c.Export<DisposableService>().As<IDisposableService>().Lifestyle.SingletonPerScope());

            IDisposableService service = container.Locate<IDisposableService>();

            Assert.NotNull(service);

            bool called = false;

            using (var scope = container.BeginLifetimeScope())
            {
                var secondService = scope.Locate<IDisposableService>();

                Assert.NotNull(secondService);
                Assert.NotSame(service, secondService);
                Assert.Same(secondService, scope.Locate<IDisposableService>());

                secondService.Disposing += (sender, args) => called = true;
            }

            Assert.True(called);
        }

        public void FactoryFiveArgWithOutBasicAndOutOfOrderTest()
        {
            DependencyInjectionContainer container = new DependencyInjectionContainer();

            BasicService basicService = new BasicService();

            container.Configure(c =>
                                {
                                    c.Export<FiveArgParameterService>().As<IArrayOfObjectsPropertyService>();
                                    c.ExportInstance(basicService).As<IBasicService>();
                                });

            FiveArgParameterService.ActivateWithOutBasicServiceAndOutOfOrder factory =
                container.Locate<FiveArgParameterService.ActivateWithOutBasicServiceAndOutOfOrder>();

            Assert.NotNull(factory);

            IArrayOfObjectsPropertyService instance = factory(14.0m, "Blah", 9.0, 5);

            Assert.NotNull(instance);
            Assert.Equal(5, instance.Parameters.Length);
            Assert.Equal("Blah", instance.Parameters[0]);
            Assert.Equal(5, instance.Parameters[1]);
            Assert.Equal(9.0, instance.Parameters[2]);
            Assert.Equal(14.0m, instance.Parameters[3]);
            Assert.Equal(basicService, instance.Parameters[4]);
        }

        public void AutoCreateTest()
        {
            DependencyInjectionContainer container = new DependencyInjectionContainer();

            container.Configure(c => c.Export<BasicService>().As<IBasicService>());

            ImportConstructorService constructorService = container.Locate<ImportConstructorService>();

            Assert.NotNull(constructorService);
        }

        public void InEnvironment()
        {
            DependencyInjectionContainer container = new DependencyInjectionContainer(ExportEnvironment.UnitTest);

            container.Configure(c => c.ExportAssembly(GetType().Assembly).InEnvironment(ExportEnvironment.RunTimeOnly));

            IEnumerable<ISimpleObject> simpleObjects = container.LocateAll<ISimpleObject>();

            Assert.NotNull(simpleObjects);
            Assert.Equal(0, simpleObjects.Count());
        }

        private static IDependencyInjectionContainer CreateDIContainer()
        {
            var container = new DependencyInjectionContainer { ThrowExceptions = false };

            container.Configure(
                registration => registration
                    .Export<PeopleService>()
                    .As<IPeopleService>());

            return container;
        }

        public void SelectTypes()
        {
            DependencyInjectionContainer container = new DependencyInjectionContainer();

            container.Configure(
                c => c.ExportAssembly(GetType().Assembly).ByInterface(typeof(ISimpleObject)).Select(TypesThat.EndWith("C")));

            IEnumerable<ISimpleObject> simpleObjects = container.LocateAll<ISimpleObject>();

            Assert.NotNull(simpleObjects);
            Assert.Equal(1, simpleObjects.Count());
        }

        public void ExportInterfaces()
        {
            DependencyInjectionContainer container = new DependencyInjectionContainer();

            container.Configure(
                c => c.ExportAssembly(GetType().Assembly).ByInterfaces(t => t.Name.StartsWith("ISimple")));

            IEnumerable<ISimpleObject> simpleObjects = container.LocateAll<ISimpleObject>();

            Assert.NotNull(simpleObjects);
            Assert.Equal(5, simpleObjects.Count());
        }

        public void BasedOnInterfaceByType()
        {
            DependencyInjectionContainer container = new DependencyInjectionContainer();

            container.Configure(c => c.Export(Types.FromThisAssembly())
                                              .BasedOn<ISimpleObject>()
                                              .ByType());

            SimpleObjectA simpleObjectA = container.Locate<SimpleObjectA>();

            Assert.NotNull(simpleObjectA);
        }

        public void DebugConsoleLog()
        {
            Logger.SetLogService(new DebugConsoleLogService());

            DependencyInjectionContainer container = new DependencyInjectionContainer();

            container.Configure(c => c.Export<BasicService>().As<IBasicService>());

            IBasicService basicService = container.Locate<IBasicService>();

            Assert.NotNull(basicService);
        }

		public void AttributedPropertyInjection()
		{
			DependencyInjectionContainer container = new DependencyInjectionContainer();

			container.Configure(c => c.Export<AttributeBasicService>().As<IAttributeBasicService>());

			AttributedImportPropertyService service = new AttributedImportPropertyService();

			container.Inject(service);

			Assert.NotNull(service.BasicService);
			Assert.IsType(typeof(AttributeBasicService), service.BasicService);
		}

        public void AsKeyedStringTest()
        {
            DependencyInjectionContainer container = new DependencyInjectionContainer();

            container.Configure(c =>
                                {
                                    c.ExportInstance((scope, context) => "Hello");
                                    c.ExportInstance((scope, context) => "HelloAgain").AsKeyed<string,string>("Key");
                                });

            Assert.Equal("Hello",container.Locate<string>());
            Assert.Equal("HelloAgain",container.Locate<string>(withKey: "Key"));
        }