C# DependencyInjectionContainer.Locate方法代码示例

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

            container.ConfigureWithXml("thirdGrace");

            IConstructorImportService importService = container.Locate<IConstructorImportService>();

            Assert.NotNull(importService);

            Assert.Equal(5, container.Locate("IntProperty"));
        }

        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"));
        }

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

            container.Configure(c => c.Export<DispatchedMessenger>().As<IDispatchedMessenger>().AndSingleton());

            TestClass tc = container.Locate<TestClass>();

            IDispatchedMessenger dispatchedMessenger = container.Locate<IDispatchedMessenger>();

            dispatchedMessenger.Send(5, "Multiply");

            Assert.AreEqual(50, tc.TestInt);
        }

        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 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);
        }

        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 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 ImportIInjectionScopeDiagnostic()
		{
			DependencyInjectionContainer container = new DependencyInjectionContainer();

			InjectionScopeDiagnostic diag = container.Locate<InjectionScopeDiagnostic>();

			Assert.Equal(0, diag.PossibleMissingDependencies.Count());
		}

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

			container.Substitute();

			container.Configure(c => c.Export<ImportConstructor>());

			container.Locate<IBasicService>().SomeMethod().Returns(5);

			ImportConstructor constructor = container.Locate<ImportConstructor>();

			Assert.NotNull(constructor);
			Assert.NotNull(constructor.BasicService);

			Assert.Equal(5, constructor.BasicService.SomeMethod());
		}

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

            container.ConfigureWithXml();

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

            Assert.NotNull(basicService);
        }

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

            container.ConfigureWithXml();

            int intProperty = (int)container.Locate("IntProperty");

            Assert.Equal(5, intProperty);
        }

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

            container.ConfigureWithXml();

            IConstructorImportService importService = container.Locate<IConstructorImportService>();

            Assert.NotNull(importService);
        }

        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 ResolveTest()
        {
            DependencyInjectionContainer container = new DependencyInjectionContainer();

            container.Substitute();

            container.Configure(c => c.Export<ImportConstructorService>().As<IImportConstructorService>());

            container.Locate<IBasicService>().TestMethod().Returns(5);
            container.Locate<IBasicService>().Count.Returns(5);

            IImportConstructorService importConstructorService =
                container.Locate<IImportConstructorService>();

            Assert.NotNull(importConstructorService);
            Assert.NotNull(importConstructorService.BasicService);

            Assert.Equal(5, importConstructorService.BasicService.Count);
            Assert.Equal(5, importConstructorService.BasicService.TestMethod());
        }