public void Test() { var c = new Container(); c.RegisterMany <Mode1Comp>(Reuse.Transient, setup: Setup.With(openResolutionScope: true)); c.RegisterMany <Mode2Comp>(Reuse.Transient, setup: Setup.With(openResolutionScope: true)); c.Register <IOoui, Ooui1>(Reuse.ScopedTo <IComp>(), setup: Setup.With( condition: req => req.Any(x => x.ServiceType == typeof(IMode1Comp)))); c.Register <IOoui, Ooui2>(Reuse.ScopedTo <IComp>(), setup: Setup.With( condition: req => req.Any(x => x.ServiceType == typeof(IMode2Comp)))); c.RegisterMany <OouiHost>(Reuse.ScopedTo <IComp>()); c.RegisterMany <Mode1>(); c.RegisterMany <Mode2>(); var mode1 = c.Resolve <Mode1>(); Assert.IsInstanceOf <Ooui1>(mode1.Comp.Oouis.Single()); var mode2 = c.Resolve <Mode2>(); Assert.IsInstanceOf <Ooui2>(mode2.Comp.Oouis.Single()); }
public void TheBug_2_is_not_a_bug_and_depends_on_the_registration_order() { var container = new Container(rules => rules .WithMicrosoftDependencyInjectionRules() .WithFuncAndLazyWithoutRegistration()); container.Register <A>(); container.Register <S, S1>(Reuse.ScopedTo("FirstScope")); container.Register <B, B2>(Reuse.ScopedTo("SecondScope")); container.Register <B, B1>(); using (var scope = container.OpenScope("FirstScope")) { // no issue var a = scope.Resolve <A>(); Assert.IsInstanceOf <B1>(a.B); Assert.IsInstanceOf <S1>(a.B.S); } using (var context = container.OpenScope("SecondScope")) { //DryIoc.ContainerException : code: Error.NoMatchedScopeFound; //message: Unable to find matching scope with name "FirstScope" starting from the current scope {Name=SecondScope}. Assert.Throws <ContainerException>(() => context.Resolve <A>()); } }
[Test] // #107 public void Reusing_singletons_from_parent_and_not_disposing_them_in_scoped_container() { var container = new Container(); var parent = container.OpenScope("parent"); container.Register <Foo>(Reuse.InCurrentNamedScope("parent")); var firstChild = parent.OpenScope(); var firstFoo = firstChild.Resolve <Foo>(); container.Register <Blah>(Reuse.InCurrentScope); var firstBlah = firstChild.Resolve <Blah>(); firstChild.Dispose(); Assert.IsFalse(firstFoo.Disposed); // firstFoo shouldn't be disposed Assert.IsTrue(firstBlah.Disposed); // firstBlah should be disposed var secondChild = parent.OpenScope(); secondChild.Resolve <Foo>(); // Resolve<Foo>() shouldn't throw parent.Dispose(); // Parent scope is disposed. Assert.IsTrue(firstFoo.Disposed); container.Dispose(); // singletons, registry, cache, is gone }
public void RegisterDecorator(Type service, Type decorator, Reuse reuse = Reuse.Transient) { var originalFactory = serviceMap[service]; var constructor = ResolveConstructor(decorator); var parameterTypes = constructor.GetParameters().Select(p => p.ParameterType).ToList(); switch (reuse) { case Reuse.Transient: serviceMap[service] = () => { var parameters = parameterTypes.Select(t => t == service ? originalFactory() : Resolve(t)).ToArray(); return(constructor.Invoke(parameters)); }; break; case Reuse.Singleton: object instance = null; serviceMap[service] = () => { if (instance == null) { var parameters = parameterTypes.Select(t => t == service ? originalFactory() : Resolve(t)).ToArray(); instance = constructor.Invoke(parameters); } return(instance); }; break; } }
public void Func_of_scoped_thing_should_return_object_from_a_new_scope_when_singleton_is_resolved_out_of_the_scope() { var c = new Container(scopeContext: new AsyncExecutionFlowScopeContext()); c.Register <ISingletonComponent, SingletonComponentWithScopedFunc>(Reuse.Singleton); var scopeName = "myScope"; c.Register <IScopedComponent, ScopedComponent>(Reuse.InCurrentNamedScope(scopeName)); var singleton = c.Resolve <ISingletonComponent>(); IScopedComponent scoped1a, scoped1b, scoped2; using (c.OpenScope(scopeName)) { scoped1a = singleton.Scoped; scoped1b = singleton.Scoped; } using (c.OpenScope(scopeName)) { scoped2 = singleton.Scoped; } Assert.AreSame(scoped1b, scoped1a); Assert.AreNotSame(scoped1a, scoped2); }
public void Can_supply_fresh_args_in_different_open_scopes() { var c = new Container(); //var c = new Container(r => r.WithIgnoringReuseForFuncWithArgs()); c.Register <SS>(Reuse.ScopedTo("1", "2")); using (var scope = c.OpenScope("1")) { var ss = scope.Resolve <Func <string, SS> >(new object[] { "b" })("a"); Assert.AreEqual("a", ss.A); Assert.AreEqual("b", ss.B); } using (var scope = c.OpenScope("1")) { var ss = scope.Resolve <SS>(new object[] { "x", "y" }); Assert.AreEqual("x", ss.A); Assert.AreEqual("y", ss.B); } using (var scope = c.OpenScope("2")) { var ss = scope.Resolve <SS>(new object[] { "__", "_ _" }); Assert.AreEqual("__", ss.A); Assert.AreEqual("_ _", ss.B); } }
private void OnTriggerEnter(Collider other) { if (other.CompareTag(playerTag)) { player.Damage(damage); Reuse?.Invoke(this); } }
public void If_no_scope_opened_and_no_matched_name_found_then_resolving_should_Throw() { var container = new Container(scopeContext: new AsyncExecutionFlowScopeContext()); container.Register <Blah>(Reuse.InCurrentNamedScope(1)); Assert.Throws <ContainerException>(() => container.Resolve <Blah>()); }
public void Register <T>(Func <T> factory, Reuse reuse = Reuse.Transient) { if (factory == null) { throw new ArgumentNullException(nameof(factory)); } ItemsProviders[typeof(T)] = new ItemProvider(() => factory(), reuse); }
public void Resolving_the_object_should_use_required_service_type_for_matching_the_resolution_scope() { var container = new Container(); container.Register <O>(setup: Setup.With(openResolutionScope: true)); container.Register <Ho>(Reuse.ScopedTo <O>()); container.Resolve <object>(typeof(O)); }
public void Resolve_service_reused_in_resolution_scope_of_open_generic_service() { var container = new Container(); container.Register(typeof(Aaa <>), setup: Setup.With(openResolutionScope: true)); container.Register <Bbb>(Reuse.ScopedTo(typeof(Aaa <>))); var aaa = container.Resolve <Aaa <Bbb> >(); Assert.IsNotNull(aaa); }
public void Can_use_resolution_scope_reuse_bound_to_resolution_root() { var container = new Container(); container.Register <ViewModel2>(setup: Setup.With(openResolutionScope: true)); container.Register <Log>(Reuse.ScopedTo <ViewModel2>()); var vm = container.Resolve <ViewModel2>(); Assert.IsNotNull(vm.Log); }
public void Resolution_call_should_not_create_resolution_scope() { var container = new Container(); container.Register <AD>(Reuse.ScopedTo <ADConsumer>()); container.Register <ADConsumer>(setup: Setup.With(asResolutionCall: true)); container.Register <AResolutionScoped>(setup: Setup.With(openResolutionScope: true)); Assert.Throws <ContainerException>(() => container.Resolve <AResolutionScoped>()); }
public void Register(ServiceRegistration registration) { if (registration == null) { throw new ArgumentNullException(nameof(registration)); } if (!IsScoped && container == null) { throw new InvalidOperationException("The container was not initialized."); } if (IsScoped && registration.Instance == null) { throw new ArgumentException("Cannot register a service in a scope"); } try { lock (this) { var serviceType = registration.ServiceType; var service = registration.Instance; var serviceName = registration.ServiceKey; var implementationType = registration.ImplementationType; var reuse = Reuse.Transient; if (!String.IsNullOrEmpty(registration.Scope)) { reuse = Reuse.InCurrentNamedScope(registration.Scope); } else if (!String.IsNullOrEmpty(scopeName)) { reuse = Reuse.InCurrentNamedScope(scopeName); } if (service == null) { container.Register(serviceType, implementationType, serviceKey: serviceName, reuse: reuse); } else if (!String.IsNullOrEmpty(scopeName)) { resolver.UseInstance(serviceType, service, serviceKey: serviceName); } else { container.UseInstance(serviceType, service, serviceKey: serviceName); } } } catch (ServiceException) { throw; } catch (Exception ex) { throw new ServiceException("Error when registering service.", ex); } }
public void Unable_to_select_from_two_services_Resolved_in_func_before_scope_is_opened() { var container = new Container(scopeContext: new ThreadScopeContext()); container.Register <Service>(); container.Register <IAction, ActionOne>(Reuse.InCurrentNamedScope("1")); container.Register <IAction, ActionOne>(Reuse.InCurrentNamedScope("2")); Assert.Throws <ContainerException>(() => container.Resolve <Func <int, Service> >()); }
public void Resolve_service_reused_in_resolution_scope_succeed_if_key_matched() { var container = new Container(); container.Register <AccountUser>(made: Parameters.Of.Type <Account>(serviceKey: "account")); container.Register <Account>(serviceKey: "account", setup: Setup.With(openResolutionScope: true)); container.Register <Log>(Reuse.ScopedTo(serviceKey: "account")); var user = container.Resolve <AccountUser>(); Assert.IsNotNull(user.Account.Log); }
public void Ok_to_resolve_one_scoped_service_wrapped_in_func_before_the_scope_is_opened() { var container = new Container(scopeContext: new ThreadScopeContext()); container.Register <Service>(); container.Register <IAction, ActionOne>(Reuse.InCurrentNamedScope("1")); var factory = container.Resolve <Func <int, Service> >(); using (container.OpenScope("1")) Assert.DoesNotThrow(() => factory(1)); }
public void Sample_based_registration_condition_and_resolution_scope() { var c = new Container(); // register tenants with respective key + plus instruct tenant to open its scope c.Register <ITenant, GreenTenant>(serviceKey: TenantKey.Green, setup: Setup.With(openResolutionScope: true)); c.Register <ITenant, BlueTenant>(serviceKey: TenantKey.Blue, setup: Setup.With(openResolutionScope: true)); // green tenant services var greenSetup = Setup.With(condition: req => IsTenant(req, TenantKey.Green), asResolutionCall: true); c.Register <ITransient, GreenTransient>(setup: greenSetup); c.Register <IScoped, GreenScoped>(Reuse.Scoped, setup: greenSetup); c.Register <ISingleton, GreenSingleton>(Reuse.ScopedTo <ITenant>(TenantKey.Green)); // default services c.Register <ISomeController, SomeController>(Reuse.Scoped); c.Register <ITransient, DefaultTransient>(); c.Register <IScoped, DefaultScoped>(Reuse.Scoped); c.Register <ISingleton, DefaultSingleton>(Reuse.Singleton); using (var reqScope = c.OpenScope()) { var tenants = new[] { GetAndAssertTenantServices(reqScope, TenantKey.Green, "Green"), GetAndAssertTenantServices(reqScope, TenantKey.Blue, "Default") }; // cross tenant resolution var transients = tenants.Select(t => t.Resolver.Resolve <ITransient>().GetType()).ToArray(); CollectionAssert.AreEquivalent(new[] { typeof(GreenTransient), typeof(DefaultTransient) }, transients); } using (var reqScope = c.OpenScope()) { var tenants = new[] { GetAndAssertTenantServices(reqScope, TenantKey.Green, "Green"), GetAndAssertTenantServices(reqScope, TenantKey.Blue, "Default") }; // cross tenant resolution var transients = tenants.Select(t => t.Resolver.Resolve <ITransient>().GetType()).ToArray(); CollectionAssert.AreEquivalent(new[] { typeof(GreenTransient), typeof(DefaultTransient) }, transients); } var allTransients = c.ResolveMany <ITransient>(); // will be 1 default, because tenant transients can be resolved only through a tenant Assert.AreEqual(1, allTransients.Count()); }
public void SameOuterShareSameInnerForResolutionScope() { var container = new Container(); container.Register <IInner, Inner>(Reuse.InResolutionScopeOf <IOuter>()); container.Register <IOuter, Outer>(Reuse.Singleton); var outer1 = container.Resolve <IOuter>(); var outer2 = container.Resolve <IOuter>(); Assert.Same(outer1, outer2); Assert.Same(outer1.Inner, outer2.Inner); }
public void DifferentOuterHaveDifferentInnerForResolutionScope() { var container = new Container(); container.Register <IInner, Inner>(Reuse.InResolutionScopeOf <IOuter>()); container.Register <IOuter, Outer>(Reuse.Transient); var outer1 = container.Resolve <IOuter>(); var outer2 = container.Resolve <IOuter>(); Assert.NotSame(outer1, outer2); Assert.NotSame(outer1.Inner, outer2.Inner); }
public void Resolution_scope_should_be_propagated_through_resolution_call_intermediate_dependencies() { var container = new Container(); container.Register <AD>(Reuse.ScopedTo <AResolutionScoped>()); container.Register <ADConsumer>(setup: Setup.With(asResolutionCall: true)); container.Register <AResolutionScoped>(setup: Setup.With(openResolutionScope: true)); var scoped = container.Resolve <AResolutionScoped>(); Assert.IsNotNull(scoped); Assert.AreSame(scoped.Consumer.Ad, scoped.Consumer.Ad2); }
[Test] public void Example() { var container = new Container(); container.Register <Foo>(setup: Setup.With(openResolutionScope: true)); container.Register <Dependency>(Reuse.ScopedTo <Foo>()); var foo = container.Resolve <Foo>(); container.Dispose(); Assert.IsTrue(foo.Dep.IsDisposed); }
public void ResolveMany_can_resolve_decorator_with_dependency() { var container = new Container(); container.Register <B>(Reuse.ScopedTo <IA>()); container.Register <IA, A>(); container.Register <IA, D>(setup: Setup.DecoratorWith(_ => true, openResolutionScope: true)); var a = container.ResolveMany(typeof(IA)).First(); Assert.IsInstanceOf <D>(a); Assert.AreSame(((D)a).B, ((D)a).Bb); }
public void Resolve_can_resolve_decorator_as_resolution_call_together_with_resolution_scope_reuse() { var container = new Container(); container.Register <B>(Reuse.ScopedTo <IA>()); container.Register <IA, A>(); container.Register <IA, D>(setup: Setup.DecoratorWith(_ => true, openResolutionScope: true)); var a = container.Resolve(typeof(IA)); Assert.IsInstanceOf <D>(a); Assert.AreSame(((D)a).B, ((D)a).Bb); }
public void Test() { var container = new Container(); container.RegisterMany <Layr1>(Reuse.ScopedTo <IComp>(), nonPublicServiceTypes: true); container.RegisterMany <Layr2>(Reuse.ScopedTo <IComp>(), nonPublicServiceTypes: true); container.RegisterMany <Comp1>(Reuse.Singleton, nonPublicServiceTypes: true, setup: Setup.With(openResolutionScope: true)); container.RegisterMany <Comp2>(Reuse.Singleton, nonPublicServiceTypes: true, setup: Setup.With(openResolutionScope: true)); container.RegisterMany <Serv1>(Reuse.Singleton, nonPublicServiceTypes: true); container.RegisterMany <Serv2>(Reuse.Singleton, nonPublicServiceTypes: true); container.Resolve <Serv1>(); }
public void Test() { var c = new Container(r => r .WithoutThrowOnRegisteringDisposableTransient() .With(FactoryMethod.ConstructorWithResolvableArguments)); c.RegisterMany(new[] { typeof(IMediator).GetAssembly(), typeof(SomeRequestHandler).GetAssembly() }, type => type.GetTypeInfo().IsInterface // exclude action handler so we can register by key && !typeof(IActionHandler).IsAssignableFrom(type)); c.RegisterDelegate <SingleInstanceFactory>(r => serviceType => r.Resolve(serviceType)); c.RegisterDelegate <MultiInstanceFactory>(r => serviceType => r.ResolveMany(serviceType)); c.Register <IActionHandler, SomeActionHandler>(serviceKey: "key1"); c.Register <IActionHandler, SomeActionHandler2>(serviceKey: "key2"); c.Register <IActionHandler, SomeActionHandler3>(serviceKey: "key3"); c.Register <IActionHandler, SomeActionHandler4>(serviceKey: "key4"); c.Register(typeof(IAsyncRequestHandler <,>), typeof(Decorator <,>), made: Parameters.Of.Type <IActionHandler>(serviceKey: "key1"), setup: Setup.DecoratorWith(r => true, openResolutionScope: true)); c.Register(typeof(IAsyncRequestHandler <,>), typeof(Decorator <,>), made: Parameters.Of.Type <IActionHandler>(serviceKey: "key2"), setup: Setup.DecoratorWith(r => true, openResolutionScope: true)); c.Register(typeof(IAsyncRequestHandler <,>), typeof(Decorator <,>), made: Parameters.Of.Type <IActionHandler>(serviceKey: "key3"), setup: Setup.DecoratorWith(r => true, openResolutionScope: true)); c.Register(typeof(IAsyncRequestHandler <,>), typeof(Decorator <,>), made: Parameters.Of.Type <IActionHandler>(serviceKey: "key4"), setup: Setup.DecoratorWith(r => true, openResolutionScope: true)); c.Register <Command1>(); c.Register <CommandFactory>(); c.Register <DbContext, Model1>(Reuse.ScopedTo(typeof(IAsyncRequestHandler <,>))); c.Register <DbContext, Model1>(Reuse.ScopedTo(typeof(IAsyncNotificationHandler <>))); var mediator = c.Resolve <IMediator>(); var x = mediator.SendAsync(new RequestCommand()).Result; Assert.AreEqual("success", x); }
[Test] public void Example() { var container = new Container(); // `openResolutionScope` option is required to open the scope for the `Foo` container.Register <Foo>(setup: Setup.With(openResolutionScope: true)); container.Register <Dependency>(); container.Register <SubDependency>(Reuse.ScopedTo <Foo>()); var foo = container.Resolve <Foo>(); Assert.AreSame(foo.Sub, foo.Dep.Sub); }
public void Example() { var container = new Container(rules => rules .WithoutImplicitCheckForReuseMatchingScope()); container.Register <I, A>(Reuse.ScopedTo("a")); container.Register <I, B>(Reuse.ScopedTo("b")); using (var scope = container.OpenScope("b")) { // Throws an exception because of the multiple `I` registrations found Assert.Throws <ContainerException>(() => scope.Resolve <I>()); } }
public void Example() { var container = new Container(); container.Register <I, A>(Reuse.ScopedTo("a")); container.Register <I, B>(Reuse.ScopedTo("b")); using (var scope = container.OpenScope("b")) { // will skip a registration of `A` because the open scope has different name var b = scope.Resolve <I>(); Assert.IsInstanceOf <B>(b); } }
public void Test_with_default_container_rules() { var container = new Container(); container.Register <TestScope1>(setup: Setup.With(openResolutionScope: true)); container.Register <TestScope2>(setup: Setup.With(openResolutionScope: true)); container.Register <Test1>(Reuse.ScopedTo <TestScope1>()); container.Register <Test1>(Reuse.ScopedTo <TestScope2>()); var t1 = container.Resolve <TestScope1>(); var t2 = container.Resolve <TestScope2>(); Assert.AreNotSame(t1.Test1, t2.Test1); }
/// <summary> /// Register implementation of type /// </summary> /// <param name="registrationType">Type to register</param> /// <param name="implementationType">Implementation type of <see cref="registrationType" /> null to use <see cref="registrationType" /></param> /// <param name="reuse">Should the registration be singleton or multiple</param> /// <param name="name"></param> public static void Set(Type registrationType, Type implementationType, Reuse reuse = Reuse.Multiple, string name = null) { var container = GetContainer(registrationType); container.Set(implementationType ?? registrationType, reuse, name); }