C# Container.With方法代码示例

        public void supply_defaults_by_generic_in_a_bunch()
        {
            var container = new Container(x =>
            {
                x.For<IWidget>().Use<BWidget>();
                x.For<IService>().Use<AService>();
            });

            // SAMPLE: explicit-defaults-with-nested-closure
            var widget = new BWidget();
            var service = new BService();

            var guyWithWidgetAndService = container
                .With(x =>
                {
                    x.With<IWidget>(widget);
                    x.With<IService>(service);
                })
                .GetInstance<GuyWithWidgetAndService>();

            guyWithWidgetAndService
                .Widget.ShouldBeTheSameAs(widget);

            guyWithWidgetAndService
                .Service.ShouldBeTheSameAs(service);
            // ENDSAMPLE
        }

        public void supply_defaults_by_generic()
        {
            // SAMPLE: explicit-arg-container
            var container = new Container(x =>
            {
                x.For<IWidget>().Use<BWidget>();
                x.For<IService>().Use<AService>();
            });
            // ENDSAMPLE

            // SAMPLE: explicit-fluent-interface
            var widget = new BWidget();
            var service = new BService();

            var guyWithWidgetAndService = container
                .With<IWidget>(widget)
                .With<IService>(service)
                .GetInstance<GuyWithWidgetAndService>();

            guyWithWidgetAndService
                .Widget.ShouldBeTheSameAs(widget);

            guyWithWidgetAndService
                .Service.ShouldBeTheSameAs(service);
            // ENDSAMPLE
        }

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

            var x = container.With<InterfaceA>(new ClassA2()).Resolve<ClassB>();

            Assert.IsInstanceOf<ClassA2>(x.A);
        }

        public void ShouldResolveHybridReplacement()
        {
            var container = new Container();
            container.Register<InterfaceA, ClassA1>(Lifecycle.HttpContextOrThreadLocal);

            var x = container.With<InterfaceA>(new ClassA2()).Resolve<InterfaceA>();

            Assert.IsInstanceOf<ClassA2>(x);
        }

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

            var x = container.With<InterfaceA>(new ClassA2()).Resolve<InterfaceA>();
            var y = container.Resolve<InterfaceA>();

            Assert.IsInstanceOf<ClassA1>(y);
        }

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

            var x = container.With<InterfaceA>(new ClassA2()).Resolve<InterfaceA>();
            var y = container.Resolve<IContainer>();
            var z = container.Resolve<IContainer>();

            Assert.IsInstanceOf<IContainer>(y);
            Assert.AreSame(y, z);
        }

 public void It_should_observe_keys()
 {
     using (var container = new Container(cfg =>
                                       {
                                           cfg.For<IService>().Use<Service>();
                                           cfg.For<Thingy>().Use<Thingy>();
                                       }))
     {
         var service = new Service();
         var thingy = container.With("service").EqualTo(service).GetAllInstances<Thingy>().First();
         thingy.Service.ShouldBeTheSameAs(service);
     }
 }

        public void Processes_WhenCalledMultipleTimes_RegistersEachHandlerType()
        {
            const string instanceName = "empty";
            var handlerCache = new HandlerCache();
            handlerCache.Set(0);

            var sut = new Registry();

            sut.Register(instanceName)
                .Processes<CounterHandler>()
                .Processes<CounterHandler>();

            var container = new Container(sut);

            HandlerProcessor processor = container.With(handlerCache).GetInstance<HandlerProcessor>(instanceName);

            processor.Process();

            Assert.AreEqual(2, handlerCache.Get(typeof(int)));
        }

        public void Processes_WhenHandlerTypeHasProcessMethod_RegistersHandlerType()
        {
            const string instanceName = "empty";
            var handlerCache = new HandlerCache();

            var sut = new Registry();

            sut.Register(instanceName)
                .Processes<EmptyHandler>();

            var container = new Container(sut);

            HandlerProcessor processor = container.With(handlerCache).GetInstance<HandlerProcessor>(instanceName);

            processor.Process();

            Assert.IsTrue(container.Model.For<HandlerProcessor>().HasImplementations(), "Missing implementations.");
            Assert.IsNotNull(container.Model.Find<HandlerProcessor>(instanceName));
            Assert.AreEqual("message", handlerCache.Get(typeof(string)));
        }

        public void supply_defaults_by_generic()
        {
            var container = new Container(x => {
                x.For<IWidget>().Use<BWidget>();
                x.For<IService>().Use<AService>();
            });

            var widget = new BWidget();
            var service = new BService();

            var guyWithWidgetAndService = container
                .With<IWidget>(widget)
                .With<IService>(service)
                .GetInstance<GuyWithWidgetAndService>();

            guyWithWidgetAndService
                .Widget.ShouldBeTheSameAs(widget);

            guyWithWidgetAndService
                .Service.ShouldBeTheSameAs(service);
        }

        public void use_explicit_type_arguments_with_custom_instance()
        {
            var container =
                new Container(x => { x.For<ClassWithNoArgs>().Use(new SpecialInstance()); });

            var address = new Address();

            container.With(address).GetInstance<ClassWithNoArgs>()
                .TheAddress.ShouldBeTheSameAs(address);
        }

        public void pass_explicit_service_into_all_instances_and_retrieve_without_generics()
        {
            // The Container is constructed with 2 instances
            // of TradeView
            var container = new Container(r =>
            {
                r.For<TradeView>().Use<TradeView>();
                r.For<TradeView>().Add<SecuredTradeView>();
            });

            var theTrade = new Trade();

            var views = container.With(theTrade).GetAllInstances(typeof (TradeView))
                .OfType<TradeView>();

            views.ElementAt(0).Trade.ShouldBeTheSameAs(theTrade);
            views.ElementAt(1).Trade.ShouldBeTheSameAs(theTrade);
        }

 public void use_a_type_that_is_not_part_of_the_constructor_in_the_with()
 {
     var container = new Container();
     container.With(new Address()).GetInstance<ClassWithNoArgs>()
         .ShouldBeOfType<ClassWithNoArgs>();
 }

        public void Explicit_services_are_used_throughout_the_object_graph()
        {
            var theTrade = new Trade();

            IContainer container = new Container(r =>
            {
                r.For<IView>().Use<TradeView>();
                r.For<Node>().Use<TradeNode>();
            });

            var command = container.With(theTrade).GetInstance<Command>();

            command.Trade.ShouldBeTheSameAs(theTrade);
            command.Node.IsType<TradeNode>().Trade.ShouldBeTheSameAs(theTrade);
            command.View.IsType<TradeView>().Trade.ShouldBeTheSameAs(theTrade);
        }

        public void Fill_in_argument_by_type()
        {
            var container = new Container(x => { x.For<IView>().Use<View>(); });

            var theNode = new SpecialNode();
            var theTrade = new Trade();

            var command = container
                .With(typeof (Node), theNode)
                .With(theTrade)
                .GetInstance<Command>();

            command.View.ShouldBeOfType<View>();
            theNode.ShouldBeTheSameAs(command.Node);
            theTrade.ShouldBeTheSameAs(command.Trade);
        }