C# IocContainer.Register方法代码示例

        static MunqUseCase()
        {
            container = new IocContainer();
            singleton = new Munq.LifetimeManagers.ContainerLifetime();

            container.Register<IWebService>(
                c => new WebService(
                    c.Resolve<IAuthenticator>(),
                    c.Resolve<IStockQuote>()));

            container.Register<IAuthenticator>(
                c => new Authenticator(
                    c.Resolve<ILogger>(),
                    c.Resolve<IErrorHandler>(),
                    c.Resolve<IDatabase>()));

            container.Register<IStockQuote>(
                c => new StockQuote(
                    c.Resolve<ILogger>(),
                    c.Resolve<IErrorHandler>(),
                    c.Resolve<IDatabase>()));

            container.Register<IDatabase>(
                c => new Database(
                    c.Resolve<ILogger>(),
                    c.Resolve<IErrorHandler>()));

            container.Register<IErrorHandler>(
                c => new ErrorHandler(c.Resolve<ILogger>()));

            container.RegisterInstance<ILogger>(new Logger())
                    .WithLifetimeManager(singleton);
        }

        static MunqGenericUseCase()
        {
            container = new IocContainer();

            //container.Register<IWebService, WebService>();
            container.Register<IAuthenticator, Authenticator>();
            container.Register<IStockQuote, StockQuote>();
            container.Register<IDatabase, Database>();
            container.Register<IErrorHandler, ErrorHandler>();
            container.Register<ILogger,Logger>().WithLifetimeManager(singleton);
        }

        public void TestRegisterSingletonInterface()
        {
            var container = new IocContainer();
            container.Register(typeof(ConnectionName));
            container.Register(typeof(IConnection), typeof(SqlConnection), LifestyleType.Singleton);

            IConnection connection = (IConnection)container.Resolve(typeof(IConnection));
            Assert.NotNull(connection);

            IConnection connection2 = (IConnection)container.Resolve(typeof(IConnection));
            Assert.NotNull(connection);
            Assert.Equal(connection, connection2);
        }

        void SettingTheLifetimeManagerForARegistration()
        {
            // create the container.  Only done once in Application_Start
            IocContainer iocContainer = new IocContainer();

            // create a Container lifetime manager to use for 'singelton' services
            // only one instance will be created and reused for each resolve request.
            ILifetimeManager containerLifetimeManager = new LifetimeManagers.ContainerLifetime();

            iocContainer.Register<IMembershipService>( ioc => new AccountMembershipService(Membership.Provider))
                         .WithLifetimeManager(containerLifetimeManager);

            iocContainer.Register<IFormsAuthenticationService>(ioc => new FormsAuthenticationService())
                        .WithLifetimeManager(containerLifetimeManager);
        }

        public void TransientLifetimeAlwaysReturnsANewInstance()
        {
            // Arrange
            using (var container = new IocContainer())
            {
                container.Register<IFoo>(c => new Foo1());	//.SetLifetime(new TransientLifetime<IFoo>);

                // Act
                var result1 = container.Resolve<IFoo>();
                var result2 = container.Resolve<IFoo>();
                var result3 = container.Resolve<IFoo>();

                // Assert
                Assert.IsNotNull(result1);
                Assert.IsNotNull(result2);
                Assert.IsNotNull(result3);

                Assert.AreNotSame(result1, result2);
                Assert.AreNotSame(result2, result3);
                Assert.AreNotSame(result1, result3);

                Assert.IsInstanceOfType(result1, typeof(Foo1));
                Assert.IsInstanceOfType(result2, typeof(Foo1));
                Assert.IsInstanceOfType(result3, typeof(Foo1));
            }
        }

		public void SessionLifetimeReturnsSameInstanceForSameSessionAndDifferentInstanceForDifferentSession()
		{
			// Arrange
			using (var container = new IocContainer())
			{
				var sessionItems1 = new SessionStateItemCollection();
				var sessionItems2 = new SessionStateItemCollection();
				var context1 = new FakeHttpContext("Http://fakeUrl1.com", null, null, null, null, sessionItems1);
				var context2 = new FakeHttpContext("Http://fakeUrl2.com", null, null, null, null, sessionItems2);

				HttpContextBase currentContext = null;

				var lifetime = new SessionLifetime(() => currentContext);		// better solution for injecting HttpContext ?

				container.Register<IFoo>(c => new Foo1()).SetLifetime(lifetime);

				// Act
				currentContext = context1;

				var result1 = container.Resolve<IFoo>();
				var result2 = container.Resolve<IFoo>();

				currentContext = context2;

				var result3 = container.Resolve<IFoo>();

				// Assert
				Assert.IsNotNull(result1);
				Assert.IsNotNull(result2);
				Assert.IsNotNull(result3);

				Assert.AreSame(result1, result2);
				Assert.AreNotSame(result1, result3);
			}
		}

		public void ThreadLocalStorageLifetimeReturnsSameInstanceForSameThread()
		{
			using (var container = new IocContainer())
			{
				container.Register<IFoo>(c => new Foo1()).SetLifetime(new ThreadLocalLifetime());

				IFoo result1 = container.Resolve<IFoo>();
				IFoo result2 = container.Resolve<IFoo>();

				IFoo result3 = null;
				IFoo result4 = null;

				// Resolve on a different thread
				var task = Task.Factory.StartNew(() =>
				{
					result3 = container.Resolve<IFoo>();
					result4 = container.Resolve<IFoo>();
				});

				task.Wait();

				// Assert
				Assert.IsNotNull(result1);
				Assert.IsNotNull(result2);
				Assert.IsNotNull(result3);
				Assert.IsNotNull(result4);

				Assert.AreSame(result1, result2);
				Assert.AreSame(result3, result4);

				Assert.AreNotSame(result1, result3);
			}
		}

        public void CanRegisterAndResolveMultipleTypes()
        {
            using (var container = new IocContainer())
            {
                container.Register<IFoo>(c => new Foo1());
                container.Register<IBar>(c => new Bar1());

                var result1 = container.Resolve<IFoo>();
                var result2 = container.Resolve<IBar>();

                Assert.IsNotNull(result1);
                Assert.IsNotNull(result2);

                Assert.IsInstanceOfType(result1, typeof(Foo1));
                Assert.IsInstanceOfType(result2, typeof(Bar1));
            }
        }

		public void KeyResolverWorks()
		{
			using (var container = new IocContainer())
			{
				var reg1 = container.Register<IDeviceState>(x => new FooConnection(true), DeviceState.Online);
				var reg2 = container.Register<IDeviceState>(x => new FooConnection(false), DeviceState.Offline);
				var reg3 = container.Register<IHardwareDevice>(x => new Modem(x.GetKeyResolver<IDeviceState, DeviceState>()));

				var instance = container.Resolve<IHardwareDevice>();

				Assert.IsTrue(instance.State.Connected);

				instance.SwitchOff();

				Assert.IsFalse(instance.State.Connected);
			}
		}

 public void GenericResolveByTypeNotRegisteredThrowsException2()
 {
     using (var container = new IocContainer())
     {
         container.Register<IFoo>("Foo", c => new Foo1());
         container.Resolve<IFoo>();
     }
 }

        public void CompileDoesntBreakAnything()
        {
            // What to do with this ... ?
            // To find out if anything was actually compiled it needs to inspect the Expression/Lambda created

            using (var container = new IocContainer())
            {
                // Arrange
                container.Register<IFoo>(c => new Foo1());
                container.Register<IBar>("bar1name", x => new Bar1());
                container.Register<IFooBar>(y => new FooBar((IFoo)y.Resolve(typeof(IFoo)), (IBar)y.Resolve(typeof(IBar), "bar1name")));
                container.Register<IFooBar>("foobarname", xyz => new FooBar(xyz.Resolve<IFoo>(), xyz.Resolve<IBar>("bar1name")));

                // Act
                container.Compile();

                var foo = container.Resolve<IFoo>();
                var bar = container.Resolve<IBar>("bar1name");
                var foobar1 = container.Resolve<IFooBar>();
                var foobar2 = container.Resolve<IFooBar>("foobarname");

                // Assert
                Assert.AreNotSame(foo, null);
                Assert.AreNotSame(bar, null);
                Assert.AreNotSame(foobar1, null);
                Assert.AreNotSame(foobar2, null);

                Assert.AreNotSame(foobar1.Foo, null);
                Assert.AreNotSame(foobar1.Bar, null);
                Assert.AreNotSame(foobar2.Foo, null);
                Assert.AreNotSame(foobar2.Bar, null);

                Assert.IsInstanceOfType(foo, typeof(Foo1));
                Assert.IsInstanceOfType(bar, typeof(Bar1));
                Assert.IsInstanceOfType(foobar1, typeof(FooBar));
                Assert.IsInstanceOfType(foobar2, typeof(FooBar));

                Assert.IsInstanceOfType(foobar1.Foo, typeof(Foo1));
                Assert.IsInstanceOfType(foobar1.Bar, typeof(Bar1));

                Assert.IsInstanceOfType(foobar2.Foo, typeof(Foo1));
                Assert.IsInstanceOfType(foobar2.Bar, typeof(Bar1));
            }
        }

		public void ResolveAllByTypeReturnsInstancesOfExpectedType()
		{
			using (var container = new IocContainer())
			{
				container.Register<IFoo>(c => new Foo1());
				container.Register<IFoo>(c => new Foo2(), "Foo1");
				container.Register<IFoo>(c => new Foo2(), "Foo2");
				container.Register<IBar>(c => new Bar1());

				var results = container.ResolveAll<IFoo>();

				Assert.IsTrue(results.Count() == 3);

				var resultsList = results.ToList();

				CollectionAssert.AllItemsAreNotNull(resultsList);
				CollectionAssert.AllItemsAreInstancesOfType(resultsList, typeof(IFoo));
				CollectionAssert.AllItemsAreUnique(resultsList);
			}
		}

        public void TestMultiThreading()
        {
            var container = new IocContainer();
            var tasks = new Task[20];
            int taskIdx = 0;

            while (taskIdx < 20)
            {
                tasks[taskIdx++] = Task.Run(() =>
                {
                    container.Register<ConnectionName>();
                });

                tasks[taskIdx++] = Task.Run(() =>
                {
                    container.Register<ConnectionServer>();
                });
            }

            Task.WaitAll(tasks);
        }

        public void GenericResolveByTypeReturnsInstanceOfExpectedType()
        {
            using (var container = new IocContainer())
            {
                container.Register<IFoo>(c => new Foo1());
                var result = container.Resolve<IFoo>();

                Assert.IsNotNull(result);
                Assert.IsInstanceOfType(result, typeof(IFoo));
                Assert.IsInstanceOfType(result, typeof(Foo1));
            }
        }

        public void TestRegisterSingletonClassGeneric()
        {
            var container = new IocContainer();
            container.Register<ConnectionName>(LifestyleType.Singleton);

            ConnectionName connectionName = container.Resolve<ConnectionName>();
            Assert.NotNull(connectionName);

            ConnectionName connectionName2 = container.Resolve<ConnectionName>();
            Assert.NotNull(connectionName);
            Assert.Equal(connectionName, connectionName2);
        }