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);
}
