protected override IContainerExtension CreateContainerExtension()
{
var unity = new UnityContainer().AddExtension(new Diagnostic());
var container = new UnityContainerExtension(unity);
var mainScope = new ScopedContainer(container, unity);
container.RegisterInstance <IScopedContainer>(mainScope);
return(container);
}
public void Enumerable_ShouldWorkFromScopedContainer()
{
var container = new ScopedContainer();
using (var scope = container.CreateScope())
{
var result = scope.Resolve <IEnumerable <Action <BaseClassChild> > >();
Assert.Empty(result);
}
}
protected override IContainerExtension CreateContainerExtension()
{
IUnityContainer unity = new UnityContainer();
#if DEBUG
unity = unity.AddExtension(new Diagnostic());
#endif
var container = new UnityContainerExtension(unity);
var mainScope = new ScopedContainer(container, unity);
container.RegisterInstance <IScopedContainer>(mainScope);
ViewBind.ContainerProvider = container;
return(container);
}
public void ScopeShouldCreateOnlyOneScopedObject()
{
// <example1>
using (var container = new ScopedContainer())
{
container.RegisterScoped <MyService, IMyService>();
var result1 = container.Resolve <IMyService>();
var result2 = container.Resolve <IMyService>();
Assert.Same(result1, result2);
}
// </example1>
}
protected override IServiceProvider CreateServiceProvider(IServiceCollection serviceCollection)
{
//Just proving my comments on https://github.com/aspnet/DependencyInjection/issues/589
var config = TargetContainer
.DefaultConfig
.Clone()
.ConfigureOption <Options.LazyEnumerables>(false);
var container = new ScopedContainer(
new TargetContainer(config));
//var container = new ScopedContainer();
container.Populate(serviceCollection);
return(container);
}
public void ShouldDispose()
{
// <example11>
var disposableObj = new DisposableType();
using (var container = new ScopedContainer())
{
container.RegisterObject(disposableObj, scopeBehaviour: ScopeBehaviour.Explicit);
var result = container.Resolve <DisposableType>();
Assert.Same(disposableObj, result);
}
// Should be disposed
Assert.True(disposableObj.Disposed);
// </example11>
}
public void ShouldNotDisposeByDefault()
{
// <example10>
var disposableObj = new DisposableType();
using (var container = new ScopedContainer())
{
container.RegisterObject(disposableObj);
var result = container.Resolve <DisposableType>();
Assert.Same(disposableObj, result);
}
// Should NOT be disposed
Assert.False(disposableObj.Disposed);
// </example10>
}
public void Enumerable_ShouldCreateSameScopeds()
{
var container = new ScopedContainer();
container.RegisterScoped <BaseClass>();
container.RegisterScoped <BaseClassChild, BaseClass>();
container.RegisterScoped <BaseClassGrandchild, BaseClass>();
var last = container.Resolve <BaseClass>();
var result = container.ResolveMany <BaseClass>().ToArray();
Assert.NotSame(result[0], result[1]);
Assert.NotSame(result[1], result[2]);
Assert.Same(last, result[2]);
}
public void ScopeShouldCreateDifferentScopedObjectsFromItsParent()
{
// <example2>
using (var container = new ScopedContainer())
{
container.RegisterScoped <MyService, IMyService>();
var result1 = container.Resolve <IMyService>();
IMyService result2;
using (var scope = container.CreateScope())
{
result2 = scope.Resolve <IMyService>();
Assert.NotSame(result1, result2);
}
}
// </example2>
}
/// <summary>
/// Creates a new default <see cref="ScopedContainer"/> and registers the services in <paramref name="services"/>
/// as targets.
/// </summary>
/// <param name="services">The services to be registered.</param>
/// <returns>An <see cref="Container"/> instance</returns>
/// <exception cref="ArgumentNullException">If <paramref name="services"/> is null.</exception>
/// <remarks>The <see cref="Rezolver.Options.LazyEnumerables"/> option (is set to <c>false</c> by this method,
/// because v2.0 of .Net Core 2 seems to expect all enumerables to be eagerly loaded - getting clarification
/// on this from the team at https://github.com/aspnet/DependencyInjection/issues/589</remarks>
public static Container CreateRezolverContainer(this IServiceCollection services)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
var targetContainer = new TargetContainer(
TargetContainer.DefaultConfig
.Clone()
.ConfigureOption <Rezolver.Options.LazyEnumerables>(false)
);
var c = new ScopedContainer(targetContainer);
c.Populate(services);
return(c);
}
public void ShouldInjectEnumerableWithItemsWithDifferentLifetimes()
{
// <example4>
// since we're using a scoped registration here,
// we'll use the ScopedContainer, which establishes
// a root scope.
var container = new ScopedContainer();
container.RegisterSingleton <MyService1, IMyService>();
container.RegisterScoped <MyService2, IMyService>();
container.RegisterType <MyService3, IMyService>();
// So - each enumerable will contain, in order:
// 1) Singleton IMyService
// 2) Scoped IMyService
// 3) Transient IMyService
var fromRoot1 = container.ResolveMany <IMyService>().ToArray();
var fromRoot2 = container.ResolveMany <IMyService>().ToArray();
Assert.Same(fromRoot1[0], fromRoot2[0]);
// both scoped objects should be the same because we've resolved
// from the root scope
Assert.Same(fromRoot1[1], fromRoot2[1]);
Assert.NotSame(fromRoot1[2], fromRoot2[2]);
using (var childScope = container.CreateScope())
{
var fromChildScope1 = childScope.ResolveMany <IMyService>().ToArray();
// singleton should be the same as before, but
// the scoped object will be different
Assert.Same(fromRoot1[0], fromChildScope1[0]);
Assert.NotSame(fromRoot1[1], fromChildScope1[1]);
Assert.NotSame(fromRoot1[2], fromChildScope1[2]);
var fromChildScope2 = childScope.ResolveMany <IMyService>().ToArray();
// the scoped object will be the same as above
Assert.Same(fromChildScope1[0], fromChildScope2[0]);
Assert.Same(fromChildScope1[1], fromChildScope2[1]);
Assert.NotSame(fromChildScope1[2], fromChildScope2[2]);
}
// </example4>
}
public void EagerEnumerable_ShouldCreateSameScopeds()
{
var targets = CreateTargetContainer();
targets.SetOption <Options.LazyEnumerables, BaseClass>(false);
var container = new ScopedContainer(targets);
container.RegisterScoped <BaseClass>();
container.RegisterScoped <BaseClassChild, BaseClass>();
container.RegisterScoped <BaseClassGrandchild, BaseClass>();
var last = container.Resolve <BaseClass>();
var result = container.ResolveMany <BaseClass>().ToArray();
Assert.NotSame(result[0], result[1]);
Assert.NotSame(result[1], result[2]);
Assert.Same(last, result[2]);
}
public void OnlyRootScopeShouldDispose()
{
// <example12>
var disposableObj = new DisposableType();
using (var container = new ScopedContainer())
{
container.RegisterObject(disposableObj, scopeBehaviour: ScopeBehaviour.Explicit);
using (var scope = container.CreateScope())
{
var result = container.Resolve <DisposableType>();
Assert.Same(disposableObj, result);
}
// Should not be disposed here...
Assert.False(disposableObj.Disposed);
}
// ... but should be disposed here
Assert.True(disposableObj.Disposed);
// </example12>
}
public void DisposableSingletonShouldBeDisposedByRootScope()
{
// <example4>
// In this example we use the disposable ScopedContainer, which
// supports all the same functionality as 'Container' except it
// also has its own scope, and is therefore disposable.
DisposableType result;
using (var container = new ScopedContainer())
{
container.RegisterSingleton <DisposableType>();
using (var scope = container.CreateScope())
{
// singletons force tracking in the
// rootmost scope of a scope hierarchy
result = scope.Resolve <DisposableType>();
}
Assert.False(result.Disposed);
}
Assert.True(result.Disposed);
// </example4>
}
