public override void PreBuildUp(IBuilderContext context)
{
NamedTypeBuildKey key = context.OriginalBuildKey;
if (!(key.Type.IsInterface && _typeStacks.ContainsKey(key.Type)))
{
return;
}
if (null != context.GetOverriddenResolver(key.Type))
{
return;
}
var stack = new Stack<Type>(_typeStacks[key.Type]);
object value = null;
stack.ForEach(type =>
{
value = context.NewBuildUp(new NamedTypeBuildKey(type, key.Name));
var overrides = new DependencyOverride(key.Type, value);
context.AddResolverOverrides(overrides);
}
);
context.Existing = value;
context.BuildComplete = true;
}
public IFactDependencyProcessor Create(IFactDependencyFeature metadata)
{
var processorType = typeof(FactDependencyProcessor<>).MakeGenericType(metadata.DependancyType);
var metadataDependency = new DependencyOverride(typeof(IFactDependencyFeature<>).MakeGenericType(metadata.DependancyType), metadata);
var processor = _unityContainer.Resolve(processorType, metadataDependency);
return (IFactDependencyProcessor)processor;
}
/// <summary>
/// Registers types into the Unity container.
/// </summary>
/// <param name="types">The array of interfaces and concretes to map up and register.</param>
/// <param name="behaviors">The behaviors to use to guide auto-mapping.</param>
public IEnumerable<ContainerRegistration> RegisterTypes(MappingBehaviors behaviors, params Type[] types)
{
var configurationDetails = GetConfigurationDetails(types);
var mappings = mappingFactory.CreateMappings(behaviors, configurationDetails, types);
var configParameter = new DependencyOverride<AutomapperConfig>(configurationDetails);
var mappingParameter = new DependencyOverride<IEnumerable<TypeMapping>>(mappings);
var behaviorParameter = new DependencyOverride<MappingBehaviors>(behaviors);
var containerParameter = new DependencyOverride<IUnityContainer>(target);
var mappingHandler = internalContainer.Resolve<ITypeMappingHandler>(configParameter, mappingParameter, behaviorParameter, containerParameter);
return mappingHandler.PerformRegistrations(target, mappings);
}
public void WhenOverridingMultipleDependencies()
{
IUnityContainer container = new UnityContainer();
container.RegisterType<Type4DependingOnOtherType>().RegisterType<IToWhichDependent, Type1ToWhichDependent>(new InjectionConstructor(111)).RegisterType<Dependent>(new InjectionProperty("X", 111));
Dependent overrideDependent1 = new Dependent();
overrideDependent1.X = 9999;
IToWhichDependent overrideDependent2 = new Type2ToWhichDependent(8888);
DependencyOverride<Dependent> overrideParam1 = new DependencyOverride<Dependent>(overrideDependent1);
DependencyOverride<IToWhichDependent> overrideParam2 = new DependencyOverride<IToWhichDependent>(overrideDependent2);
var result = container.Resolve<Type4DependingOnOtherType>(overrideParam1, overrideParam2);
Assert.IsInstanceOfType(result.IToWhichDependent, typeof(Type2ToWhichDependent));
Assert.IsInstanceOfType(result.OneMoreIToWhichDependent, typeof(Type2ToWhichDependent));
Assert.AreEqual<int>(8888, result.IToWhichDependent.X);
Assert.AreEqual<int>(8888, result.OneMoreIToWhichDependent.X);
Assert.AreEqual<int>(9999, result.NewToWhichDependent.X);
}
public void DependencyOverrideValueInConfigFileDoesNotPersistAcrossCalls()
{
IToWhichDependent overrideDependency = new Type2ToWhichDependent(9999);
DependencyOverride<IToWhichDependent> overrideParam = new DependencyOverride<IToWhichDependent>(overrideDependency);
IUnityContainer container = GetContainer("DependencyOverrideContainer");
var result = container.Resolve<Type3DependingOnOtherType>("TestDependencyOverrideDefaultInConfiguration", overrideParam);
var defaultResult = container.Resolve<Type3DependingOnOtherType>("TestDependencyOverrideDefaultInConfiguration");
Assert.IsInstanceOfType(result.IToWhichDependent, typeof(Type2ToWhichDependent));
Assert.IsInstanceOfType(result.OneMoreIToWhichDependent, typeof(Type2ToWhichDependent));
Assert.AreEqual<int>(9999, result.OneMoreIToWhichDependent.X);
Assert.AreEqual<int>(9999, result.IToWhichDependent.X);
Assert.IsInstanceOfType(defaultResult.IToWhichDependent, typeof(Type1ToWhichDependent));
Assert.IsInstanceOfType(defaultResult.OneMoreIToWhichDependent, typeof(Type1ToWhichDependent));
Assert.AreEqual<int>(-111, defaultResult.OneMoreIToWhichDependent.X);
Assert.AreEqual<int>(-111, defaultResult.IToWhichDependent.X);
}
