public override void PreBuildUp(IBuilderContext context)
{
var key = context.OriginalBuildKey;
if (!key.Type.IsInterface || context.GetOverriddenResolver(key.Type) != null)
{
return;
}
Stack <Type> stack;
if (!_stackDictionary.TryGetValue(key.Type, out stack))
{
return;
}
object value = null;
foreach (var t in stack)
{
value = context.NewBuildUp(new NamedTypeBuildKey(t, key.Name));
var overrides = new DependencyOverride(key.Type, value);
context.AddResolverOverrides(overrides);
}
context.Existing = value;
context.BuildComplete = true;
}
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 override void PreBuildUp(IBuilderContext context)
{
var key = context.OriginalBuildKey;
if (!(key.Type.IsInterface &&
_typeStacks.ContainsKey(key.Type)) ||
context.GetOverriddenResolver(key.Type) != null)
{
return;
}
var stack = _typeStacks[key.Type];
object value = null;
while (stack.Count != 0)
{
var t = stack.Dequeue();
value = context.NewBuildUp(t, key.Name);
var overrides = new DependencyOverride(
key.Type, value);
context.AddResolverOverrides(overrides);
}
context.Existing = value;
context.BuildComplete = true;
}
public async Task StartActivityAsync(Type activityInfoType, ActivityInfo activityInfo)
{
var activityType = GetActivityType(activityInfoType);
var activityInfoOverride = new DependencyOverride(activityInfoType, new InjectionParameter(activityInfo));
var activity = (IActivity)container.Resolve(activityType, activityInfoOverride);
await activity.StartAsync();
}
private DependencyOverride ResolveValueObjectFindSpecificationProvider(IValueObjectMetadata metadata)
{
var metadatOverride = new DependencyOverride(metadata.GetType(), metadata);
return(new DependencyOverride(
typeof(IFindSpecificationProvider <,>).MakeGenericType(metadata.ValueObjectType, typeof(AggregateOperation)),
_unityContainer.Resolve(typeof(ValueObjectFindSpecificationProvider <,>).MakeGenericType(metadata.ValueObjectType, metadata.EntityKeyType), metadatOverride)));
}
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);
}
private DependencyOverride ResolveAggregateFindSpecificationProvider(IMetadataElement metadata)
{
var aggregateType = metadata.GetType().GenericTypeArguments[0];
var aggregateKeyType = metadata.GetType().GenericTypeArguments[1];
var metadataOverride = new DependencyOverride(metadata.GetType(), metadata);
return(new DependencyOverride(
typeof(IFindSpecificationProvider <,>).MakeGenericType(aggregateType, typeof(AggregateOperation)),
_unityContainer.Resolve(typeof(AggregateFindSpecificationProvider <,>).MakeGenericType(aggregateType, aggregateKeyType), metadataOverride)));
}
public T Resolve <T>(ContainerDependencyOverride dependencyOverride)
{
if (dependencyOverride == null)
{
throw new ArgumentNullException(nameof(dependencyOverride));
}
var overrider = new DependencyOverride(dependencyOverride.Type, dependencyOverride.Instance);
return(_container.Resolve <T>(overrider));
}
/// <summary>
/// Gets an instance of the requested repository type
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
protected T GetRepository <T>() where T : IRepository
{
IRepository repository = dependencyResolver.Resolve <T>(
DependencyOverride.CreateNew <DbContext>(dbContext),
DependencyOverride.CreateNew <IDataMapper>(DataMapper));
((IDataInteractions)repository).OnDataChange += OnDataChangeHandler;
return((T)repository);
}
public AccountManager(
IAccountContext accountContext, ICryptoProvider cryptoProvider,
ISystemContext systemContext, IDependencyResolver dependencyResolver)
{
this.accountContext = accountContext;
this.cryptoProvider = cryptoProvider;
this.systemContext = systemContext;
this.dependencyResolver = dependencyResolver;
//This resolved instance is delayed until here because we want to make sure the user validator also uses the same DB Access instances
this.userValidator = dependencyResolver.Resolve <IUserValidator>(DependencyOverride.CreateNew <IUsersRepository>(accountContext.Users));
}
public void DirectUseOfDependencyOverride()
{
// arrange
var target = new Composition.CompositionRoot();
var resolvedParameter = new ResolvedParameter <IDrillBit>(CompositionRoot.SecondDrill);
var dependencyOverride = new DependencyOverride <IDrillBit>(resolvedParameter);
// act
var actual = target.Container.Resolve <ILayer>(dependencyOverride);
// assert
Assert.IsNotNull(actual);
}
public T Resolve <T>(params InjectedParam[] args)
{
List <ResolverOverride> overrides = new List <ResolverOverride>();
foreach (var arg in args)
{
var typeToConstruct = arg.TypeOfParam;
var dependencyOverride = new DependencyOverride(typeToConstruct, arg.Value);
overrides.Add(dependencyOverride);
}
return(_container.Resolve <T>(overrides.ToArray()));
}
public void ShouldResolveAlternativeImplementationWhenUsingOverride()
{
// arrange
var target = new Composition.CompositionRoot();
var resolvedParameter = new ResolvedParameter <IMessageProvider>(nameof(AlternativeMessageProvider));
var dependencyOverride = new DependencyOverride <IMessageProvider>(resolvedParameter);
// act
var actual = target.Container.Resolve <IController>(dependencyOverride);
// assert
Assert.AreEqual(actual.GetMessage(), "Goodbye cruel world!");
}
/// <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 DependencyOverrideValueInConfigFile()
{
IToWhichDependent overrideDependency = new Type2ToWhichDependent(9999);
DependencyOverride <IToWhichDependent> overrideParam = new DependencyOverride <IToWhichDependent>(overrideDependency);
IUnityContainer container = GetContainer("DependencyOverrideContainer");
var result = container.Resolve <Type3DependingOnOtherType>("TestDependencyOverrideDefaultInConfiguration", overrideParam);
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);
}
public IFactDependencyProcessor Create(IFactDependencyFeature metadata)
{
Type processorType;
if (!KnownFeatureProcessors.TryGetValue(metadata.GetType().GetGenericTypeDefinition(), out processorType))
{
throw new ArgumentException($"Feature of type {metadata.GetType().Name} has no known processor", nameof(metadata));
}
processorType = processorType.MakeGenericType(metadata.GetType().GetGenericArguments());
var metadataOverride = new DependencyOverride(metadata.GetType(), metadata);
var processor = _unityContainer.Resolve(processorType, metadataOverride);
return((IFactDependencyProcessor)processor);
}
public void DependencyLegacy()
{
// arrange
Container.RegisterType <IController, TheController>()
.RegisterType <IMessageProvider, DefaultMessageProvider>()
.RegisterType <IMessageProvider, AlternativeMessageProvider>(nameof(AlternativeMessageProvider));
var resolvedParameter = new ResolvedParameter <IMessageProvider>(nameof(AlternativeMessageProvider));
var dependencyOverride = new DependencyOverride <IMessageProvider>(resolvedParameter);
// act
var actual = Container.Resolve <IController>(dependencyOverride);
// assert
Assert.AreEqual(actual.GetMessage(), "Goodbye cruel world!");
}
public Consumer(string runtimeChoice)
{
DependencyOverride <IDatabase> dependency = null;
if (runtimeChoice == "SQLSERVER")
{
dependency = new DependencyOverride <IDatabase>
(Container.Resolve <IDatabase>("SQLDatabase"));
}
else if (runtimeChoice == "Oracle")
{
dependency = new DependencyOverride <IDatabase>
(Container.Resolve <IDatabase>("OracleDatabase"));
}
dataService = _container.Resolve <IDataService>(dependency);
}
public override void PreBuildUp(ref BuilderContext context)
{
// Get the type that is to be constructed
var typeToBuild = GetTypeToBuild(context);
if (!IsBuildingLayer(typeToBuild))
{
return;
}
if (IsThereAnotherLayerInHierarchy(context))
{
var resolvedParameter = new ResolvedParameter <IDrillBit>(CompositionRoot.SecondDrill);
var dependencyOverride = new DependencyOverride <IDrillBit>(resolvedParameter);
AddResolverOverrides(ref context, dependencyOverride);
}
}
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);
}