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)); }
public void ConfigureContainerbyAddingPolicyHanlderRule() { ICallHandler myHandler1 = new CallCountHandler(); IMatchingRule myMatchingRule1 = new AlwaysMatchingRule(); IUnityContainer container = new UnityContainer(); container.AddNewExtension<Interception>(); container.Configure<Interception>(). AddPolicy("myRDP"). AddCallHandler(myHandler1). AddMatchingRule(myMatchingRule1); container.Configure<Interception>(). SetInterceptorFor<InterceptionClass>("interceptionclass", new TransparentProxyInterceptor()); InterceptionClass ic = container.Resolve<InterceptionClass>("interceptionclass"); ic.MethodA(); Assert.AreEqual(1, ((CallCountHandler)myHandler1).CallCount); }
public void Can_register_using_factory_delegate() { var container = new UnityContainer(); var myService = new BarService(); container.Configure(x => x.Register<IBarService>(c => myService)); Assert.That(container.Resolve<IBarService>(), Is.SameAs(myService)); }
public void Can_register_transient_type() { var container = new UnityContainer(); container.Configure(x => x.Register<IBarService, BarService>()); Assert.That(container.Resolve<IBarService>(), Is.InstanceOf<BarService>()); Assert.That(container.Resolve<IBarService>(), Is.Not.SameAs(container.Resolve<IBarService>())); }
public void ShouldRethrowFromNoOpPolicy() { IUnityContainer factory = new UnityContainer().AddNewExtension<Interception>(); factory.Configure<Interception>().SetDefaultInterceptorFor<TargetType>(new TransparentProxyInterceptor()); AddExceptionHandlingConfiguration(factory); AddExceptionPolicy(factory, "No-Op Policy", new TypeMatchingRule("TargetType")); TargetType target = factory.Resolve<TargetType>(); target.ThrowFromFunctionWithReturnValue(); }
public void ShouldTranslateException() { IUnityContainer factory = new UnityContainer().AddNewExtension<Interception>(); factory.Configure<Interception>().SetDefaultInterceptorFor<TargetType>(new TransparentProxyInterceptor()); AddExceptionHandlingConfiguration(factory); AddExceptionPolicy(factory, "Translate Exceptions", new TypeMatchingRule("TargetType")); TargetType target = factory.Resolve<TargetType>(); target.WillThrowException(); }
public void ConfigureContainerbyAddingEmptyHandlerRuleThrowException() { IUnityContainer container = new UnityContainer(); container.AddNewExtension<Interception>(); container.Configure<Interception>(). AddPolicy("myRDP"). AddCallHandler(String.Empty). AddMatchingRule(String.Empty); List<InjectionPolicy> policy = new List<InjectionPolicy>(container.ResolveAll<InjectionPolicy>()); }
public void Ext_CanGetConfigurationWithoutGenericMethod() { MockContainerExtension extension = new MockContainerExtension(); IUnityContainer container = new UnityContainer() .AddExtension(extension); IMockConfiguration config = (IMockConfiguration)container.Configure(typeof(IMockConfiguration)); Assert.AreSame(extension, config); Assert.AreSame(container, config.Container); }
public void Ext_CanGetConfigurationInterfaceFromExtension() { MockContainerExtension extension = new MockContainerExtension(); IUnityContainer container = new UnityContainer() .AddExtension(extension); IMockConfiguration config = container.Configure<IMockConfiguration>(); Assert.AreSame(extension, config); Assert.AreSame(container, config.Container); }
public void Can_call_method_on_interface_after_build_up() { var container = new UnityContainer(); container.Configure(x => { x.Register<IStartable, StartableService1>(); x.AfterBuildingUp<IStartable>().Call((c, s) => s.Start()); }); Assert.That(container.Resolve<IStartable>().StartWasCalled); }
public void ConfigureContainerbyAddingExteralPolicyHandlerRule() { IUnityContainer container = new UnityContainer(); container.AddNewExtension<Interception>(); container.Configure<Interception>(). AddPolicy("myRDP"). AddCallHandler("myHandler1"). AddMatchingRule("myMatchingRule1") .Interception.Container.RegisterType<ICallHandler, CallCountHandler>("myHandler1") .RegisterType<IMatchingRule, AlwaysMatchingRule>("myMatchingRule1"); }
public void ShouldThrowWhenSwallowingExceptionFromNonVoidMethod() { IUnityContainer factory = new UnityContainer().AddNewExtension<Interception>(); factory.Configure<Interception>().SetDefaultInterceptorFor<TargetType>(new TransparentProxyInterceptor()); AddExceptionHandlingConfiguration(); AddExceptionPolicy(factory, "Swallow Exceptions", new TypeMatchingRule("TargetType")); TargetType target = factory.Resolve<TargetType>(); target.ThrowFromFunctionWithReturnValue(); Assert.Fail("An exception should have been thrown"); }
public void Can_set_property_after_building_up() { var container = new UnityContainer(); container.Configure(x => { x.Register<ILogger, NullLogger>(); x.AfterBuildingUp<FooService>().Call((c, s) => s.Logger = c.Resolve<ILogger>()); }); Assert.That(container.Resolve<FooService>().Logger, Is.Not.Null); }
public void Registers_with_default_naming_convention() { var container = new UnityContainer(); container.Configure(x => x.Scan(scan => { scan.AssemblyContaining<NamedService>(); scan.WithNamingConvention(); })); Assert.That(container.Resolve<INamedService>(), Is.InstanceOf<NamedService>()); }
public void Can_add_same_registry_twice_without_breaking_anything() { var container = new UnityContainer(); container.Configure(x => { x.AddRegistry<FooRegistry>(); x.AddRegistry<FooRegistry>(); }); Assert.That(container.Resolve<IFooService>(), Is.InstanceOf<FooService>()); }
public void Can_override_the_default_naming_convention() { var container = new UnityContainer(); container.Configure(x => x.Scan(scan => { scan.AssemblyContaining<FooRegistry>(); scan.WithAddAllConvention().TypesImplementing<IHaveManyImplementations>().WithName(t => "test"); })); Assert.That(container.Resolve<IHaveManyImplementations>("test"), Is.Not.Null); }