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