private IEnumerable <Expression> FillMembersExpression(
IContainerContext containerContext,
MemberInformation[] injectionMembers,
RegistrationContextData registrationContext,
ResolutionContext resolutionContext,
Expression instance)
{
var length = injectionMembers.Length;
var expressions = new List <Expression>();
for (var i = 0; i < length; i++)
{
var member = injectionMembers[i];
if (!member.CanInject(containerContext.ContainerConfigurator.ContainerConfiguration,
registrationContext))
{
continue;
}
var expression = containerContext.ResolutionStrategy
.BuildResolutionExpression(containerContext, resolutionContext,
member.TypeInformation, registrationContext.InjectionParameters);
if (expression == null)
{
continue;
}
expressions.Add(instance.Member(member.MemberInfo).AssignTo(expression));
}
return(expressions);
}
private IList <MemberBinding> GetMemberBindings(IContainerContext containerContext, IServiceRegistration serviceRegistration, ResolutionContext resolutionContext)
{
var length = serviceRegistration.MetaInformation.InjectionMembers.Length;
var members = new List <MemberBinding>();
for (var i = 0; i < length; i++)
{
var info = serviceRegistration.MetaInformation.InjectionMembers[i];
if (!serviceRegistration.CanInjectMember(info))
{
continue;
}
var expression = containerContext.ResolutionStrategy
.BuildResolutionExpression(containerContext, resolutionContext, info.TypeInformation, serviceRegistration.RegistrationContext.InjectionParameters);
if (expression == null)
{
continue;
}
members.Add(info.MemberInfo.AssignTo(expression));
}
return(members);
}
/// <inheritdoc />
public override Expression GetExpression(IContainerContext containerContext, IServiceRegistration serviceRegistration, IObjectBuilder objectBuilder, ResolutionContext resolutionContext, Type resolveType)
{
if (this.expression != null)
{
return(this.expression);
}
lock (this.syncObject)
{
if (this.expression != null)
{
return(this.expression);
}
var expr = base.GetExpression(containerContext, serviceRegistration, objectBuilder, resolutionContext, resolveType);
if (expr == null)
{
return(null);
}
object instance;
if (expr.NodeType == ExpressionType.New && ((NewExpression)expr).Arguments.Count == 0)
{
instance = Activator.CreateInstance(expr.Type);
}
else
{
instance = expr.CompileDelegate(resolutionContext)(resolutionContext.RootScope);
}
this.expression = instance.AsConstant();
}
return(this.expression);
}
private static Expression CreateLazyExpressionCall(IContainerContext containerContext, IServiceRegistration serviceRegistration, Type type, ConstructorInfo constructor, ResolutionContext resolutionContext)
{
var arguments = resolutionContext.ParameterExpressions != null
? new Expression[resolutionContext.ParameterExpressions.Sum(x => x.Length)]
: new Expression[0];
if (resolutionContext.ParameterExpressions != null)
{
var index = 0;
for (var i = 0; i < resolutionContext.ParameterExpressions.Length; i++)
{
for (var j = 0; j < resolutionContext.ParameterExpressions[i].Length; j++)
{
arguments[index++] = resolutionContext.ParameterExpressions[i][j].ConvertTo(typeof(object));
}
}
}
var callExpression = DelegateCacheMethod.CallStaticMethod(
containerContext.AsConstant(),
serviceRegistration.AsConstant(),
resolutionContext.AsConstant(),
type.AsConstant(),
typeof(object).InitNewArray(arguments));
return(constructor.MakeNew(callExpression.ConvertTo(type).AsLambda()));
}
private Expression HandleDisposalAndGetExpression(IContainerContext containerContext, IServiceRegistration serviceRegistration,
ResolutionContext resolutionContext, Type resolveType)
{
var expr = this.GetExpressionInternal(containerContext, serviceRegistration, resolutionContext, resolveType);
if (expr == null)
{
return(null);
}
if (!this.HandlesObjectLifecycle && serviceRegistration.RegistrationContext.Finalizer != null)
{
expr = this.HandleFinalizer(expr, serviceRegistration, resolutionContext.CurrentScopeParameter);
}
if (!serviceRegistration.ShouldHandleDisposal || this.HandlesObjectLifecycle || !expr.Type.IsDisposable())
{
return(this.CheckRuntimeCircularDependenciesIfNeeded(expr, containerContext, serviceRegistration, resolutionContext, resolveType));
}
var method = Constants.AddDisposalMethod.MakeGenericMethod(expr.Type);
return(this.CheckRuntimeCircularDependenciesIfNeeded(resolutionContext.CurrentScopeParameter.CallMethod(method, expr),
containerContext, serviceRegistration, resolutionContext, resolveType));
}
private bool TryBuildResolutionConstructor(
ConstructorInformation constructor,
ResolutionContext resolutionContext,
IContainerContext containerContext,
IServiceRegistration serviceRegistration,
out TypeInformation failedParameter,
out Expression[] parameterExpressions,
bool skipUknownResolution = false)
{
var paramLength = constructor.Parameters.Length;
parameterExpressions = new Expression[paramLength];
failedParameter = null;
for (var i = 0; i < paramLength; i++)
{
var parameter = constructor.Parameters[i];
parameterExpressions[i] = containerContext.ResolutionStrategy.BuildResolutionExpression(containerContext, resolutionContext,
parameter, serviceRegistration.RegistrationContext.InjectionParameters, skipUknownResolution);
if (parameterExpressions[i] == null)
{
failedParameter = parameter;
return(false);
}
}
return(true);
}
private static object CreateLazyDelegate(IContainerContext containerContext, IServiceRegistration serviceRegistration, ResolutionContext resolutionContext, Type type, object[] arguments)
{
var expr = serviceRegistration.GetExpression(containerContext, resolutionContext, type);
return(expr.AsLambda(resolutionContext.ParameterExpressions.SelectMany(x => x))
.CompileDynamicDelegate(resolutionContext)(resolutionContext.ResolutionScope).DynamicInvoke(arguments));
}
public void RegisterType(IContainerContext context, Type registeredType, string name, Type mappedTo,
LifetimeManager lifetimeManager, params InjectionMember[] injectionMembers)
{
// Validate imput
if (mappedTo == null || registeredType == mappedTo)
{
return;
}
// Set mapping policy
var policy = registeredType.GetTypeInfo().IsGenericTypeDefinition&& mappedTo.GetTypeInfo().IsGenericTypeDefinition
? new GenericTypeBuildKeyMappingPolicy(mappedTo, name)
: (IBuildKeyMappingPolicy) new BuildKeyMappingPolicy(mappedTo, name);
context.Policies.Set(registeredType, name, typeof(IBuildKeyMappingPolicy), policy);
// Require Re-Resolve if no injectors specified
var members = null == injectionMembers ? new InjectionMember[0] : injectionMembers;
var overrides = members.Where(m => m is InjectionConstructor || m is InjectionMethod || m is InjectionProperty).Any();
if (lifetimeManager is IRequireBuildUpPolicy || overrides)
{
return;
}
context.Policies.Set(registeredType, name, typeof(IBuildPlanPolicy), new ResolveBuildUpPolicy());
}
private ResolutionScope(IResolverSelector resolverSelector, IServiceRegistrator serviceRegistrator, IExpressionBuilder expressionBuilder,
IContainerContext containerContext, IResolutionScope rootScope, IResolutionScope parent, DelegateCache delegateCache, object name = null)
: this(resolverSelector, serviceRegistrator, expressionBuilder, containerContext, delegateCache, name)
{
this.RootScope = rootScope;
this.ParentScope = parent;
}
internal ResolutionScope(IResolverSelector resolverSelector, IServiceRegistrator serviceRegistrator,
IExpressionBuilder expressionBuilder, IContainerContext containerContext)
: this(resolverSelector, serviceRegistrator, expressionBuilder, containerContext,
new DelegateCache(), null)
{
this.RootScope = this;
}
public Expression BuildResolutionExpression(IContainerContext containerContext, ResolutionInfo resolutionInfo, TypeInformation typeInformation,
InjectionParameter[] injectionParameters)
{
if (typeInformation.Type == Constants.ResolverType)
{
return(Expression.Convert(Constants.ScopeExpression, Constants.ResolverType));
}
if (resolutionInfo.ParameterExpressions != null && resolutionInfo.ParameterExpressions.Any(p => p.Type == typeInformation.Type || p.Type.Implements(typeInformation.Type)))
{
return(resolutionInfo.ParameterExpressions.Last(p => p.Type == typeInformation.Type || p.Type.Implements(typeInformation.Type)));
}
var matchingParam = injectionParameters?.FirstOrDefault(param => param.Name == typeInformation.ParameterName);
if (matchingParam != null)
{
return(Expression.Constant(matchingParam.Value));
}
var exprOverride = resolutionInfo.GetExpressionOverrideOrDefault(typeInformation.Type);
if (exprOverride != null)
{
return(exprOverride);
}
var registration = containerContext.RegistrationRepository.GetRegistrationOrDefault(typeInformation, true);
return(registration != null?registration.GetExpression(resolutionInfo, typeInformation.Type) :
this.resolverSelector.GetResolverExpression(containerContext, typeInformation, resolutionInfo));
}
internal ServiceRegistrator(IContainerContext containerContext, IContainerExtensionManager containerExtensionManager,
IObjectBuilderSelector objectBuilderSelector)
{
this.containerContext = containerContext;
this.containerExtensionManager = containerExtensionManager;
this.objectBuilderSelector = objectBuilderSelector;
}
private IList <MemberBinding> GetMemberBindings(
IContainerContext containerContext,
MemberInformation[] injectionMembers,
RegistrationContextData registrationContext,
ResolutionContext resolutionContext)
{
var length = injectionMembers.Length;
var members = new List <MemberBinding>();
for (var i = 0; i < length; i++)
{
var info = injectionMembers[i];
if (!info.CanInject(containerContext.ContainerConfigurator.ContainerConfiguration,
registrationContext))
{
continue;
}
var expression = containerContext.ResolutionStrategy
.BuildResolutionExpression(containerContext, resolutionContext,
info.TypeInformation, registrationContext.InjectionParameters);
if (expression == null)
{
continue;
}
members.Add(info.MemberInfo.AssignTo(expression));
}
return(members);
}
private void CreateMethodExpressions(
IContainerContext containerContext,
MethodInformation[] injectionMethods,
RegistrationContextData registrationContext,
ResolutionContext resolutionContext,
Expression newExpression,
Expression[] buffer)
{
var length = injectionMethods.Length;
for (var i = 0; i < length; i++)
{
var info = injectionMethods[i];
var paramLength = info.Parameters.Length;
if (paramLength == 0)
{
buffer[i] = newExpression.CallMethod(info.Method);
}
else
{
var parameters = new Expression[paramLength];
for (var j = 0; j < paramLength; j++)
{
parameters[j] = containerContext.ResolutionStrategy
.BuildResolutionExpression(containerContext, resolutionContext,
info.Parameters[j], registrationContext.InjectionParameters);
}
buffer[i] = newExpression.CallMethod(info.Method, parameters);
}
}
}
private Expression CreateInitExpression(
IContainerContext containerContext,
IServiceRegistration serviceRegistration,
ResolutionContext resolutionContext)
{
if (serviceRegistration.SelectedConstructor != null)
{
if (serviceRegistration.RegistrationContext.ConstructorArguments != null)
{
return(serviceRegistration.SelectedConstructor.Constructor
.MakeNew(serviceRegistration.RegistrationContext.ConstructorArguments.Select(Expression.Constant)));
}
return(this.constructorSelector.CreateResolutionConstructor(containerContext, serviceRegistration,
resolutionContext, serviceRegistration.SelectedConstructor)
.MakeNew());
}
var rule = serviceRegistration.RegistrationContext.ConstructorSelectionRule ??
containerContext.ContainerConfigurator.ContainerConfiguration.ConstructorSelectionRule;
var constructors = rule(serviceRegistration.Constructors).ToArray();
return(this.constructorSelector.SelectConstructor(serviceRegistration.ImplementationType,
containerContext, resolutionContext, constructors,
serviceRegistration.RegistrationContext.InjectionParameters)?.MakeNew());
}
public Expression CreateFillExpression(
IContainerContext containerContext,
IServiceRegistration serviceRegistration,
Expression instance,
ResolutionContext resolutionContext,
Type serviceType)
{
var lines = new List <Expression>();
if (instance.Type != serviceType)
{
instance = instance.ConvertTo(serviceType);
}
var variable = serviceType.AsVariable();
var assign = variable.AssignTo(instance);
lines.Add(assign);
if (serviceRegistration.InjectionMembers.Length > 0)
{
lines.AddRange(this.FillMembersExpression(containerContext, serviceRegistration.InjectionMembers,
serviceRegistration.RegistrationContext, resolutionContext, variable));
}
if (serviceRegistration.InjectionMethods.Length > 0 || serviceRegistration.RegistrationContext.Initializer != null || this.containerExtensionManager.HasPostBuildExtensions)
{
lines.AddRange(this.CreatePostWorkExpressionIfAny(containerContext, serviceRegistration, resolutionContext, serviceType, variable));
}
lines.Add(variable); //block returns with the variable
return(lines.AsBlock(variable));
}
protected override Expression GetExpressionInternal(IContainerContext containerContext, IServiceRegistration serviceRegistration, ResolutionContext resolutionContext, Type resolveType)
{
var genericType = serviceRegistration.ImplementationType.MakeGenericType(resolveType.GetGenericArguments());
var registration = this.RegisterConcreteGenericType(containerContext, serviceRegistration, resolveType, genericType);
return(registration.GetExpression(containerContext, resolutionContext, resolveType));
}
public Expression GetExpression(IContainerContext containerContext, TypeInformation typeInfo, ResolutionContext resolutionContext)
{
var args = typeInfo.Type.GetGenericArguments();
var tupleConstructor = typeInfo.Type.GetConstructor(args);
var length = args.Length;
var expressions = new Expression[length];
for (var i = 0; i < length; i++)
{
var argumentInfo = new TypeInformation {
Type = args[i]
};
var expr = containerContext.ResolutionStrategy.BuildResolutionExpression(containerContext, resolutionContext, argumentInfo, null);
if (expr != null)
{
expressions[i] = expr;
}
else
{
return(null);
}
}
return(tupleConstructor.MakeNew(expressions));
}
public static CreateInstance CreateConstructorExpression(IContainerContext containerContext, ResolutionConstructor resolutionConstructor,
ResolutionMember[] members = null)
{
var strategyParameter = Expression.Constant(containerContext.ResolutionStrategy, typeof(IResolutionStrategy));
var resolutionInfoParameter = Expression.Parameter(typeof(ResolutionInfo), "resolutionInfo");
var arguments = CreateExpressionFromResolutionTargets(resolutionConstructor.Parameters, strategyParameter, resolutionInfoParameter);
var newExpression = Expression.New(resolutionConstructor.Constructor, arguments);
if (members == null || members.Length == 0)
return Expression.Lambda<CreateInstance>(newExpression, resolutionInfoParameter).Compile();
var length = members.Length;
var propertyExpressions = new MemberBinding[length];
for (var i = 0; i < length; i++)
{
var member = members[i];
var propertyExpression = Expression.Bind(member.MemberInfo,
CreateResolutionTargetExpression(member.ResolutionTarget, strategyParameter,
resolutionInfoParameter));
propertyExpressions[i] = propertyExpression;
}
var initExpression = Expression.MemberInit(newExpression, propertyExpressions);
return Expression.Lambda<CreateInstance>(initExpression, resolutionInfoParameter).Compile();
}
public static Expression CreateExpression(IContainerContext containerContext, ResolutionConstructor resolutionConstructor, ResolutionInfo resolutionInfo,
Expression resolutionInfoExpression, ResolutionMember[] members = null)
{
var length = resolutionConstructor.Parameters.Length;
var arguments = new Expression[length];
for (var i = 0; i < length; i++)
{
var parameter = resolutionConstructor.Parameters[i];
arguments[i] = containerContext.ResolutionStrategy.GetExpressionForResolutionTarget(parameter, resolutionInfo, resolutionInfoExpression);
}
var newExpression = Expression.New(resolutionConstructor.Constructor, arguments);
if (members == null || members.Length == 0) return newExpression;
{
var propLength = members.Length;
var propertyExpressions = new MemberBinding[propLength];
for (var i = 0; i < propLength; i++)
{
var member = members[i];
var propertyExpression = Expression.Bind(member.MemberInfo,
containerContext.ResolutionStrategy.GetExpressionForResolutionTarget(member.ResolutionTarget, resolutionInfo, resolutionInfoExpression));
propertyExpressions[i] = propertyExpression;
}
return Expression.MemberInit(newExpression, propertyExpressions);
}
}
public bool CanResolve(IContainerContext containerContext, TypeInformation typeInformation,
InjectionParameter[] injectionParameters)
{
return this.resolutionStrategy.CanResolve(containerContext, typeInformation, injectionParameters) ||
this.resolutionStrategy.CanResolve(containerContext.Container.ParentContainer.ContainerContext, typeInformation,
injectionParameters);
}
public void ReinitalizeExtensions(IContainerContext containerContext)
{
foreach (var extension in this.repository)
{
extension.Initialize(containerContext);
}
}
protected override Expression GetExpressionInternal(IContainerContext containerContext, IServiceRegistration serviceRegistration, ResolutionContext resolutionContext, Type resolveType)
{
if (this.expression != null)
{
return(this.expression);
}
lock (this.syncObject)
{
if (this.expression != null)
{
return(this.expression);
}
if (serviceRegistration.ShouldHandleDisposal && serviceRegistration.RegistrationContext.ExistingInstance is IDisposable disposable)
{
resolutionContext.RootScope.AddDisposableTracking(disposable);
}
if (serviceRegistration.RegistrationContext.Finalizer != null)
{
var finalizerExpression = base.HandleFinalizer(serviceRegistration.RegistrationContext.ExistingInstance.AsConstant(),
serviceRegistration, resolutionContext.CurrentScopeParameter.Prop(Constants.RootScopeProperty));
return(this.expression = finalizerExpression.CompileDelegate(resolutionContext)(resolutionContext.ResolutionScope).AsConstant());
}
return(this.expression = serviceRegistration.RegistrationContext.ExistingInstance.AsConstant());
}
}
private ResolutionConstructor SelectConstructor(IContainerContext containerContext, IServiceRegistration serviceRegistration, ResolutionContext resolutionContext, ConstructorInformation[] constructors)
{
var length = constructors.Length;
var checkedConstructors = new Dictionary <ConstructorInfo, TypeInformation>();
for (var i = 0; i < length; i++)
{
var constructor = constructors[i];
var paramLength = constructor.Parameters.Length;
var parameterExpressions = new Expression[paramLength];
var hasNullParameter = false;
TypeInformation failedParameter = null;
for (var j = 0; j < paramLength; j++)
{
var parameter = constructor.Parameters[j];
var expression = containerContext.ResolutionStrategy.BuildResolutionExpression(containerContext,
resolutionContext, parameter, serviceRegistration.RegistrationContext.InjectionParameters);
if (expression == null)
{
hasNullParameter = true;
failedParameter = parameter;
break;
}
parameterExpressions[j] = expression;
}
if (hasNullParameter)
{
if (!resolutionContext.NullResultAllowed)
{
checkedConstructors.Add(constructor.Constructor, failedParameter);
}
continue;
}
return(new ResolutionConstructor {
Constructor = constructor.Constructor, Parameters = parameterExpressions
});
}
if (resolutionContext.NullResultAllowed)
{
return(null);
}
var stringBuilder = new StringBuilder();
foreach (var checkedConstructor in checkedConstructors)
{
stringBuilder.AppendLine($"Checked constructor {checkedConstructor.Key}, unresolvable parameter: ({checkedConstructor.Value.Type}){checkedConstructor.Value.ParameterName}");
}
throw new ResolutionFailedException(serviceRegistration.ImplementationType, stringBuilder.ToString());
}
/// <summary>
/// Clear down the test context.
/// </summary>
protected virtual void TidyUp()
{
// Ensure that we wipe down the core objects - NUnit re-uses the instance for all tests
entityFactory = null;
checkerFactory = null;
container = null;
containerContext = null;
}
internal ResolutionContext BeginCrossContainerContext(IContainerContext currentContainerContext)
{
var clone = this.Clone();
clone.CurrentContainerContext = currentContainerContext;
clone.ShouldFallBackToRequestInitiatorContext = clone.RequestInitiatorContainerContext != currentContainerContext;
return(clone);
}
public ResolutionScope(IResolverSelector resolverSelector, IServiceRegistrator serviceRegistrator, IExpressionBuilder expressionBuilder,
IContainerContext containerContext, IResolutionScope rootScope, IResolutionScope parent, AvlTreeKeyValue <object, Func <IResolutionScope, object> >[] serviceDelegateCache,
AvlTreeKeyValue <object, Func <IResolutionScope, Delegate> >[] factoryDelegates, object name = null)
: this(resolverSelector, serviceRegistrator, expressionBuilder, containerContext, serviceDelegateCache, factoryDelegates, name)
{
this.RootScope = rootScope;
this.ParentScope = parent;
}
public ContainerConfiguration(IContainerContext context)
{
Context = context ?? throw new ArgumentNullException("context");
if (context.IsLocked())
{
throw new ArgumentException("The container cannot already be locked.");
}
}
public static void UseDataAccess(this IAppBuilder app, IContainerContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
app.Use(typeof(DataAccessMiddleware), context);
}
public BuildUpObjectBuilder(object instance, IContainerContext containerContext, IContainerExtensionManager containerExtensionManager, IObjectExtender objectExtender)
{
this.instance = instance;
this.instanceType = instance.GetType();
this.containerExtensionManager = containerExtensionManager;
this.objectExtender = objectExtender;
this.containerContext = containerContext;
}
public override Expression GetExpression(IContainerContext containerContext, TypeInformation typeInfo, ResolutionContext resolutionContext)
{
if (typeInfo.HasDefaultValue)
{
return(typeInfo.DefaultValue.AsConstant(typeInfo.Type));
}
return(typeInfo.Type.AsDefault());
}
public StoredProcedureNodeViewModel(
IContainerContext context,
CosmosStoredProcedure storedProcedure,
NonLeafTreeNodeViewModel parent,
ScriptCommands <CosmosStoredProcedure> commands,
IMessenger messenger)
: base(storedProcedure, context, parent, commands, messenger)
{
}
public UserDefinedFunctionNodeViewModel(
CosmosUserDefinedFunction udf,
IContainerContext context,
NonLeafTreeNodeViewModel parent,
ScriptCommands <CosmosUserDefinedFunction> commands,
IMessenger messenger)
: base(udf, context, parent, commands, messenger)
{
}
public void ExecuteOnRegistrationExtensions(IContainerContext containerContext, RegistrationInfo registrationInfo, InjectionParameter[] injectionParameters = null)
{
if (!this.hasRegistrationExtensions) return;
using (this.readerWriterLock.AcquireReadLock())
{
foreach (var extension in this.registrationExtensions)
extension.OnRegistration(containerContext, registrationInfo, injectionParameters);
}
}
public TriggerNodeViewModel(
CosmosTrigger trigger,
IContainerContext context,
NonLeafTreeNodeViewModel parent,
ScriptCommands <CosmosTrigger> commands,
IMessenger messenger)
: base(trigger, context, parent, commands, messenger)
{
}
public MetaInfoProvider(IContainerContext containerContext, MetaInfoCache metaInfoCache)
{
this.containerContext = containerContext;
this.metaInfoCache = metaInfoCache;
this.HasInjectionMethod = this.metaInfoCache.InjectionMethods.Any();
this.HasInjectionMembers = this.metaInfoCache.InjectionMembers.Any();
this.sensitivityList = new Lazy<HashSet<Type>>(() => new HashSet<Type>(this.metaInfoCache.Constructors.SelectMany(constructor => constructor.Parameters, (constructor, parameter) => parameter.Type)
.Concat(this.metaInfoCache.InjectionMethods.SelectMany(method => method.Parameters, (method, parameter) => parameter.Type))
.Concat(this.metaInfoCache.InjectionMembers.Select(members => members.TypeInformation.Type)).Distinct()));
}
public static InvokeMethod CreateMethodExpression(IContainerContext containerContext, ResolutionTarget[] parameters, MethodInfo methodInfo)
{
var strategyParameter = Expression.Constant(containerContext.ResolutionStrategy, typeof(IResolutionStrategy));
var resolutionInfoParameter = Expression.Parameter(typeof(ResolutionInfo), "resolutionInfo");
var instanceParameter = Expression.Parameter(typeof(object), "instance");
var convertedInstance = Expression.Convert(instanceParameter, methodInfo.DeclaringType);
var arguments = CreateExpressionFromResolutionTargets(parameters, strategyParameter, resolutionInfoParameter);
var callExpression = Expression.Call(convertedInstance, methodInfo, arguments);
return Expression.Lambda<InvokeMethod>(callExpression, resolutionInfoParameter, instanceParameter).Compile();
}
public ResolutionTarget BuildResolutionTarget(IContainerContext containerContext, TypeInformation typeInformation,
InjectionParameter[] injectionParameters)
{
var target = this.resolutionStrategy.BuildResolutionTarget(containerContext, typeInformation,
injectionParameters);
if (target.Resolver == null && target.ResolutionTargetValue == null)
return this.resolutionStrategy.BuildResolutionTarget(
containerContext.Container.ParentContainer.ContainerContext, typeInformation, injectionParameters);
else
return target;
}
public DefaultObjectBuilder(IContainerContext containerContext, IMetaInfoProvider metaInfoProvider,
IContainerExtensionManager containerExtensionManager, string registrationName,
InjectionParameter[] injectionParameters = null)
{
if (injectionParameters != null)
this.injectionParameters = injectionParameters;
this.instanceType = metaInfoProvider.TypeTo;
this.containerExtensionManager = containerExtensionManager;
this.registrationName = registrationName;
this.metaInfoProvider = metaInfoProvider;
this.containerContext = containerContext;
}
public ResolutionTarget BuildResolutionTarget(IContainerContext containerContext, TypeInformation typeInformation,
InjectionParameter[] injectionParameters)
{
Resolver resolver;
this.resolverSelector.TryChooseResolver(containerContext, typeInformation, out resolver);
return new ResolutionTarget
{
Resolver = resolver,
TypeInformation = typeInformation,
ResolutionTargetValue = injectionParameters?.FirstOrDefault(param => param.Name == typeInformation.MemberName)?.Value
};
}
public EnumerableResolver(IContainerContext containerContext, TypeInformation typeInfo)
: base(containerContext, typeInfo)
{
this.enumerableType = new TypeInformation
{
Type = typeInfo.Type.GetEnumerableType(),
CustomAttributes = typeInfo.CustomAttributes,
ParentType = typeInfo.ParentType,
DependencyName = typeInfo.DependencyName
};
containerContext.RegistrationRepository.TryGetTypedRepositoryRegistrations(this.enumerableType,
out registrationCache);
}
public object FillResolutionMembers(object instance, IContainerContext containerContext, ResolutionInfo resolutionInfo)
{
if (!this.metaInfoProvider.HasInjectionMembers) return instance;
var members = this.GetResolutionMembers();
var count = members.Length;
for (var i = 0; i < count; i++)
{
var value = containerContext.ResolutionStrategy.EvaluateResolutionTarget(members[i].ResolutionTarget, resolutionInfo);
members[i].MemberSetter(instance, value);
}
return instance;
}
public object FillResolutionMethods(object instance, IContainerContext containerContext, ResolutionInfo resolutionInfo)
{
if (!this.metaInfoProvider.HasInjectionMethod) return instance;
{
var methods = this.GetResolutionMethods();
var count = methods.Length;
for (var i = 0; i < count; i++)
{
methods[i].MethodDelegate(resolutionInfo, instance);
}
}
return instance;
}
public bool TryChooseResolver(IContainerContext containerContext, TypeInformation typeInfo, out Resolver resolver, Func<ResolverRegistration, bool> filter = null)
{
using (this.readerWriterLock.AcquireReadLock())
{
var resolverFactory = filter == null ? this.resolverRepository.FirstOrDefault(
registration => registration.Predicate(containerContext, typeInfo)) :
this.resolverRepository.Where(filter).FirstOrDefault(
registration => registration.Predicate(containerContext, typeInfo));
if (resolverFactory != null)
{
resolver = resolverFactory.ResolverFactory(containerContext, typeInfo);
return true;
}
resolver = null;
return false;
}
}
public object ExecutePostBuildExtensions(object instance, Type targetType, IContainerContext containerContext, ResolutionInfo resolutionInfo,
TypeInformation resolveType, InjectionParameter[] injectionParameters = null)
{
if (!this.hasPostBuildExtensions) return instance;
using (this.readerWriterLock.AcquireReadLock())
{
var result = instance;
foreach (var extension in this.postbuildExtensions)
result = extension.PostBuild(instance, targetType, containerContext, resolutionInfo, resolveType, injectionParameters);
return result;
}
}
private object ResolveType(IContainerContext containerContext, ResolutionInfo resolutionInfo, TypeInformation resolveType)
{
var instance = this.constructorDelegate(resolutionInfo);
if (!this.metaInfoProvider.HasInjectionMethod)
return this.containerExtensionManager.ExecutePostBuildExtensions(instance, this.instanceType,
containerContext, resolutionInfo, resolveType, this.injectionParameters);
var methods = this.GetResolutionMethods();
var count = methods.Length;
for (var i = 0; i < count; i++)
{
methods[i].MethodDelegate(resolutionInfo, instance);
}
return this.containerExtensionManager.ExecutePostBuildExtensions(instance, this.instanceType, containerContext, resolutionInfo, resolveType, this.injectionParameters);
}
public bool CanResolve(IContainerContext containerContext, TypeInformation typeInfo)
{
using (this.readerWriterLock.AcquireReadLock())
return this.resolverRepository.Any(registration => registration.Predicate(containerContext, typeInfo));
}
public GenericTypeObjectBuilder(IContainerContext containerContext, IMetaInfoProvider metaInfoProvider)
{
this.metaInfoProvider = metaInfoProvider;
this.containerContext = containerContext;
}
public bool CanResolve(IContainerContext containerContext, TypeInformation typeInformation,
InjectionParameter[] injectionParameters)
{
return this.resolverSelector.CanResolve(containerContext, typeInformation) ||
(injectionParameters != null &&
injectionParameters.Any(injectionParameter =>
injectionParameter.Name == typeInformation.MemberName));
}
public ContainerResolver(IContainerContext containerContext, TypeInformation typeInfo)
: base(containerContext, typeInfo)
{
containerContext.RegistrationRepository.TryGetRegistrationWithConditions(typeInfo,
out this.registrationCache);
}
/// <summary>
/// Constructs the <see cref="Resolver"/>
/// </summary>
/// <param name="containerContext">The <see cref="IContainerContext"/> of the <see cref="StashboxContainer"/></param>
/// <param name="typeInfo">The type information about the resolved service.</param>
protected Resolver(IContainerContext containerContext, TypeInformation typeInfo)
{
this.BuilderContext = containerContext;
this.TypeInfo = typeInfo;
}
public void ReinitalizeExtensions(IContainerContext containerContext)
{
using (this.readerWriterLock.AcquireReadLock())
foreach (var extension in this.postbuildExtensions.OfType<IContainerExtension>().Concat(this.registrationExtensions))
extension.Initialize(containerContext);
}
public TestResolver(IContainerContext containerContext, TypeInformation typeInfo)
: base(containerContext, typeInfo)
{
}
private FactoryObjectBuilder(IContainerContext containerContext, IContainerExtensionManager containerExtensionManager, IObjectExtender objectExtender)
{
this.containerExtensionManager = containerExtensionManager;
this.objectExtender = objectExtender;
this.containerContext = containerContext;
}
public FactoryObjectBuilder(Func<object, object, object, object> threeParamsFactory, IContainerContext containerContext, IContainerExtensionManager containerExtensionManager, IObjectExtender objectExtender)
: this(containerContext, containerExtensionManager, objectExtender)
{
this.threeParamsFactory = threeParamsFactory;
}
public FactoryObjectBuilder(Func<object> factory, IContainerContext containerContext, IContainerExtensionManager containerExtensionManager, IObjectExtender objectExtender)
: this(containerContext, containerExtensionManager, objectExtender)
{
this.singleFactory = factory;
}
