C# Container.Inject方法代码示例

        public void ShouldRemoveExecutionContextInstanceOnly()
        {
            var instance1 = new TestClass();
            var instance2 = new TestClass();

            var container = new Container();
            container.Inject<TestInterface>(instance1, Lifecycle.HttpContextOrExecutionContextLocal);

            TestInterface[] thread2ResolvedTestClasses = null;
            bool thread2HasRegistration = true;
            ExecutionContext.SuppressFlow();
            var thread2 = new Thread(() =>
            {
                container.Inject<TestInterface>(instance2, Lifecycle.HttpContextOrExecutionContextLocal);

                thread2ResolvedTestClasses = container.ResolveAll<TestInterface>().ToArray();

                container.RemoveInstancesOf<TestInterface>(Lifecycle.HttpContextOrExecutionContextLocal);

                thread2HasRegistration = container.HasRegistrationFor<TestInterface>();
            });

            thread2.Start();
            thread2.Join(1000);
            ExecutionContext.RestoreFlow();
            Assert.IsFalse(thread2HasRegistration);
            Assert.AreEqual(1, thread2ResolvedTestClasses.Length);

            Assert.AreEqual(instance1, container.Resolve<TestInterface>());
        }

        public void ShouldResolveInjectedOverInjected()
        {
            var container = new Container();

            container.Register<TestInterface, TestClass>();

            var injector1 = new TestClass2();
            var injector2 = new TestClass2();
            container.Inject<TestInterface>(injector1);
            container.Inject<TestInterface>(injector2, injectionBehaviour: InjectionBehaviour.Override);

            Assert.AreSame(injector2, container.Resolve<TestInterface>());
        }

        public void OnEndStart_ScheduleEvery_Called()
        {
            var fakeBus = MockRepository.GenerateStub<IServiceBus>();
            var fakeScheduler = MockRepository.GenerateStub<IScheduler>();
            var fakeContainer = new Container();
            fakeContainer.Inject<IServiceBus>(fakeBus);
            fakeContainer.Inject<IScheduler>(fakeScheduler);
            var testObject = new ClientBootstrapperTest(fakeContainer);

            testObject.OnEndStart();

            fakeScheduler.AssertWasCalled(x => x.Every(
                Arg<TimeSpan>.Is.Anything, Arg<Action>.Is.NotNull));
        }

        public void ShouldRemoveInstances3()
        {
            var container = new Container();
            var class1 = new ClassA1();
            var class2 = new ClassA1();

            container.Inject(class1, Lifecycle.HttpContextOrThreadLocal);

            container.RemoveAllInstancesWithLifecycle(Lifecycle.HttpContextOrThreadLocal);

            container.Inject(class2, Lifecycle.HttpContextOrThreadLocal);

            var classA1 = container.Resolve<ClassA1>();
            Assert.AreSame(class2, classA1);
        }

        public bool Start(HostControl hostControl)
        {
            var container = new Container(cfg => cfg.Scan(scan =>
                {
                    scan.TheCallingAssembly();
                    scan.AssembliesFromApplicationBaseDirectory();
                    scan.AddAllTypesOf(typeof (IConsumer));
                }));

            try
            {
                _Bus = ServiceBusFactory.New(sbc =>
                    {
                        sbc.UseRabbitMq();
                        sbc.ReceiveFrom(ConfigurationManager.AppSettings["RabbitMQEndPoint"]);
                        sbc.Subscribe(x => x.LoadFrom(container));
                        sbc.Validate();
                    });

                container.Inject(_Bus);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                return false;
            }
            return true;
        }

        public void SetUp()
        {
            FubuTransport.Reset();

            // Need to do something about this.  Little ridiculous
            var settings = new BusSettings
            {
                Downstream = "lq.tcp://localhost:2020/downstream".ToUri()
            };

            var container = new Container();
            container.Inject(settings);

            _runtime = FubuTransport.For<DelayedRegistry>().StructureMap(container)
                                       .Bootstrap();

            theServiceBus = _runtime.Factory.Get<IServiceBus>();
            _runtime.Factory.Get<IPersistentQueues>().ClearAll();

            theClock = _runtime.Factory.Get<ISystemTime>().As<SettableClock>();

            message1 = new OneMessage();
            message2 = new OneMessage();
            message3 = new OneMessage();
            message4 = new OneMessage();

            theServiceBus.DelaySend(message1, theClock.UtcNow().AddHours(1));
            theServiceBus.DelaySend(message2, theClock.UtcNow().AddHours(1));
            theServiceBus.DelaySend(message3, theClock.UtcNow().AddHours(2));
            theServiceBus.DelaySend(message4, theClock.UtcNow().AddHours(2));
        }

        public void SetUp()
        {
            container = new Container(new RavenDbRegistry());
            container.Inject(new RavenDbSettings { RunInMemory = true });

            theReset = container.GetInstance<IPersistenceReset>();
            theUnitOfWork = new RavenUnitOfWork(container);
        }

 public void FixtureSetUp()
 {
     container = new Container(new RavenDbRegistry());
     container.Inject(new RavenDbSettings
     {
         RunInMemory = true
     });
 }

        public void ShouldRemoveInstances()
        {
            var container = new Container();
            container.Inject<InterfaceA>(new ClassA1());
            container.Register<InterfaceA, ClassA2>();

            container.RemoveAllRegistrationsAndInstancesOf<InterfaceA>();

            Assert.AreEqual(0, container.ResolveAll<InterfaceA>().Count());
        }

        public void OnEndStart_SendSchedulerMessage_Scheduled()
        {
            var fakeBus = MockRepository.GenerateStub<IServiceBus>();
            var fakeScheduler = MockRepository.GenerateStub<IScheduler>();
            var fakeContainer = new Container();
            fakeContainer.Inject<IServiceBus>(fakeBus);
            fakeContainer.Inject<IScheduler>(fakeScheduler);
            var testObject = new ClientBootstrapperTest(fakeContainer);
            testObject.OnEndStart();

            // get the action from the arguments
            var args = fakeScheduler.GetArgumentsForCallsMadeOn(x => x.Every(
                Arg<TimeSpan>.Is.Anything, Arg<Action>.Is.NotNull));
            var action = args[0][1] as Action;
            // execute the action
            action();

            fakeBus.AssertWasCalled(x => x.Send(Arg<SchedulerMessage>.Is.NotNull));
        }

        public void ContainerControllerFactory_CreateController_ReturnsExpectedTypeFromContainer_GivenContainerAndProperType()
        {
            var container = new Container();
            var controller = new ProperController();
            container.Inject<ProperController>(controller);
            var factory = new TestContainerControllerFactory(new ContainerResolver(container));
            factory.GetControllerTypeDelegate = () => typeof(ProperController);

            Assert.Same(controller, factory.CreateController(null, ""));
        }

        public void ShouldntHaveRegistrations()
        {
            var container = new Container();
            container.Register<InterfaceA, ClassA1>();
            container.Register<InterfaceA, ClassA2>();
            container.Inject<InterfaceA>(new ClassA2());

            container.RemoveAllRegistrationsAndInstancesOf<InterfaceA>();

            Assert.IsFalse(container.HasRegistrationFor<InterfaceA>());
        }

		public static IContainer CreateContainer(string sagaDb = null)
		{
			sagaDb = sagaDb ?? HttpContext.Current.Server.MapPath("~/App_Data/saga_state.db");
			if (sagaDb == null) throw new ArgumentNullException("sagaDb");

			var endpointUri = "loopback://localhost/ScreenShotter.Web/";

			// FubuApplication "guides" the bootstrapping of the FubuMVC
			// application
			var container = new Container(x =>
				{
					x.For<ISessionFactory>()
						.Singleton()
						.Add(ctx =>
							{
								var config = Fluently.Configure()
									.Database(SQLiteConfiguration.Standard.UsingFile(sagaDb))
									.Mappings(m => m.FluentMappings.AddFromAssemblyOf<WebShotSagaMap>())
									.BuildConfiguration();
									
								new SchemaUpdate(config).Execute(true, true);

								return config.BuildSessionFactory();
							});

					x.For<ISagaRepository<WebShotSaga>>()
						.Singleton()
						.Use<NHibernateSagaRepository<WebShotSaga>>();

					x.ForConcreteType<WebShotSaga>();

					x.ForConcreteType<PostHandler>().Configure.Ctor<IEndpoint>()
						.Is(ctx => ctx.GetInstance<IServiceBus>().GetEndpoint(new Uri(endpointUri)));

					x.For<IServiceBus>().Singleton();
				});

			var serviceBus = ServiceBusFactory.New(sbc =>
				{
					sbc.UseJsonSerializer();
					sbc.ReceiveFrom(endpointUri);
					sbc.Subscribe(x => x.LoadFrom(container));
				});

			PipelineViewer.Trace(serviceBus.InboundPipeline);

			//PipelineViewer.Trace(serviceBus.OutboundPipeline);

			container.Inject(serviceBus);
			return container;
		}

        protected void Application_Start(object sender, EventArgs e)
        {
            var container = new Container();
            FubuApplication.For<HarnessRegistry>().StructureMap(container).Bootstrap();

            var membership = new InMemoryMembershipRepository();
            membership.Add(new UserInfo
            {
                UserName = "jeremy",
                Password = "carthage"
            });

            container.Inject<IMembershipRepository>(membership);
        }

        public void ContainerControllerFactory_CreateController_DoesntSetActionInvoker_WhenOfCorrectType()
        {
            var container = new Container();
            var containerResolver = new ContainerResolver(container);
            var controller = new ProperController();
            var actionInvoker = new ContainerControllerActionInvoker(containerResolver);

            controller.ActionInvoker = actionInvoker;
            container.Inject<ProperController>(controller);
            var factory = new TestContainerControllerFactory(containerResolver);
            factory.GetControllerTypeDelegate = () => typeof(ProperController);

            Assert.Same(actionInvoker, (factory.CreateController(null, "") as ProperController).ActionInvoker);
        }