C# UnityContainer.Configure方法代码示例

        public static void RegisterRepositoryTypes(UnityContainer container)
        {
            /* Register types into the container */
            container.RegisterType<IDataService, DataService>();

            //container.RegisterType<IDataService, DummyDataService>();

            /* Register the Logger to be used by all calls from the container */
            container.RegisterType<LogHelper, LogHelper>(new ContainerControlledLifetimeManager());

            /* Register our data access helper to be used uniquely for each thread call from container */
            container.RegisterType<IDataAccessor, DataAccessor>(new PerThreadLifetimeManager());

            /* Register our matching rule and call handlers (AKA Aspects) */
            container.RegisterType<IMatchingRule, AllMatchingRule>(MatchingRule);
            container.RegisterType<ICallHandler, ExceptionCallHandler>(ExceptionCallHandler.Key);
            container.RegisterType<ICallHandler, UnitOfWorkCallHandler>(UnitOfWorkCallHandler.Key);
            container.RegisterType<ICallHandler, AuthenticationCallHandler>(AuthenticationCallHandler.Key);
            container.RegisterType<ICallHandler, CommandCallHandler>(CommandCallHandler.Key);
            container.RegisterType<ICallHandler, LogCallHandler>(LogCallHandler.Key);

            /* Create a new policy and reference the matching rule and call handler by name */
            container.AddNewExtension<Interception>();
            container.Configure<Interception>()
                .AddPolicy(PolicyName)
                .AddMatchingRule(MatchingRule)
                .AddCallHandler(ExceptionCallHandler.Key)
                .AddCallHandler(UnitOfWorkCallHandler.Key)
                //.AddCallHandler(LogCallHandler.Key)
                .AddCallHandler(AuthenticationCallHandler.Key)
                .AddCallHandler(CommandCallHandler.Key);

            /* Make IDataService interface elegible for interception */
            container.Configure<Interception>().SetInterceptorFor(typeof(IDataService), new TransparentProxyInterceptor());
        }

        public void InjectClassWithTwoConstructors()
        {
            int myInt = 37;
            string myStr = "Test";

            IUnityContainer container = new UnityContainer();

            //constructor without params
            container.Configure<InjectedMembers>().ConfigureInjectionFor<TestClass>(new InjectionConstructor());

            TestClass withOutCon = container.Resolve<TestClass>();
            Assert.IsFalse(withOutCon.StringConstructorCalled);
            Assert.IsFalse(withOutCon.IntConstructorCalled);
            //constructor with one param
            container.Configure<InjectedMembers>()
                .ConfigureInjectionFor<TestClass>("First",
                    new InjectionConstructor(myInt));

            TestClass myTestClass = container.Resolve<TestClass>("First");

            Assert.IsFalse(myTestClass.StringConstructorCalled);
            Assert.IsTrue(myTestClass.IntConstructorCalled);

            //constructor with one param
            container.Configure<InjectedMembers>()
               .ConfigureInjectionFor<TestClass>("Second",
                   new InjectionConstructor(myStr));

            TestClass myTestClass1 = container.Resolve<TestClass>("Second");
            
            Assert.IsFalse(myTestClass1.IntConstructorCalled);
            Assert.IsTrue(myTestClass1.StringConstructorCalled);
        }

    static void UsingPIABWithContainer()
    {
      ConfigureLogger();
      using (var container = new UnityContainer())
      {

        container.AddNewExtension<Interception>();
        container.RegisterType<InterceptableTenantStore>(new Interceptor<TransparentProxyInterceptor>(), new InterceptionBehavior<PolicyInjectionBehavior>());

        container.Configure<Interception>().AddPolicy("logging")
             .AddMatchingRule<MemberNameMatchingRule>(
                new InjectionConstructor(
                new InjectionParameter("Save")))
             .AddCallHandler<LogCallHandler>(
                new ContainerControlledLifetimeManager(),
                new InjectionConstructor(
                  9001, true, false,
                  "This is before the method call",
                  "This is after the method call", false, false, true, 10, 1));


        var tenantStore = container.Resolve<InterceptableTenantStore>();

        // Use the interceptable type.
        Console.WriteLine("*** Invoking the Save method ***");
        tenantStore.Save();
        Console.WriteLine("*** Invoking the Modify method ***");
        tenantStore.Modify();
      }
    }

        public void Can_call_method_on_concrete_after_build_up()
        {
            var container = new UnityContainer();
            container.Configure(x => x.AfterBuildingUp<StartableService1>().Call((c, s) => s.Start()));

            Assert.That(container.Resolve<StartableService1>().StartWasCalled);
        }

        public void Can_register_named_singleton_instance()
        {
            var container = new UnityContainer();
            container.Configure(x => x.Register<IBarService, BarService>().WithName("name").AsSingleton());

            Assert.That(container.Resolve<IBarService>("name"), Is.SameAs(container.Resolve<IBarService>("name")));
        }

 public void ConfigureContainerbyAddingExteralPolicy()
 {
     IUnityContainer container = new UnityContainer();
     container.AddNewExtension<Interception>();
     container.Configure<Interception>().AddPolicy("myRDP");
     List<InjectionPolicy> policy = new List<InjectionPolicy>(container.ResolveAll<InjectionPolicy>());
     Assert.AreEqual("myRDP", policy[1].Name);
 }

        public void Can_resolve_the_container_without_registering_it()
        {
            var container = new UnityContainer();

            container.Configure(x => { });

            Assert.That(container.Resolve<IUnityContainer>(), Is.SameAs(container));
        }

 public void ConfigureAndRegisterInstance()
 {
     IUnityContainer container = new UnityContainer().AddNewExtension<StaticFactoryExtension>();
     IStaticFactoryConfiguration config = container.Configure<IStaticFactoryConfiguration>();
     object obj1 = container.RegisterInstance<IStaticFactoryConfiguration>(config);
     Assert.IsNotNull(config);
     Assert.IsNotNull(obj1);
 }

        public void Should_return_container()
        {
            var container = new UnityContainer();

            var result = container.Configure(x => { });

            Assert.That(result, Is.SameAs(container));
        }

        public void Can_initalize_container_with_one_registry()
        {
            var container = new UnityContainer();

            container.Configure(x => x.AddRegistry<FooRegistry>());

            Assert.That(container.Resolve<IFooService>(), Is.InstanceOf<FooService>());
        }

        public void ValidationCallHandlerThrowsArgumentValidationExceptionIfValidationFailsFromConfiguration()
        {
            IUnityContainer factory = new UnityContainer().AddNewExtension<Interception>();
            factory.Configure<Interception>().SetDefaultInterceptorFor<ValidationFixtureTarget>(new TransparentProxyInterceptor());
            AddValidationPolicy(factory, string.Empty, SpecificationSource.Configuration, new TypeMatchingRule("ValidationFixtureTarget"));
            ValidationFixtureTarget target = factory.Resolve<ValidationFixtureTarget>();

            target.AcceptTest(new TestObject(false, true));
        }

        public void Can_register_a_func_with_parameters()
        {
            var container = new UnityContainer();

            var myService = new BarService();
            container.Configure(x => x.Register<Func<int, IBarService>>(c => i => myService));

            Assert.That(container.Resolve<Func<int, IBarService>>()(1), Is.SameAs(myService));
        }

        public void Finds_all_registries()
        {
            var container = new UnityContainer();

            container.Configure(x => x.AddRegistry<MyRegistry>());

            Assert.That(container.Resolve<IFooService>(), Is.InstanceOf<FooService>());
            Assert.That(container.Resolve<IBarService>(), Is.InstanceOf<BarService>());
        }

        public void Can_register_singleton()
        {
            var container = new UnityContainer();

            container.Configure(x => x.Register<IBarService, BarService>().AsSingleton());

            Assert.That(container.Resolve<IBarService>(), Is.InstanceOf<BarService>());
            Assert.That(container.Resolve<IBarService>(), Is.SameAs(container.Resolve<IBarService>()));
        }

        public void ValidationCallHandlerDoesNothingIfValidationPasses()
        {
            IUnityContainer factory = new UnityContainer().AddNewExtension<Interception>();
            factory.Configure<Interception>().SetDefaultInterceptorFor<ValidationFixtureTarget>(new TransparentProxyInterceptor());
            AddValidationPolicy(factory, string.Empty, SpecificationSource.Attributes, new TypeMatchingRule("ValidationFixtureTarget"));
            ValidationFixtureTarget target = factory.Resolve<ValidationFixtureTarget>();

            target.AcceptTest(new TestObject(false, false));
        }