// Root Container Constructor
internal ContainerContext(UnityContainer container, StagedStrategyChain <Pipeline, Stage> type,
StagedStrategyChain <Pipeline, Stage> factory,
StagedStrategyChain <Pipeline, Stage> instance)
{
// Container this context represents
Container = container;
// Lifetime Managers
_typeLifetimeManager = TransientLifetimeManager.Instance;
_factoryLifetimeManager = TransientLifetimeManager.Instance;
_instanceLifetimeManager = new ContainerControlledLifetimeManager();
// Initialize Pipelines
TypePipeline = type;
TypePipeline.Invalidated += (s, e) => TypePipelineCache = TypePipeline.ToArray();
TypePipelineCache = TypePipeline.ToArray();
FactoryPipeline = factory;
FactoryPipeline.Invalidated += (s, e) => FactoryPipelineCache = FactoryPipeline.ToArray();
FactoryPipelineCache = FactoryPipeline.ToArray();
InstancePipeline = instance;
InstancePipeline.Invalidated += (s, e) => InstancePipelineCache = InstancePipeline.ToArray();
InstancePipelineCache = InstancePipeline.ToArray();
}
public void OrderingAcrossStagesForStrategyChain()
{
StagedStrategyChain <BuilderStrategy, FakeStage> innerChain = new StagedStrategyChain <BuilderStrategy, FakeStage>();
StagedStrategyChain <BuilderStrategy, FakeStage> outerChain = new StagedStrategyChain <BuilderStrategy, FakeStage>(innerChain);
FakeStrategy innerStage1 = new FakeStrategy {
Name = "innerStage1"
};
FakeStrategy innerStage2 = new FakeStrategy {
Name = "innerStage2"
};
FakeStrategy outerStage1 = new FakeStrategy {
Name = "outerStage1"
};
FakeStrategy outerStage2 = new FakeStrategy {
Name = "outerStage2"
};
innerChain.Add(innerStage1, FakeStage.Stage1);
innerChain.Add(innerStage2, FakeStage.Stage2);
outerChain.Add(outerStage1, FakeStage.Stage1);
outerChain.Add(outerStage2, FakeStage.Stage2);
var chain = outerChain.ToArray();
AssertOrder(chain, innerStage1, outerStage1, innerStage2, outerStage2);
}
public void SetUp()
{
builder = new Builder();
strategies = new StagedStrategyChain <BuilderStage>();
strategies.AddNew <ConfigurationNameMappingStrategy>(BuilderStage.PreCreation);
MockNameMapper.invoked = false;
}
/// <summary>
/// Create a default <see cref="UnityContainer"/>.
/// </summary>
public UnityContainer()
{
// Root of the hierarchy
_root = this;
// Lifetime Container
LifetimeContainer = new LifetimeContainer(this);
// Registry
InitializeRootRegistry();
/////////////////////////////////////////////////////////////
// Context
_context = new ContainerContext(this);
// Build Strategies
_strategies = new StagedStrategyChain <BuilderStrategy, UnityBuildStage>
{
{ new LifetimeStrategy(), UnityBuildStage.Lifetime }, // Lifetime
{ new BuildKeyMappingStrategy(), UnityBuildStage.TypeMapping }, // Mapping
{ new BuildPlanStrategy(), UnityBuildStage.Creation } // Build
};
// Update on change
_strategies.Invalidated += (s, e) => _strategiesChain = _strategies.ToArray();
_strategiesChain = _strategies.ToArray();
// Default Policies and Strategies
SetDefaultPolicies(this);
}
// Child Container Constructor
internal ContainerContext(UnityContainer container)
{
// Container this context represents
Container = container;
var parent = Container._parent ?? throw new InvalidOperationException("Parent must not be null");
// Lifetime Managers
_typeLifetimeManager = parent.Context._typeLifetimeManager;
_factoryLifetimeManager = parent.Context._factoryLifetimeManager;
_instanceLifetimeManager = parent.Context._instanceLifetimeManager;
// TODO: Create on demand
// Initialize Pipelines
TypePipeline = new StagedStrategyChain <Pipeline, Stage>(parent.Context.TypePipeline);
TypePipeline.Invalidated += (s, e) => TypePipelineCache = TypePipeline.ToArray();
TypePipelineCache = TypePipeline.ToArray();
FactoryPipeline = new StagedStrategyChain <Pipeline, Stage>(parent.Context.FactoryPipeline);
FactoryPipeline.Invalidated += (s, e) => FactoryPipelineCache = FactoryPipeline.ToArray();
FactoryPipelineCache = FactoryPipeline.ToArray();
InstancePipeline = new StagedStrategyChain <Pipeline, Stage>(parent.Context.InstancePipeline);
InstancePipeline.Invalidated += (s, e) => InstancePipelineCache = InstancePipeline.ToArray();
InstancePipelineCache = InstancePipeline.ToArray();
}
/// <summary>
/// Create a <see cref="Unity.UnityContainer"/> with the given parent container.
/// </summary>
/// <param name="parent">The parent <see cref="Unity.UnityContainer"/>. The current object
/// will apply its own settings first, and then check the parent for additional ones.</param>
private UnityContainer(UnityContainer parent)
{
// WithLifetime
LifetimeContainer = new LifetimeContainer(this);
// Context and policies
_context = new ContainerContext(this);
// Parent
_parent = parent ?? throw new ArgumentNullException(nameof(parent));
_parent.LifetimeContainer.Add(this);
_root = _parent._root;
SetDefaultPolicies = parent.SetDefaultPolicies;
// Methods
_get = _parent._get;
_getGenericRegistration = _parent._getGenericRegistration;
_isExplicitlyRegistered = _parent._isExplicitlyRegistered;
IsTypeExplicitlyRegistered = _parent.IsTypeExplicitlyRegistered;
GetRegistration = _parent.GetRegistration;
Register = CreateAndSetOrUpdate;
GetPolicy = parent.GetPolicy;
SetPolicy = CreateAndSetPolicy;
ClearPolicy = delegate { };
// Strategies
_strategies = _parent._strategies;
_strategiesChain = _parent._strategiesChain;
_strategies.Invalidated += OnStrategiesChanged;
// Caches
SetDefaultPolicies(this);
}
/// <summary>
/// Create a <see cref="Unity.UnityContainer"/> with the given parent container.
/// </summary>
/// <param name="parent">The parent <see cref="Unity.UnityContainer"/>. The current object
/// will apply its own settings first, and then check the parent for additional ones.</param>
private UnityContainer(UnityContainer parent)
{
// Parent
_parent = parent ?? throw new ArgumentNullException(nameof(parent));
_parent.LifetimeContainer.Add(this);
// Root of the hierarchy
_root = _parent._root;
// Lifetime
LifetimeContainer = new LifetimeContainer(this);
// Registry
Register = InitAndAdd;
/////////////////////////////////////////////////////////////
SetDefaultPolicies = parent.SetDefaultPolicies;
// Context and policies
_context = new ContainerContext(this);
// Strategies
_strategies = _parent._strategies;
_strategiesChain = _parent._strategiesChain;
_strategies.Invalidated += (s, e) => _strategiesChain = _strategies.ToArray();
// Caches
SetDefaultPolicies(this);
}
/// <summary>
/// Create a <see cref="Unity.UnityContainer"/> with the given parent container.
/// </summary>
/// <param name="parent">The parent <see cref="Unity.UnityContainer"/>. The current object
/// will apply its own settings first, and then check the parent for additional ones.</param>
private UnityContainer(UnityContainer parent)
{
// Parent
_parent = parent;
_parent?._lifetimeContainer.Add(this);
// Strategies
_strategies = new StagedStrategyChain <IBuilderStrategy, UnityBuildStage>(_parent?._strategies);
_buildPlanStrategies = new StagedStrategyChain <IBuilderStrategy, BuilderStage>(_parent?._buildPlanStrategies);
// Lifetime
_lifetimeContainer = new LifetimeContainer(this)
{
_strategies, _buildPlanStrategies
};
// Default Policies
if (null == _parent)
{
InitializeRootContainer();
}
_defaultPolicies = parent?._defaultPolicies ?? GetDefaultPolicies();
this[null, null] = _defaultPolicies;
// Context and policies
_extensions = new List <UnityContainerExtension>();
_context = new ContainerContext(this);
// Caches
OnStrategiesChanged(this, null);
_strategies.Invalidated += OnStrategiesChanged;
}
private MockBuilderContext GetContext()
{
StagedStrategyChain <BuilderStage> chain = new StagedStrategyChain <BuilderStage>();
chain.AddNew <DynamicMethodCallStrategy>(BuilderStage.Initialization);
DynamicMethodBuildPlanCreatorPolicy policy =
new DynamicMethodBuildPlanCreatorPolicy(chain);
MockBuilderContext context = new MockBuilderContext();
context.Strategies.Add(new LifetimeStrategy());
// Not used in Win8
//context.PersistentPolicies.SetDefault<IDynamicBuilderMethodCreatorPolicy>(
// DynamicBuilderMethodCreatorFactory.CreatePolicy());
context.PersistentPolicies.SetDefault <IConstructorSelectorPolicy>(
new ConstructorSelectorPolicy <InjectionConstructorAttribute>());
context.PersistentPolicies.SetDefault <IPropertySelectorPolicy>(
new PropertySelectorPolicy <DependencyAttribute>());
context.PersistentPolicies.SetDefault <IMethodSelectorPolicy>(
new MethodSelectorPolicy <InjectionMethodAttribute>());
context.PersistentPolicies.SetDefault <IBuildPlanCreatorPolicy>(policy);
return(context);
}
public static TestingBuilderContext GetFullContext()
{
TestingBuilderContext context = new TestingBuilderContext();
context.Strategies.Add(new BuildKeyMappingStrategy());
context.Strategies.Add(new LifetimeStrategy());
context.Strategies.Add(new BuildPlanStrategy());
StagedStrategyChain <BuilderStage> buildPlanChain =
new StagedStrategyChain <BuilderStage>();
buildPlanChain.AddNew <DynamicMethodConstructorStrategy>(BuilderStage.Creation);
buildPlanChain.AddNew <DynamicMethodPropertySetterStrategy>(BuilderStage.Initialization);
buildPlanChain.AddNew <DynamicMethodCallStrategy>(BuilderStage.Initialization);
DynamicMethodBuildPlanCreatorPolicy creatorPolicy =
new DynamicMethodBuildPlanCreatorPolicy(buildPlanChain);
context.PersistentPolicies.SetDefault <IDynamicBuilderMethodCreatorPolicy>(
new DefaultDynamicBuilderMethodCreatorPolicy());
context.PersistentPolicies.SetDefault <IBuildPlanCreatorPolicy>(creatorPolicy);
context.PersistentPolicies.SetDefault <IConstructorSelectorPolicy>(
new ConstructorSelectorPolicy <InjectionConstructorAttribute>());
context.PersistentPolicies.SetDefault <IPropertySelectorPolicy>(
new PropertySelectorPolicy <DependencyAttribute>());
context.PersistentPolicies.SetDefault <IMethodSelectorPolicy>(
new MethodSelectorPolicy <InjectionMethodAttribute>());
return(context);
}
/// <summary>
/// Create a default <see cref="UnityContainer"/>.
/// </summary>
public UnityContainer()
{
_root = this;
// WithLifetime
LifetimeContainer = new LifetimeContainer(this);
// Registrations
_registrations = new Registrations(ContainerInitialCapacity);
// Context
_context = new ContainerContext(this);
// Methods
_get = Get;
_getGenericRegistration = GetOrAddGeneric;
_isExplicitlyRegistered = IsExplicitlyRegisteredLocally;
IsTypeExplicitlyRegistered = IsTypeTypeExplicitlyRegisteredLocally;
GetRegistration = GetOrAdd;
Register = AddOrUpdate;
GetPolicy = Get;
SetPolicy = Set;
ClearPolicy = Clear;
// Build Strategies
_strategies = new StagedStrategyChain <BuilderStrategy, UnityBuildStage>
{
{ // Array
new ArrayResolveStrategy(
typeof(UnityContainer).GetTypeInfo().GetDeclaredMethod(nameof(ResolveArray)),
typeof(UnityContainer).GetTypeInfo().GetDeclaredMethod(nameof(ResolveGenericArray))),
UnityBuildStage.Enumerable
},
{ // Enumerable
new EnumerableResolveStrategy(
typeof(UnityContainer).GetTypeInfo().GetDeclaredMethod(nameof(ResolveEnumerable)),
typeof(UnityContainer).GetTypeInfo().GetDeclaredMethod(nameof(ResolveGenericEnumerable))),
UnityBuildStage.Enumerable
},
{ new BuildKeyMappingStrategy(), UnityBuildStage.TypeMapping }, // Mapping
{ new LifetimeStrategy(), UnityBuildStage.Lifetime }, // WithLifetime
{ new BuildPlanStrategy(), UnityBuildStage.Creation } // Build
};
// Update on change
_strategies.Invalidated += OnStrategiesChanged;
_strategiesChain = _strategies.ToArray();
// Default Policies and Strategies
SetDefaultPolicies(this);
Set(typeof(Func <>), All, typeof(LifetimeManager), new PerResolveLifetimeManager());
Set(typeof(Func <>), All, typeof(ResolveDelegateFactory), (ResolveDelegateFactory)DeferredFuncResolverFactory.DeferredResolveDelegateFactory);
Set(typeof(Lazy <>), All, typeof(ResolveDelegateFactory), (ResolveDelegateFactory)GenericLazyResolverFactory.GetResolver);
// Register this instance
((IUnityContainer)this).RegisterInstance(typeof(IUnityContainer), null, this, new ContainerLifetimeManager());
}
protected virtual IStrategyChain CreateStrategyChain()
{
StagedStrategyChain <BuilderStage> strategies = new StagedStrategyChain <BuilderStage>();
Strategies.ForEach(item => strategies.Add(CreateStrategy(item.Type), item.Stage));
return(strategies.MakeStrategyChain());
}
public void TestDeepProfilingExtensionWithEmptyFilter()
{
var strategies = new StagedStrategyChain<UnityBuildStage>();
var mockContext = new Mock<ExtensionContext>();
mockContext.Setup(c => c.Strategies).Returns(strategies);
var target = new DeepProfilingExtension(null);
target.InitializeExtension(mockContext.Object);
Assert.AreEqual(0, strategies.MakeStrategyChain().Count());
}
static EnterpriseLibraryFactory()
{
builder = new Builder();
StagedStrategyChain <BuilderStage> stagedStrategyChain = new StagedStrategyChain <BuilderStage>();
stagedStrategyChain.AddNew <ConfigurationNameMappingStrategy>(BuilderStage.PreCreation);
stagedStrategyChain.AddNew <LocatorLookupStrategy>(BuilderStage.PreCreation);
stagedStrategyChain.AddNew <ConfiguredObjectStrategy>(BuilderStage.PreCreation);
stagedStrategyChain.AddNew <InstrumentationStrategy>(BuilderStage.PostInitialization);
strategyChain = stagedStrategyChain.MakeStrategyChain();
}
private void InitializeBuilderState()
{
registeredNames = new NamedTypesRegistry(ParentNameRegistry);
extensions = new List <UnityContainerExtension>();
locator = new Locator(ParentLocator);
lifetimeContainer = new LifetimeContainer();
strategies = new StagedStrategyChain <UnityBuildStage>(ParentStrategies);
buildPlanStrategies = new StagedStrategyChain <UnityBuildStage>(ParentBuildPlanStrategies);
policies = new PolicyList(ParentPolicies);
}
public void SetUp()
{
baseStrategyChain = new StagedStrategyChain <BuilderStage>();
baseStrategyChain.AddNew <PolicyInjectionStrategy>(BuilderStage.PreCreation);
baseStrategyChain.AddNew <BuildKeyMappingStrategy>(BuilderStage.PreCreation);
baseStrategyChain.AddNew <BuildPlanStrategy>(BuilderStage.Creation);
buildPlanStrategyChain = new StagedStrategyChain <BuilderStage>();
buildPlanStrategyChain.AddNew <DynamicMethodConstructorStrategy>(BuilderStage.Creation);
buildPlanStrategyChain.AddNew <DynamicMethodPropertySetterStrategy>(BuilderStage.Initialization);
}
public void SetUp()
{
baseStrategyChain = new StagedStrategyChain<BuilderStage>();
baseStrategyChain.AddNew<PolicyInjectionStrategy>(BuilderStage.PreCreation);
baseStrategyChain.AddNew<BuildKeyMappingStrategy>(BuilderStage.PreCreation);
baseStrategyChain.AddNew<BuildPlanStrategy>(BuilderStage.Creation);
buildPlanStrategyChain = new StagedStrategyChain<BuilderStage>();
buildPlanStrategyChain.AddNew<DynamicMethodConstructorStrategy>(BuilderStage.Creation);
buildPlanStrategyChain.AddNew<DynamicMethodPropertySetterStrategy>(BuilderStage.Initialization);
}
public void InnerStrategiesComeBeforeOuterStrategiesInStrategyChain()
{
StagedStrategyChain<FakeStage> innerChain = new StagedStrategyChain<FakeStage>();
StagedStrategyChain<FakeStage> outerChain = new StagedStrategyChain<FakeStage>(innerChain);
FakeStrategy innerStrategy = new FakeStrategy();
FakeStrategy outerStrategy = new FakeStrategy();
innerChain.Add(innerStrategy, FakeStage.Stage1);
outerChain.Add(outerStrategy, FakeStage.Stage1);
IStrategyChain chain = outerChain.MakeStrategyChain();
AssertOrder(chain, innerStrategy, outerStrategy);
}
public void InnerStrategiesComeBeforeOuterStrategiesInStrategyChain()
{
StagedStrategyChain <FakeStage> innerChain = new StagedStrategyChain <FakeStage>();
StagedStrategyChain <FakeStage> outerChain = new StagedStrategyChain <FakeStage>(innerChain);
FakeStrategy innerStrategy = new FakeStrategy();
FakeStrategy outerStrategy = new FakeStrategy();
innerChain.Add(innerStrategy, FakeStage.Stage1);
outerChain.Add(outerStrategy, FakeStage.Stage1);
IStrategyChain chain = outerChain.MakeStrategyChain();
AssertOrder(chain, innerStrategy, outerStrategy);
}
private void InitializeBuilderState()
{
registeredNames = new NamedTypesRegistry(ParentNameRegistry);
extensions = new List <UnityContainerExtension>();
lifetimeContainer = new LifetimeContainer();
strategies = new StagedStrategyChain <UnityBuildStage>(ParentStrategies);
buildPlanStrategies = new StagedStrategyChain <UnityBuildStage>(ParentBuildPlanStrategies);
policies = new PolicyList(ParentPolicies);
policies.Set <IRegisteredNamesPolicy>(new RegisteredNamesPolicy(registeredNames), null);
cachedStrategies = null;
cachedStrategiesLock = new object();
}
public void InitializeAddsReleasingStrategyToContext()
{
// Fixture setup
var strategies = new StagedStrategyChain<UnityBuildStage>();
var contextStub = new Mock<ExtensionContext> { CallBase = true };
contextStub.SetupGet(ctx => ctx.Strategies).Returns(strategies);
var sut = new CacheLifetimeStrategyExtension();
// Exercise system
sut.InitializeExtension(contextStub.Object);
// Verify outcome
Assert.True(strategies.MakeStrategyChain().OfType<CacheReleasingLifetimeStrategy>().Any());
// Teardown
}
public void OrderingAcrossStagesForStrategyChain()
{
StagedStrategyChain<FakeStage> innerChain = new StagedStrategyChain<FakeStage>();
StagedStrategyChain<FakeStage> outerChain = new StagedStrategyChain<FakeStage>(innerChain);
FakeStrategy innerStage1 = new FakeStrategy();
FakeStrategy innerStage2 = new FakeStrategy();
FakeStrategy outerStage1 = new FakeStrategy();
FakeStrategy outerStage2 = new FakeStrategy();
innerChain.Add(innerStage1, FakeStage.Stage1);
innerChain.Add(innerStage2, FakeStage.Stage2);
outerChain.Add(outerStage1, FakeStage.Stage1);
outerChain.Add(outerStage2, FakeStage.Stage2);
IStrategyChain chain = outerChain.MakeStrategyChain();
AssertOrder(chain, innerStage1, outerStage1, innerStage2, outerStage2);
}
public void MultipleChildContainers()
{
StagedStrategyChain<FakeStage> innerChain = new StagedStrategyChain<FakeStage>();
StagedStrategyChain<FakeStage> outerChain = new StagedStrategyChain<FakeStage>(innerChain);
StagedStrategyChain<FakeStage> superChain = new StagedStrategyChain<FakeStage>(outerChain);
FakeStrategy innerStrategy = new FakeStrategy();
FakeStrategy outerStrategy = new FakeStrategy();
FakeStrategy superStrategy = new FakeStrategy();
innerChain.Add(innerStrategy, FakeStage.Stage1);
outerChain.Add(outerStrategy, FakeStage.Stage1);
superChain.Add(superStrategy, FakeStage.Stage1);
IStrategyChain chain = superChain.MakeStrategyChain();
AssertOrder(chain, innerStrategy, outerStrategy, superStrategy);
}
private static MockBuilderContext GetContext()
{
var chain = new StagedStrategyChain<BuilderStage>();
chain.AddNew<DynamicMethodConstructorStrategy>(BuilderStage.Creation);
var policy = new DynamicMethodBuildPlanCreatorPolicy(chain);
var context = new MockBuilderContext();
context.Strategies.Add(new LifetimeStrategy());
context.PersistentPolicies.SetDefault<IConstructorSelectorPolicy>(
new ConstructorSelectorPolicy<InjectionConstructorAttribute>());
context.PersistentPolicies.SetDefault<IBuildPlanCreatorPolicy>(policy);
return context;
}
DependencyContainer(IReadableLocator innerLocator,
IPolicyList innerPolicies,
StagedStrategyChain <BuilderStage> innerStrategies,
IDependencyContainerConfigurator configurator)
{
locator = new Locator(innerLocator);
policies = new PolicyList(innerPolicies);
strategies = new StagedStrategyChain <BuilderStage>(innerStrategies);
RegisterSingletonInstance <IObjectFactory>(this);
if (innerStrategies == null)
{
strategies.AddNew <BuildKeyMappingStrategy>(BuilderStage.PreCreation);
strategies.AddNew <SingletonStrategy>(BuilderStage.PreCreation);
strategies.AddNew <ConstructorReflectionStrategy>(BuilderStage.PreCreation);
strategies.AddNew <MethodReflectionStrategy>(BuilderStage.PreCreation);
strategies.AddNew <PropertyReflectionStrategy>(BuilderStage.PreCreation);
strategies.AddNew <EventBrokerReflectionStrategy>(BuilderStage.PreCreation);
strategies.AddNew <InterceptionReflectionStrategy>(BuilderStage.PreCreation);
strategies.AddNew <InterfaceInterceptionStrategy>(BuilderStage.Creation);
strategies.AddNew <VirtualInterceptionStrategy>(BuilderStage.Creation);
strategies.AddNew <CreationStrategy>(BuilderStage.Creation);
strategies.AddNew <PropertySetterStrategy>(BuilderStage.Initialization);
strategies.AddNew <MethodCallStrategy>(BuilderStage.Initialization);
strategies.AddNew <EventBrokerStrategy>(BuilderStage.Initialization);
strategies.AddNew <BuilderAwareStrategy>(BuilderStage.PostInitialization);
strategies.AddNew <RemotingInterceptionStrategy>(BuilderStage.PostInitialization);
}
if (innerPolicies == null)
{
policies.SetDefault <ICreationPolicy>(new DefaultCreationPolicy());
}
locator.Add(typeof(EventBrokerService), new EventBrokerService());
if (configurator != null)
{
configurator.Configure(this);
}
}
public void OrderingAcrossStagesForStrategyChain()
{
StagedStrategyChain <FakeStage> innerChain = new StagedStrategyChain <FakeStage>();
StagedStrategyChain <FakeStage> outerChain = new StagedStrategyChain <FakeStage>(innerChain);
FakeStrategy innerStage1 = new FakeStrategy();
FakeStrategy innerStage2 = new FakeStrategy();
FakeStrategy outerStage1 = new FakeStrategy();
FakeStrategy outerStage2 = new FakeStrategy();
innerChain.Add(innerStage1, FakeStage.Stage1);
innerChain.Add(innerStage2, FakeStage.Stage2);
outerChain.Add(outerStage1, FakeStage.Stage1);
outerChain.Add(outerStage2, FakeStage.Stage2);
IStrategyChain chain = outerChain.MakeStrategyChain();
AssertOrder(chain, innerStage1, outerStage1, innerStage2, outerStage2);
}
public void MultipleChildContainers()
{
StagedStrategyChain <FakeStage> innerChain = new StagedStrategyChain <FakeStage>();
StagedStrategyChain <FakeStage> outerChain = new StagedStrategyChain <FakeStage>(innerChain);
StagedStrategyChain <FakeStage> superChain = new StagedStrategyChain <FakeStage>(outerChain);
FakeStrategy innerStrategy = new FakeStrategy();
FakeStrategy outerStrategy = new FakeStrategy();
FakeStrategy superStrategy = new FakeStrategy();
innerChain.Add(innerStrategy, FakeStage.Stage1);
outerChain.Add(outerStrategy, FakeStage.Stage1);
superChain.Add(superStrategy, FakeStage.Stage1);
IStrategyChain chain = superChain.MakeStrategyChain();
AssertOrder(chain, innerStrategy, outerStrategy, superStrategy);
}
private static MockBuilderContext GetContext()
{
var chain = new StagedStrategyChain <IBuilderStrategy, BuilderStage>();
chain.Add(new DynamicMethodConstructorStrategy(), BuilderStage.Creation);
var policy = new DynamicMethodBuildPlanCreatorPolicy(chain);
var context = new MockBuilderContext();
context.Strategies.Add(new LifetimeStrategy());
context.PersistentPolicies.SetDefault <IConstructorSelectorPolicy>(
new ConstructorSelectorPolicy <InjectionConstructorAttribute>());
context.PersistentPolicies.SetDefault <IBuildPlanCreatorPolicy>(policy);
return(context);
}
public void InitializeAddsReleasingStrategyToContext()
{
// Fixture setup
var strategies = new StagedStrategyChain <UnityBuildStage>();
var contextStub = new Mock <ExtensionContext> {
CallBase = true
};
contextStub.SetupGet(ctx => ctx.Strategies).Returns(strategies);
var sut = new CacheLifetimeStrategyExtension();
// Exercise system
sut.InitializeExtension(contextStub.Object);
// Verify outcome
Assert.True(strategies.MakeStrategyChain().OfType <CacheReleasingLifetimeStrategy>().Any());
// Teardown
}
/// <summary>
/// Create a <see cref="Unity.UnityContainer"/> with the given parent container.
/// </summary>
/// <param name="parent">The parent <see cref="Unity.UnityContainer"/>. The current object
/// will apply its own settings first, and then check the parent for additional ones.</param>
private UnityContainer(UnityContainer parent)
{
_parent = parent;
_parent?._lifetimeContainer.Add(this);
_context = new ContainerContext(this);
_extensions = new List<UnityContainerExtension>();
_strategies = new StagedStrategyChain<IBuilderStrategy, UnityBuildStage>(_parent?._strategies);
_buildPlanStrategies = new StagedStrategyChain<IBuilderStrategy, BuilderStage>(_parent?._buildPlanStrategies);
_lifetimeContainer = new LifetimeContainer { _strategies, _buildPlanStrategies };
if (null == _parent)
InitializeStrategies();
else
this[null, null] = _parent[null, null];
RegisterInstance(typeof(IUnityContainer), null, this, new ContainerLifetimeManager());
}
private TestingBuilderContext GetContext()
{
StagedStrategyChain <BuilderStage> chain = new StagedStrategyChain <BuilderStage>();
chain.AddNew <DynamicMethodConstructorStrategy>(BuilderStage.Creation);
DynamicMethodBuildPlanCreatorPolicy policy =
new DynamicMethodBuildPlanCreatorPolicy(chain);
TestingBuilderContext context = new TestingBuilderContext();
context.Strategies.Add(new SingletonStrategy());
context.PersistentPolicies.SetDefault <IConstructorSelectorPolicy>(
new ConstructorSelectorPolicy <InjectionConstructorAttribute>());
context.PersistentPolicies.SetDefault <IBuildPlanCreatorPolicy>(policy);
return(context);
}
private MockBuilderContext GetContext()
{
StagedStrategyChain <BuilderStage> chain = new StagedStrategyChain <BuilderStage>();
chain.AddNew <DynamicMethodPropertySetterStrategy>(BuilderStage.Initialization);
DynamicMethodBuildPlanCreatorPolicy policy =
new DynamicMethodBuildPlanCreatorPolicy(chain);
MockBuilderContext context = new MockBuilderContext();
context.Strategies.Add(new LifetimeStrategy());
context.Policies.SetDefault <IConstructorSelectorPolicy>(
new ConstructorSelectorPolicy <InjectionConstructorAttribute>());
context.Policies.SetDefault <IPropertySelectorPolicy>(
new PropertySelectorPolicy <DependencyAttribute>());
context.Policies.SetDefault <IBuildPlanCreatorPolicy>(policy);
return(context);
}
private MockBuilderContext GetContext()
{
StagedStrategyChain <BuilderStage> chain = new StagedStrategyChain <BuilderStage>();
chain.AddNew <DynamicMethodConstructorStrategy>(BuilderStage.Creation);
DynamicMethodBuildPlanCreatorPolicy policy =
new DynamicMethodBuildPlanCreatorPolicy(chain);
MockBuilderContext context = new MockBuilderContext();
context.Strategies.Add(new LifetimeStrategy());
context.PersistentPolicies.SetDefault <IConstructorSelectorPolicy>(
new ConstructorSelectorPolicy <InjectionConstructorAttribute>());
context.PersistentPolicies.SetDefault <IDynamicBuilderMethodCreatorPolicy>(
DynamicBuilderMethodCreatorFactory.CreatePolicy());
context.PersistentPolicies.SetDefault <IBuildPlanCreatorPolicy>(policy);
return(context);
}
public void MultipleChildContainers()
{
StagedStrategyChain <BuilderStrategy, FakeStage> innerChain = new StagedStrategyChain <BuilderStrategy, FakeStage>();
StagedStrategyChain <BuilderStrategy, FakeStage> outerChain = new StagedStrategyChain <BuilderStrategy, FakeStage>(innerChain);
StagedStrategyChain <BuilderStrategy, FakeStage> superChain = new StagedStrategyChain <BuilderStrategy, FakeStage>(outerChain);
FakeStrategy innerStrategy = new FakeStrategy {
Name = "innerStrategy"
};
FakeStrategy outerStrategy = new FakeStrategy {
Name = "outerStrategy"
};
FakeStrategy superStrategy = new FakeStrategy {
Name = "superStrategy"
};
innerChain.Add(innerStrategy, FakeStage.Stage1);
outerChain.Add(outerStrategy, FakeStage.Stage1);
superChain.Add(superStrategy, FakeStage.Stage1);
var chain = superChain.ToArray();
AssertOrder(chain, innerStrategy, outerStrategy, superStrategy);
}
private void InitializeBuilderState()
{
registeredNames = new NamedTypesRegistry(ParentNameRegistry);
extensions = new List<UnityContainerExtension>();
locator = new Locator(ParentLocator);
lifetimeContainer = new LifetimeContainer();
strategies = new StagedStrategyChain<UnityBuildStage>(ParentStrategies);
buildPlanStrategies = new StagedStrategyChain<UnityBuildStage>(ParentBuildPlanStrategies);
policies = new PolicyList(ParentPolicies);
cachedStrategies = null;
cachedStrategiesLock = new object();
}
