public void BeginLifetimeScope() { DependencyInjectionContainer container = new DependencyInjectionContainer(); container.Configure(c => c.Export<DisposableService>().As<IDisposableService>().Lifestyle.SingletonPerScope()); IDisposableService service = container.Locate<IDisposableService>(); Assert.NotNull(service); bool called = false; using (var scope = container.BeginLifetimeScope()) { var secondService = scope.Locate<IDisposableService>(); Assert.NotNull(secondService); Assert.NotSame(service, secondService); Assert.Same(secondService, scope.Locate<IDisposableService>()); secondService.Disposing += (sender, args) => called = true; } Assert.True(called); }
public void RegisterPerThread_DifferentThreads_Success() { ITestCase testCase = new PerThreadTestCaseA(new GraceRegistration(), new GraceResolving()); var c = new DependencyInjectionContainer(); c = (DependencyInjectionContainer)testCase.Register(c, RegistrationKind.PerThread); ITestA obj1 = null; ITestA obj2 = null; var thread1 = new Thread(() => { using (var scope = c.BeginLifetimeScope()) { obj1 = scope.Locate <ITestA>(); } }); var thread2 = new Thread(() => { using (var scope = c.BeginLifetimeScope()) { obj2 = scope.Locate <ITestA>(); } }); thread1.Start(); thread1.Join(); thread2.Start(); thread2.Join(); CheckHelper.Check(obj1, true, true); CheckHelper.Check(obj2, true, true); CheckHelper.Check(obj1, obj2, false, false); }
public void SingletonPerScopeNamedDifferentNamedScopes() { var container = new DependencyInjectionContainer(); container.Configure(c => c.Export <BasicService>().As <IBasicService>().Lifestyle.SingletonPerNamedScope("Test")); var child1 = container.BeginLifetimeScope(scopeName: "Test"); var baseService1 = child1.Locate <IBasicService>(); Assert.NotNull(baseService1); Assert.Same(baseService1, child1.Locate <IBasicService>()); var child2 = container.BeginLifetimeScope(scopeName: "Test"); var baseService2 = child2.Locate <IBasicService>(); Assert.NotNull(baseService2); Assert.Same(baseService2, child2.Locate <IBasicService>()); Assert.NotSame(baseService1, baseService2); }
public void Inject_Property_From_LifetimeScope() { var container = new DependencyInjectionContainer(); container.Configure(c => c.Export <AttributeBasicService>().As <IAttributeBasicService>()); using (var scope = container.BeginLifetimeScope()) { var instance = new AttributedImportPropertyService(); scope.Inject(instance); Assert.NotNull(instance.BasicService); } }
public void SingletonPerNamedScopeDisposal() { var container = new DependencyInjectionContainer(); container.Configure(c => c.Export <DisposableService>().As <IDisposableService>().Lifestyle.SingletonPerNamedScope("Test")); var disposed = false; using (var childScope = container.BeginLifetimeScope(scopeName: "Test")) { childScope.Locate <IDisposableService>().Disposing += (sender, args) => disposed = true; } Assert.True(disposed); }
public void DynamicMethod_Per_Scope() { var container = new DependencyInjectionContainer(GraceDynamicMethod.Configuration(c => { c.Trace = s => Assert.DoesNotContain("falling back", s); })); container.Configure(c => c.Export <BasicService>().As <IBasicService>().Lifestyle.SingletonPerScope()); var value = container.Locate <DisposableDependent>(); using (var scope = container.BeginLifetimeScope()) { value = scope.Locate <DisposableDependent>(); } }
public void Container_BeingLifetimeScope_SimpleResolve() { var container = new DependencyInjectionContainer(); container.Configure(c => { c.Export <BasicService>().As <IBasicService>(); }); using (var lifetimeScope = container.BeginLifetimeScope()) { var basicService = lifetimeScope.Locate <IBasicService>(); Assert.NotNull(basicService); Assert.IsType <BasicService>(basicService); } }
public void LifetimeScope_TryLocate() { var container = new DependencyInjectionContainer(); container.Configure(c => c.Export <BasicService>().As <IBasicService>()); using (var scope = container.BeginLifetimeScope()) { IBasicService basicService; Assert.True(scope.TryLocate(out basicService)); IMultipleService multipleService; Assert.False(scope.TryLocate(out multipleService)); } }
public void Export_DisposableCleanup_Called() { var container = new DependencyInjectionContainer(); var disposedDelegateCalled = false; container.Configure(c => c.Export <DisposableService>().As <IDisposableService>().DisposalCleanupDelegate(d => disposedDelegateCalled = true)); using (var scope = container.BeginLifetimeScope()) { var instance = scope.Locate <IDisposableService>(); Assert.NotNull(instance); } Assert.True(disposedDelegateCalled); }
public void ExternallyOwned_ExportStrategy_Not_Disposed() { var container = new DependencyInjectionContainer(); container.Configure(c => c.Export <DisposableService>().As <IDisposableService>().ExternallyOwned()); var disposed = false; using (var scope = container.BeginLifetimeScope()) { var instance = scope.Locate <IDisposableService>(); instance.Disposing += (sender, args) => disposed = true; } Assert.False(disposed); }
public void Scoped_TryLocateByName_Find() { var container = new DependencyInjectionContainer(); container.Configure(c => c.Export <BasicService>().AsName("BasicService")); object instance; using (var scope = container.BeginLifetimeScope()) { var returnValue = scope.TryLocateByName("BasicService", out instance); Assert.True(returnValue); Assert.NotNull(instance); Assert.IsType <BasicService>(instance); } }
public void LifetimeScope_Locate_Dynamic() { var container = new DependencyInjectionContainer(); using (var scope = container.BeginLifetimeScope()) { IBasicService basicService; Assert.Throws <LocateException>(() => basicService = scope.Locate <IBasicService>(isDynamic: true)); container.Configure(c => c.Export <BasicService>().As <IBasicService>()); basicService = scope.Locate <IBasicService>(isDynamic: true); Assert.NotNull(basicService); } }
public void Container_BeginLifetimeScope_DisposeCorrectly() { var container = new DependencyInjectionContainer(); container.Configure(c => c.Export <DisposableService>().As <IDisposableService>()); var disposedCalled = false; using (var lifetimeScope = container.BeginLifetimeScope()) { var disposed = lifetimeScope.Locate <IDisposableService>(); Assert.NotNull(disposed); disposed.Disposing += (sender, args) => disposedCalled = true; } Assert.True(disposedCalled); }
public void Container_BeingLifetimeScope_LocateOrDefault() { var container = new DependencyInjectionContainer(); container.Configure(c => { c.Export <BasicService>().As <IBasicService>(); }); using (var lifetimeScope = container.BeginLifetimeScope()) { var defaultValue = new BasicService(); var basicService = lifetimeScope.LocateOrDefault <IBasicService>(defaultValue); Assert.NotNull(basicService); Assert.IsType <BasicService>(basicService); Assert.NotSame(basicService, defaultValue); } }
public void Scoped_Export_Disposable_AsName() { var container = new DependencyInjectionContainer(); container.Configure(c => c.Export <DisposableService>().AsName("DisposableService")); var disposed = false; using (var scope = container.BeginLifetimeScope()) { var instance = (IDisposableService)scope.LocateByName("DisposableService"); Assert.NotNull(instance); Assert.IsType <DisposableService>(instance); instance.Disposing += (sender, args) => disposed = true; } Assert.True(disposed); }
public void SingletonPerNamedScopeNestedSameTest() { var container = new DependencyInjectionContainer(); container.Configure(c => c.Export <BasicService>().As <IBasicService>().Lifestyle.SingletonPerNamedScope("Test")); var parentScope = container.BeginLifetimeScope("Test"); var childScope1 = parentScope.BeginLifetimeScope(scopeName: "Child1"); var childScope2 = parentScope.BeginLifetimeScope(scopeName: "Child2"); var basicService = parentScope.Locate <IBasicService>(); Assert.NotNull(basicService); Assert.Same(basicService, childScope1.Locate <IBasicService>()); Assert.Same(basicService, childScope2.Locate <IBasicService>()); }
public void FluentExportStrategyConfiguration_ExternallyOwned() { var container = new DependencyInjectionContainer(); container.Configure(c => { c.Export(typeof(DisposableService)).ExternallyOwned(); }); DisposableService disposableService; var disposed = false; using (var scope = container.BeginLifetimeScope()) { disposableService = scope.Locate <DisposableService>(); disposableService.Disposing += (sender, args) => disposed = true; } Assert.False(disposed); }
public void LifetimeScope_LocateAll_Generic() { var container = new DependencyInjectionContainer(); container.Configure(c => { c.Export <MultipleService1>().As <IMultipleService>(); c.Export <MultipleService2>().As <IMultipleService>(); c.Export <MultipleService3>().As <IMultipleService>(); c.Export <MultipleService4>().As <IMultipleService>(); c.Export <MultipleService5>().As <IMultipleService>(); }); using (var scope = container.BeginLifetimeScope()) { var list = scope.LocateAll <IMultipleService>(); Assert.NotNull(list); Assert.Equal(5, list.Count); } }
public void ExportTypeSet_ExternallyOwned() { var container = new DependencyInjectionContainer(); container.Configure(c => { c.ExportAssemblyContaining <IMultipleService>().ByInterfaces(); }); var disposed = false; using (var scope = container.BeginLifetimeScope()) { var disposable = scope.Locate <IDisposableService>(); disposable.Disposing += (sender, args) => disposed = true; } Assert.True(disposed); container = new DependencyInjectionContainer(); container.Configure(c => { c.ExportAssemblyContaining <IMultipleService>().ByInterfaces().ExternallyOwned(); }); disposed = false; using (var scope = container.BeginLifetimeScope()) { var disposable = scope.Locate <IDisposableService>(); disposable.Disposing += (sender, args) => disposed = true; } Assert.False(disposed); }
public static object Measure(DependencyInjectionContainer container) { using (var scope = container.BeginLifetimeScope()) return(scope.Locate <ScopedBlah>()); }
public IResolveScope CreateScope(string scopeName = "") { return(new GraceScope(_container.BeginLifetimeScope(scopeName))); }
public void BulkLifestyleSingletonPerScope() { DependencyInjectionContainer container = new DependencyInjectionContainer(); container.Configure(c => c.Export(Types.FromThisAssembly()) .ByInterface<IBasicService>() .Lifestyle.SingletonPerScope()); IBasicService basicService = container.Locate<IBasicService>(); Assert.NotNull(basicService); Assert.Same(basicService, container.Locate<IBasicService>()); using (var scope = container.BeginLifetimeScope()) { IBasicService basicService2 = scope.Locate<IBasicService>(); Assert.NotNull(basicService2); Assert.Same(basicService2, scope.Locate<IBasicService>()); Assert.NotSame(basicService, basicService2); } }