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