C# Container.WhatDoIHave方法代码示例

 public void Given_structuremap_when_printWhatDoIHave_then_shouldReturnWhatDoIHave()
 {
     var container = new Container(new Registering());
     var printerInstance = container.TryGetInstance<ITypeOfPrinter>();
     string blackAndWhitePrintText = printerInstance.Printing();
     Assert.Pass(container.WhatDoIHave());
 }

        public void SetUp()
        {
            registry = new FubuRegistry(x =>
            {
                x.Route<InputModel>("area/sub/{Name}/{Age}")
                    .Calls<TestController>(c => c.AnotherAction(null)).OutputToJson();

                x.Route<InputModel>("area/sub2/prop")
                    .Calls<TestController>(c => c.SomeAction(null)).OutputToJson();

                x.Route<InputModel>("area/sub2/{Name}/{Age}")
                    .Calls<TestController>(c => c.AnotherAction(null)).OutputToJson();

                x.Route<InputModel>("area/sub2/{Name}")
                    .Calls<TestController>(c => c.ThirdAction(null)).OutputToJson();

                x.Route<InputModel>("area/sub3/{Name}/{Age}")
                    .Calls<TestController>(c => c.AnotherAction(null)).OutputToJson();
            });

            container = new Container();

            var bootstrapper = new StructureMapBootstrapper(container, registry);
            routes = new RouteCollection();

            bootstrapper.Bootstrap(routes);

            container.Configure(x => x.For<IOutputWriter>().Use(new InMemoryOutputWriter()));
            Debug.WriteLine(container.WhatDoIHave());
        }

        public void WhatDoIHave()
        {
            var container = new Container(x =>
            {
                x.For<IService>().Use<Service>();
            });

            var whatDoIHave = container.WhatDoIHave();

            var expectedWhatDoIHave = @"

            ===================================================================================================
            PluginType           Namespace        Lifecycle     Description                           Name
            ---------------------------------------------------------------------------------------------------
            Func<TResult>        System           Transient     Open Generic Template for Func<>      (Default)
            ---------------------------------------------------------------------------------------------------
            Func<T, TResult>     System           Transient     Open Generic Template for Func<,>     (Default)
            ---------------------------------------------------------------------------------------------------
            IContainer           StructureMap     Singleton     Object:  StructureMap.Container       (Default)
            ---------------------------------------------------------------------------------------------------
            IService             Core             Transient     Core.Service                          (Default)
            ---------------------------------------------------------------------------------------------------
            Lazy<T>              System           Transient     Open Generic Template for Func<>      (Default)
            ===================================================================================================";

            Assert.Equal(expectedWhatDoIHave, whatDoIHave);
        }

        public void display_one_service_for_an_interface()
        {
            // SAMPLE: what_do_i_have_container
            var container = new Container(x =>
            {
                x.For<IEngine>().Use<Hemi>().Named("The Hemi");

                x.For<IEngine>().Add<VEight>().Singleton().Named("V8");
                x.For<IEngine>().Add<FourFiftyFour>().AlwaysUnique();
                x.For<IEngine>().Add<StraightSix>().LifecycleIs<ThreadLocalStorageLifecycle>();

                x.For<IEngine>().Add(() => new Rotary()).Named("Rotary");
                x.For<IEngine>().Add(c => c.GetInstance<PluginElectric>());

                x.For<IEngine>().Add(new InlineFour());

                x.For<IEngine>().UseIfNone<VTwelve>();
                x.For<IEngine>().MissingNamedInstanceIs.ConstructedBy(c => new NamedEngine(c.RequestedName));
            });
            // ENDSAMPLE

            // SAMPLE: whatdoihave_everything
            Debug.WriteLine(container.WhatDoIHave());
            // ENDSAMPLE
        }

        public void SetUp()
        {
            AssetDeclarationVerificationActivator.Latched = true;

            registry = new FubuRegistry(x =>
            {

                x.Route("area/sub/{Name}/{Age}")
                    .Calls<TestController>(c => c.AnotherAction(null)).OutputToJson();

                x.Route("area/sub2/prop")
                    .Calls<TestController>(c => c.SomeAction(null)).OutputToJson();

                x.Route("area/sub2/{Name}/{Age}")
                    .Calls<TestController>(c => c.AnotherAction(null)).OutputToJson();

                x.Route("area/sub2/{Name}")
                    .Calls<TestController>(c => c.ThirdAction(null)).OutputToJson();

                x.Route("area/sub3/{Name}/{Age}")
                    .Calls<TestController>(c => c.AnotherAction(null)).OutputToJson();

                x.Route("area/sub4/some_pattern")
                    .Calls<TestController>(c => c.AnotherAction(null)).OutputToJson();
            });

            container = new Container();

            routes = FubuApplication.For(registry).StructureMap(container).Bootstrap().Where(r => !r.As<Route>().Url.StartsWith("_content")).ToList();

            container.Configure(x => x.For<IOutputWriter>().Use(new InMemoryOutputWriter()));
            Debug.WriteLine(container.WhatDoIHave());
        }

        public void register_open_generic_type()
        {
            var container = new Container(_ =>
            {
                _.For(typeof(IVisualizer<>)).Use(typeof(DefaultVisualizer<>));
            });

            Debug.WriteLine(container.WhatDoIHave(@namespace: "StructureMap.Testing.Acceptance.Visualization"));

            container.GetInstance<IVisualizer<IssueCreated>>()
                .ShouldBeOfType<DefaultVisualizer<IssueCreated>>();

            Debug.WriteLine(container.WhatDoIHave(@namespace: "StructureMap.Testing.Acceptance.Visualization"));

            container.GetInstance<IVisualizer<IssueResolved>>()
                .ShouldBeOfType<DefaultVisualizer<IssueResolved>>();
        }

        public void empty_container()
        {
            // SAMPLE: whatdoihave-simple
            var container = new Container();
            var report = container.WhatDoIHave();

            Debug.WriteLine(report);
            // ENDSAMPLE
        }

        public void allow_nested_container_to_report_what_it_has()
        {
            var container = new Container(x => x.For<IAutomobile>().Use<Mustang>());

            var nestedContainer = container.GetNestedContainer();
            nestedContainer.Inject<IEngine>(new PushrodEngine());

            container.WhatDoIHave().ShouldNotBeEmpty().ShouldNotContain(typeof(IEngine).Name);
            nestedContainer.WhatDoIHave().ShouldNotBeEmpty().ShouldContain(typeof(IEngine).Name);
        }

        private static Container InitialiseContainer()
        {
            var container = new Container(x =>
            {
                x.AddRegistry<DependencyRegistry>();
            });

            Debug.WriteLine(container.WhatDoIHave());

            return container;
        }

        public void render_the_missing_named_instance_if_it_exists()
        {
            var container =
                new Container(
                    x =>
                    {
                        x.For<IEngine>().MissingNamedInstanceIs.ConstructedBy(c => new NamedEngine(c.RequestedName));
                    });

            var description = container.WhatDoIHave();
            description.ShouldContain("*Missing Named Instance*");
            description.ShouldContain("Lambda: new NamedEngine(IContext.RequestedName)");
        }

        public void clear_all_in_action()
        {
            var container = new Container(_ =>
            {
                _.For<IWidget>().Use<AWidget>();

                _.IncludeRegistry<ImportantClientServices>();
            });

            container.GetInstance<IWidget>()
                .ShouldBeOfType<ImportantClientWidget>();

            Debug.WriteLine(container.WhatDoIHave(pluginType: typeof(IWidget)));
        }

        public void SetUp()
        {
            AssetContentEndpoint.Latched = true;
            AssetDeclarationVerificationActivator.Latched = true;

            registry = new FubuRegistry(x =>
            {
                x.Actions.IncludeTypes(t => false);

                x.Route("area/sub/{Name}/{Age}")
                    .Calls<TestController>(c => c.AnotherAction(null)).OutputToJson();

                x.Route("area/sub2/prop")
                    .Calls<TestController>(c => c.SomeAction(null)).OutputToJson();

                x.Route("area/sub2/{Name}/{Age}")
                    .Calls<TestController>(c => c.AnotherAction(null)).OutputToJson();

                x.Route("area/sub2/{Name}")
                    .Calls<TestController>(c => c.ThirdAction(null)).OutputToJson();

                x.Route("area/sub3/{Name}/{Age}")
                    .Calls<TestController>(c => c.AnotherAction(null)).OutputToJson();

                x.Route("area/sub4/some_pattern")
                    .Calls<TestController>(c => c.AnotherAction(null)).OutputToJson();
            });

            container = new Container(x =>
            {
                x.For<IStreamingData>().Use(MockRepository.GenerateMock<IStreamingData>());
                x.For<ICurrentChain>().Use(new CurrentChain(null, null));
                x.For<ICurrentHttpRequest>().Use(new StubCurrentHttpRequest{
                    TheApplicationRoot = "http://server"
                });
            });

            routes = FubuApplication.For(registry)
                .StructureMap(container)
                .Bootstrap()
                .Routes
                .Where(r => !r.As<Route>().Url.StartsWith("_content"))
                .ToList();

            container.Configure(x => x.For<IOutputWriter>().Use(new InMemoryOutputWriter()));
            Debug.WriteLine(container.WhatDoIHave());
        }

        public void use_a_custom_policy()
        {
            var container = new Container(_ =>
            {
                _.For<IRepository>().Use<NormalRepository>();

                _.Policies.Add<SpecialGuyGetsSpecialRepository>();
            });

            Debug.WriteLine(container.WhatDoIHave());

            // Policy should not apply to NormalGuy
            container.GetInstance<NormalGuy>().Repository.ShouldBeOfType<NormalRepository>();

            // Policy should override the repository dependency of SpecialGuy
            container.GetInstance<SpecialGuy>().Repository.ShouldBeOfType<SpecialRepository>();
        }

        private static void Main(string[] args)
        {
            var container = new Container(x =>
            {
                x.Scan(s =>
                {
                    s.TheCallingAssembly();
                    s.WithDefaultConventions();
                });
                x.ForRequestedType<IDoMore<string>>().TheDefaultIsConcreteType<DoForStrings>();
                x.ForRequestedType<IDoThat>().AddInstances(i =>
                {
                    i.OfConcreteType<DoThat>().WithName("Red");
                    i.OfConcreteType<DoThat>().WithName("Blue");
                });
            });

            ObjectFactory.Initialize(i => i.ForRequestedType<IDoThat>().TheDefaultIsConcreteType<DoThat>());
            Debug.WriteLine(container.WhatDoIHave());

            ContainerDetail details = ContainerVisualizerObjectSource.BuildContainerDetails(container);
            Application.Run(new ContainerForm(details));
        }

    protected void Application_Start()
    {
      Container = new Container(new FileRegistry(HostingEnvironment.ApplicationPhysicalPath));

      LogService.Info("Application is starting");

      ViewEngines.Engines.Clear();
      //default view engine
      ViewEngines.Engines.Add(new ThemeViewEngine());

      //use IoC controller factory
      ControllerBuilder.Current.SetControllerFactory(typeof(DynamicControllerFactory));

      //modularity
      PluginEngine.LoadPlugins(Container, RouteTable.Routes, ViewEngines.Engines, ModelBinders.Binders, Server.MapPath("~/"), Server.MapPath("~/bin"));

      //default route
      RouteTable.Routes.MapRoute("Default", @"{controller}/{action}");
      Container.Inject<RouteCollection>(RouteTable.Routes);
      LogService.Debug(Container.WhatDoIHave());

      LogService.Info("Cache size bytes={0} percent used={1}", HttpRuntime.Cache.EffectivePrivateBytesLimit, HttpRuntime.Cache.EffectivePercentagePhysicalMemoryLimit);
    }