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