public void CanDetermineIfLifetimeContainerContainsObject()
{
ILifetimeContainer container = new LifetimeContainer();
object obj = new object();
container.Add(obj);
Assert.IsTrue(container.Contains(obj));
}
public void DisposingContainerDisposesOwnedObjects()
{
ILifetimeContainer container = new LifetimeContainer();
MockDisposableObject mdo = new MockDisposableObject();
container.Add(mdo);
container.Dispose();
Assert.IsTrue(mdo.WasDisposed);
}
public void RemovingItemsFromContainerDoesNotDisposeThem()
{
ILifetimeContainer container = new LifetimeContainer();
MockDisposableObject mdo = new MockDisposableObject();
container.Add(mdo);
container.Remove(mdo);
container.Dispose();
Assert.IsFalse(mdo.WasDisposed);
}
public void ContainerEnsuresObjectsWontBeCollected()
{
ILifetimeContainer container = new LifetimeContainer();
DisposableObject mdo = new DisposableObject();
WeakReference wref = new WeakReference(mdo);
container.Add(mdo);
mdo = null;
GC.Collect();
Assert.AreEqual(1, container.Count);
mdo = wref.Target as DisposableObject;
Assert.IsNotNull(mdo);
Assert.IsFalse(mdo.WasDisposed);
}
public void DisposingItemsFromContainerDisposesInReverseOrderAdded()
{
ILifetimeContainer container = new LifetimeContainer();
DisposeOrderCounter obj1 = new DisposeOrderCounter();
DisposeOrderCounter obj2 = new DisposeOrderCounter();
DisposeOrderCounter obj3 = new DisposeOrderCounter();
container.Add(obj1);
container.Add(obj2);
container.Add(obj3);
container.Dispose();
Assert.AreEqual(1, obj3.DisposePosition);
Assert.AreEqual(2, obj2.DisposePosition);
Assert.AreEqual(3, obj1.DisposePosition);
}
public void CanEnumerateItemsInContainer()
{
ILifetimeContainer container = new LifetimeContainer();
DisposableObject mdo = new DisposableObject();
container.Add(mdo);
int count = 0;
bool foundMdo = false;
foreach (object obj in container)
{
count++;
if (ReferenceEquals(mdo, obj))
foundMdo = true;
}
Assert.AreEqual(1, count);
Assert.IsTrue(foundMdo);
}
public void TestBuildWithParameterDependency()
{
Locator locator = new Locator();
LifetimeContainer container = new LifetimeContainer();
locator.Add(typeof(ILifetimeContainer), container);
WCSFBuilder builder = new WCSFBuilder();
builder.Policies.SetDefault <ISingletonPolicy>(new SingletonPolicy(true));
TestableRootCompositionContainer compositionContainer = new TestableRootCompositionContainer(builder);
locator.Add(new DependencyResolutionLocatorKey(typeof(CompositionContainer), null), compositionContainer);
ITestService service = compositionContainer.Services.AddNew <TestService, ITestService>();
TestParameterDependency builtObject =
builder.BuildUp(locator, typeof(TestParameterDependency), Guid.NewGuid().ToString(), null) as
TestParameterDependency;
Assert.IsNotNull(builtObject);
Assert.IsNotNull(builtObject.TestService);
Assert.AreEqual(service, builtObject.TestService);
}
public void CanEnumerateItemsInContainer()
{
ILifetimeContainer container = new LifetimeContainer();
MockDisposableObject mdo = new MockDisposableObject();
container.Add(mdo);
int count = 0;
bool foundMdo = false;
foreach (object obj in container)
{
count++;
if (ReferenceEquals(mdo, obj))
{
foundMdo = true;
}
}
Assert.AreEqual(1, count);
Assert.IsTrue(foundMdo);
}
private MockBuilderContext CreateContext(Locator locator)
{
IBuilderStrategy[] strategies =
{
new SingletonStrategy(),
new ConstructorReflectionStrategy(),
new CreationStrategy()
};
MockBuilderContext result = new MockBuilderContext(strategies);
result.Locator = locator;
LifetimeContainer lifetimeContainer = new LifetimeContainer();
if (!result.Locator.Contains(typeof(ILifetimeContainer)))
{
result.Locator.Add(typeof(ILifetimeContainer), lifetimeContainer);
}
result.Policies.SetDefault <ICreationPolicy>(new DefaultCreationPolicy());
result.Policies.SetDefault <ISingletonPolicy>(new SingletonPolicy(true));
return(result);
}
private Locator CreateLocator()
{
Locator locator = new Locator();
LifetimeContainer lifetime = new LifetimeContainer();
locator.Add(typeof(ILifetimeContainer), lifetime);
return locator;
}
public void RemovingNonContainedItemDoesNotThrow()
{
ILifetimeContainer container = new LifetimeContainer();
container.Remove(new object());
}
public void RemovingNonContainedItemDoesNotThrow()
{
ILifetimeContainer container = new LifetimeContainer();
container.Remove(new object());
}
/// <summary>
/// Create a default <see cref="UnityContainer"/>.
/// </summary>
public UnityContainer(ModeFlags mode = ModeFlags.Optimized)
{
if (!mode.IsValid())
{
throw new ArgumentException("'Activated' and 'Diagnostic' flags are mutually exclusive.");
}
/////////////////////////////////////////////////////////////
// Initialize Root
_root = this;
ExecutionMode = mode;
LifetimeContainer = new LifetimeContainer(this);
Register = AddOrReplace;
//Built-In Registrations
// Defaults
Defaults = new DefaultPolicies(this);
// IUnityContainer, IUnityContainerAsync
var container = new ExplicitRegistration(this, null, typeof(UnityContainer), new ContainerLifetimeManager())
{
Pipeline = (ref PipelineContext c) => c.Container
};
Debug.Assert(null != container.LifetimeManager);
// Create Registries
_metadata = new Metadata();
_registry = new Registry(Defaults);
_registry.Set(typeof(IUnityContainer), null, container); // TODO: Remove redundancy
_registry.Set(typeof(IUnityContainerAsync), null, container);
_registry.Set(typeof(IUnityContainer), null, container.LifetimeManager.Pipeline);
_registry.Set(typeof(IUnityContainerAsync), null, container.LifetimeManager.Pipeline);
/////////////////////////////////////////////////////////////
// Built-In Features
var func = new PolicySet(this);
_registry.Set(typeof(Func <>), func);
func.Set(typeof(LifetimeManager), new PerResolveLifetimeManager());
func.Set(typeof(TypeFactoryDelegate), FuncResolver.Factory); // Func<> Factory
_registry.Set(typeof(Lazy <>), new PolicySet(this, typeof(TypeFactoryDelegate), LazyResolver.Factory)); // Lazy<>
_registry.Set(typeof(IEnumerable <>), new PolicySet(this, typeof(TypeFactoryDelegate), EnumerableResolver.Factory)); // Enumerable
_registry.Set(typeof(IRegex <>), new PolicySet(this, typeof(TypeFactoryDelegate), RegExResolver.Factory)); // Regular Expression Enumerable
/////////////////////////////////////////////////////////////
// Pipelines
var typeFactory = new TypeFactoryPipeline();
var lifetime = new LifetimePipeline();
// Mode of operation
if (ExecutionMode.IsDiagnostic())
{
/////////////////////////////////////////////////////////////
// Setup Diagnostic mode
var diagnostic = new DiagnosticPipeline();
// Create Context
Context = new ContainerContext(this,
new StagedStrategyChain <Pipeline, Stage> // Type Build Pipeline
{
{ diagnostic, Stage.Diagnostic },
{ typeFactory, Stage.Factory },
{ new MappingDiagnostic(), Stage.TypeMapping },
{ new ConstructorDiagnostic(this), Stage.Creation },
{ new FieldDiagnostic(this), Stage.Fields },
{ new PropertyDiagnostic(this), Stage.Properties },
{ new MethodDiagnostic(this), Stage.Methods }
},
new StagedStrategyChain <Pipeline, Stage> // Factory Resolve Pipeline
{
{ diagnostic, Stage.Diagnostic },
{ new FactoryPipeline(), Stage.Factory }
},
new StagedStrategyChain <Pipeline, Stage> // Instance Resolve Pipeline
{
{ diagnostic, Stage.Diagnostic },
{ typeFactory, Stage.Factory }
});
// Build process
DependencyResolvePipeline = ValidatingDependencyResolvePipeline;
// Validators
ValidateType = DiagnosticValidateType;
ValidateTypes = DiagnosticValidateTypes;
CreateErrorMessage = CreateDiagnosticMessage;
}
else
{
// Create Context
Context = new ContainerContext(this,
new StagedStrategyChain <Pipeline, Stage> // Type Build Pipeline
{
{ lifetime, Stage.Lifetime },
{ typeFactory, Stage.Factory },
{ new MappingPipeline(), Stage.TypeMapping },
{ new ConstructorPipeline(this), Stage.Creation },
{ new FieldPipeline(this), Stage.Fields },
{ new PropertyPipeline(this), Stage.Properties },
{ new MethodPipeline(this), Stage.Methods }
},
new StagedStrategyChain <Pipeline, Stage> // Factory Resolve Pipeline
{
{ lifetime, Stage.Lifetime },
{ new FactoryPipeline(), Stage.Factory }
},
new StagedStrategyChain <Pipeline, Stage> // Instance Resolve Pipeline
{
{ typeFactory, Stage.Factory }
});
}
/////////////////////////////////////////////////////////////
// Build Mode
var build = _root.ExecutionMode.BuildMode();
PipelineFromRegistration = build switch
{
ModeFlags.Activated => PipelineFromRegistrationActivated,
ModeFlags.Compiled => PipelineFromRegistrationCompiled,
_ => (FromRegistration)PipelineFromRegistrationOptimized
};
PipelineFromUnregisteredType = build switch
{
ModeFlags.Activated => PipelineFromUnregisteredTypeActivated,
ModeFlags.Compiled => PipelineFromUnregisteredTypeCompiled,
_ => (FromUnregistered)PipelineFromUnregisteredTypeOptimized
};
PipelineFromOpenGeneric = build switch
{
ModeFlags.Activated => PipelineFromOpenGenericActivated,
ModeFlags.Compiled => PipelineFromOpenGenericCompiled,
_ => (FromOpenGeneric)PipelineFromOpenGenericOptimized
};
}
public void CreationPolicyWillRecordSingletonsUsingLocalLifetimeContainerOnly()
{
BuilderStrategyChain chain = new BuilderStrategyChain();
chain.Add(new CreationStrategy());
Locator parentLocator = new Locator();
LifetimeContainer container = new LifetimeContainer();
parentLocator.Add(typeof(ILifetimeContainer), container);
Locator childLocator = new Locator(parentLocator);
PolicyList policies = new PolicyList();
policies.SetDefault<ICreationPolicy>(new DefaultCreationPolicy());
policies.SetDefault<ISingletonPolicy>(new SingletonPolicy(true));
BuilderContext ctx = new BuilderContext(chain, childLocator, policies);
object obj = ctx.HeadOfChain.BuildUp(ctx, typeof(object), null, null);
Assert.IsNotNull(obj);
Assert.IsNull(childLocator.Get(new DependencyResolutionLocatorKey(typeof(object), null)));
}
/// <summary>
/// Create a default <see cref="UnityContainer"/>.
/// </summary>
public UnityContainer(ModeFlags mode = ModeFlags.Optimized)
{
if (!mode.IsValid())
{
throw new ArgumentException("'Activated' and 'Diagnostic' flags are mutually exclusive.");
}
/////////////////////////////////////////////////////////////
// Initialize Root
_root = this;
// Defaults and policies
ModeFlags = mode;
Defaults = new DefaultPolicies(this);
LifetimeContainer = new LifetimeContainer(this);
Register = AddOrReplace;
// Create Registry and set Factory strategy
_metadata = new Registry <int[]>();
_registry = new Registry <IPolicySet>(Defaults);
/////////////////////////////////////////////////////////////
//Built-In Registrations
// IUnityContainer, IUnityContainerAsync
var container = new ImplicitRegistration(this, null)
{
Pipeline = (ref BuilderContext c) => c.Async ? (object)Task.FromResult <object>(c.Container) : c.Container
};
_registry.Set(typeof(IUnityContainer), null, container);
_registry.Set(typeof(IUnityContainerAsync), null, container);
// Built-In Features
var func = new PolicySet(this);
_registry.Set(typeof(Func <>), func);
func.Set(typeof(LifetimeManager), new PerResolveLifetimeManager());
func.Set(typeof(TypeFactoryDelegate), FuncResolver.Factory); // Func<> Factory
_registry.Set(typeof(Lazy <>), new PolicySet(this, typeof(TypeFactoryDelegate), LazyResolver.Factory)); // Lazy<>
_registry.Set(typeof(IEnumerable <>), new PolicySet(this, typeof(TypeFactoryDelegate), EnumerableResolver.Factory)); // Enumerable
_registry.Set(typeof(IRegex <>), new PolicySet(this, typeof(TypeFactoryDelegate), RegExResolver.Factory)); // Regular Expression Enumerable
/////////////////////////////////////////////////////////////
// Pipelines
var factory = new FactoryPipeline();
var lifetime = new LifetimePipeline();
// Mode of operation
if (ModeFlags.IsOptimized())
{
/////////////////////////////////////////////////////////////
// Setup Optimized mode
// Create Context
Context = new ContainerContext(this,
new StagedStrategyChain <Pipeline, Stage> // Type Build Pipeline
{
{ lifetime, Stage.Lifetime },
{ factory, Stage.Factory },
{ new MappingPipeline(), Stage.TypeMapping },
{ new ConstructorPipeline(this), Stage.Creation },
{ new FieldPipeline(this), Stage.Fields },
{ new PropertyPipeline(this), Stage.Properties },
{ new MethodPipeline(this), Stage.Methods }
},
new StagedStrategyChain <Pipeline, Stage> // Factory Resolve Pipeline
{
{ lifetime, Stage.Lifetime },
{ factory, Stage.Factory }
},
new StagedStrategyChain <Pipeline, Stage> // Instance Resolve Pipeline
{
{ lifetime, Stage.Lifetime },
});
}
else
{
/////////////////////////////////////////////////////////////
// Setup Diagnostic mode
var diagnostic = new DiagnosticPipeline();
// Create Context
Context = new ContainerContext(this,
new StagedStrategyChain <Pipeline, Stage> // Type Build Pipeline
{
{ diagnostic, Stage.Diagnostic },
{ lifetime, Stage.Lifetime },
{ factory, Stage.Factory },
{ new MappingDiagnostic(), Stage.TypeMapping },
{ new ConstructorDiagnostic(this), Stage.Creation },
{ new FieldDiagnostic(this), Stage.Fields },
{ new PropertyDiagnostic(this), Stage.Properties },
{ new MethodDiagnostic(this), Stage.Methods }
},
new StagedStrategyChain <Pipeline, Stage> // Factory Resolve Pipeline
{
{ diagnostic, Stage.Diagnostic },
{ lifetime, Stage.Lifetime },
{ factory, Stage.Factory }
},
new StagedStrategyChain <Pipeline, Stage> // Instance Resolve Pipeline
{
{ diagnostic, Stage.Diagnostic },
{ lifetime, Stage.Lifetime },
});
// Build process
DependencyResolvePipeline = ValidatingDependencyResolvePipeline;
// Validators
ValidateType = DiagnosticValidateType;
ValidateTypes = DiagnosticValidateTypes;
CreateMessage = CreateDiagnosticMessage;
}
}
