public IActivationExpressionResult GetActivationExpression(IInjectionScope scope, IActivationExpressionRequest request)
{
var type = request.ActivationType.GenericTypeArguments[0];
var newRequest =
request.NewRequest(type, this, request.ActivationType, RequestType.Other, null, true, true);
var expression = request.Services.ExpressionBuilder.GetActivationExpression(scope, newRequest);
var scopeNameRequest =
request.NewRequest(typeof(string), this, ActivationType, RequestType.Other, null, true, true);
scopeNameRequest.SetIsRequired(false);
var scopeNameExpression =
request.Services.ExpressionBuilder.GetActivationExpression(scope, scopeNameRequest);
var compiled = request.Services.Compiler.CompileDelegate(scope, expression);
var closedType = typeof(Scoped <>).MakeGenericType(type);
var newExpression = Expression.New(closedType.GetTypeInfo().DeclaredConstructors.Single(),
request.ScopeParameter, request.InjectionContextParameter, Expression.Constant(compiled), scopeNameExpression.Expression);
return(request.Services.Compiler.CreateNewResult(request, newExpression));
}
private IActivationExpressionResult GetExpressionFromDependentStrategy(IInjectionScope scope, IActivationExpressionRequest request)
{
var newRequest = request.NewRequest(_dependentStrategy.ActivationType, this, request.InjectedType, request.RequestType, request.Info, true, true);
var instanceResult = _dependentStrategy.GetActivationExpression(scope, newRequest);
var results = new List <IActivationExpressionResult> {
instanceResult
};
var parameterExpressions = new List <Expression>();
foreach (var parameterInfo in _methodInfo.GetParameters())
{
newRequest = request.NewRequest(parameterInfo.ParameterType, this, _dependentStrategy.ActivationType,
RequestType.MethodParameter, parameterInfo, false, true);
var parameterResult = request.Services.ExpressionBuilder.GetActivationExpression(scope, newRequest);
results.Add(parameterResult);
parameterExpressions.Add(parameterResult.Expression);
}
var expression = Expression.Call(instanceResult.Expression, _methodInfo, parameterExpressions);
var result = request.Services.Compiler.CreateNewResult(request, expression);
foreach (var expressionResult in results)
{
result.AddExpressionResult(expressionResult);
}
return(result);
}
private static void AddMethodCall(IInjectionScope scope, IActivationExpressionRequest request,
TypeActivationConfiguration activationConfiguration, IActivationExpressionResult activationExpressionResult,
MethodInjectionInfo methodInjectionInfo, ParameterExpression variableExpression)
{
var parameterResults = new List <IActivationExpressionResult>();
foreach (var parameter in methodInjectionInfo.Method.GetParameters())
{
var parameterRequest = request.NewRequest(parameter.ParameterType,
activationConfiguration.ActivationStrategy, activationConfiguration.ActivationType,
RequestType.MethodParameter, parameter, false, true);
if (scope.ScopeConfiguration.Behaviors.KeyedTypeSelector(parameter.ParameterType))
{
parameterRequest.SetLocateKey(parameter.Name);
}
var result = request.Services.ExpressionBuilder.GetActivationExpression(scope, parameterRequest);
parameterResults.Add(result);
activationExpressionResult.AddExpressionResult(result);
}
activationExpressionResult.AddExtraExpression(Expression.Call(variableExpression,
methodInjectionInfo.Method, parameterResults.Select(r => r.Expression)));
}
private static IActivationExpressionResult CreatePropertyImportStatement(IInjectionScope scope, Type locateType,
ParameterExpression instanceValue, InjectionStrategy strategy, IActivationExpressionRequest request,
PropertyInfo property, ImportAttributeInfo importInfo)
{
var propertyRequest = request.NewRequest(property.PropertyType, strategy, locateType,
RequestType.Member, property, false, true);
propertyRequest.SetIsRequired(importInfo.IsRequired);
propertyRequest.SetEnumerableComparer(importInfo.Comparer);
if (importInfo.ImportKey != null)
{
propertyRequest.SetLocateKey(importInfo.ImportKey);
}
else if (scope.ScopeConfiguration.Behaviors.KeyedTypeSelector(property.PropertyType))
{
propertyRequest.SetLocateKey(property.Name);
}
var result = request.Services.ExpressionBuilder.GetActivationExpression(scope, propertyRequest);
var setExpression = Expression.Assign(Expression.Property(instanceValue, property.SetMethod),
result.Expression);
result.AddExtraExpression(setExpression);
result.Expression = null;
return(result);
}
/// <summary>
/// Get an activation expression for this strategy
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <returns></returns>
public override IActivationExpressionResult GetActivationExpression(IInjectionScope scope, IActivationExpressionRequest request)
{
var constructor = request.ActivationType.GetTypeInfo().DeclaredConstructors.First();
var wrappedType = request.ActivationType.GenericTypeArguments[0];
var ownedParameter = Expression.Parameter(request.ActivationType);
var assign = Expression.Assign(ownedParameter, Expression.New(constructor));
var newRequest = request.NewRequest(wrappedType, this, request.ActivationType, RequestType.Other, null, true, true);
newRequest.DisposalScopeExpression = ownedParameter;
var expressionResult = request.Services.ExpressionBuilder.GetActivationExpression(scope, newRequest);
var setMethod = request.ActivationType.GetRuntimeMethods().First(m => m.Name == "SetValue");
var expression = Expression.Call(ownedParameter, setMethod, expressionResult.Expression);
var returnExpression = request.Services.Compiler.CreateNewResult(request, expression);
returnExpression.AddExpressionResult(expressionResult);
returnExpression.AddExtraParameter(ownedParameter);
returnExpression.AddExtraExpression(assign);
return(returnExpression);
}
/// <summary>
/// Get an activation expression for this strategy
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <returns></returns>
public override IActivationExpressionResult GetActivationExpression(IInjectionScope scope, IActivationExpressionRequest request)
{
var elementType = request.ActivationType.GenericTypeArguments[0];
var closedType = typeof(List <>).MakeGenericType(elementType);
var newRequest = request.NewRequest(elementType.MakeArrayType(), this, closedType, RequestType.Other, null, true, true);
newRequest.SetFilter(request.Filter);
newRequest.SetEnumerableComparer(request.EnumerableComparer);
var listResult = request.Services.ExpressionBuilder.GetActivationExpression(scope, newRequest);
var constructor = closedType.GetTypeInfo().DeclaredConstructors.First(c =>
{
var parameters = c.GetParameters();
if (parameters.Length == 1)
{
return(parameters[0].ParameterType.IsConstructedGenericType &&
parameters[0].ParameterType.GetGenericTypeDefinition() == typeof(IEnumerable <>));
}
return(false);
});
var expression = Expression.New(constructor, listResult.Expression);
var result = request.Services.Compiler.CreateNewResult(request, expression);
result.AddExpressionResult(listResult);
return(result);
}
/// <summary>Visits the children of the <see cref="T:System.Linq.Expressions.MethodCallExpression" />.</summary>
/// <returns>The modified expression, if it or any subexpression was modified; otherwise, returns the original expression.</returns>
/// <param name="node">The expression to visit.</param>
protected override Expression VisitMethodCall(MethodCallExpression node)
{
if (node.Method.DeclaringType == typeof(Arg))
{
var methodName = node.Method.Name;
if (methodName == nameof(Arg.Any) ||
methodName == nameof(Arg.Locate))
{
var newRequest = _request.NewRequest(node.Method.GetGenericArguments().First(), _activationStrategy,
_activationStrategy.ActivationType, RequestType.Other, null, true, true);
var arguement = node.Arguments.FirstOrDefault();
if (arguement != null)
{
var replaceNode = (MethodCallExpression)base.VisitMethodCall(node);
arguement = replaceNode.Arguments.First();
if (arguement is NewExpression newExpression)
{
var parameters = newExpression.Constructor.GetParameters();
for (int i = 0; i < parameters.Length; i++)
{
var expression = newExpression.Arguments[i];
var parameter = parameters[i];
var knownValue = new SimpleKnownValueExpression(expression.Type, expression,
parameter.Name);
newRequest.AddKnownValueExpression(knownValue);
}
}
}
var activationExpression =
_request.Services.ExpressionBuilder.GetActivationExpression(_request.RequestingScope, newRequest);
_result.AddExpressionResult(activationExpression);
return(activationExpression.Expression);
}
if (methodName == nameof(Arg.Scope))
{
_request.RequireExportScope();
return(_request.ScopeParameter);
}
if (methodName == nameof(Arg.Context))
{
return(_request.InjectionContextParameter);
}
}
return(base.VisitMethodCall(node));
}
/// <summary>
/// Process wrappers looking for matching type
/// </summary>
/// <param name="scope"></param>
/// <param name="arrayElementType"></param>
/// <param name="request"></param>
/// <param name="expressions"></param>
protected virtual void ProcessWrappers(IInjectionScope scope, Type arrayElementType, IActivationExpressionRequest request, List <IActivationExpressionResult> expressions)
{
Type wrappedType;
var wrappers = _wrapperExpressionCreator.GetWrappers(scope, arrayElementType, request, out wrappedType);
if (wrappers != ImmutableLinkedList <IActivationPathNode> .Empty)
{
wrappers = wrappers.Reverse();
GetExpressionsFromCollections(scope, arrayElementType, request, expressions, wrappedType, wrappers);
if (expressions.Count == 0)
{
lock (scope.GetLockObject(InjectionScope.ActivationStrategyAddLockName))
{
GetExpressionsFromCollections(scope, arrayElementType, request, expressions, wrappedType, wrappers);
if (expressions.Count == 0)
{
var newRequest = request.NewRequest(arrayElementType, request.RequestingStrategy, request.RequestingStrategy?.ActivationType, RequestType.Other, null, true);
request.Services.Compiler.ProcessMissingStrategyProviders(scope, newRequest);
GetExpressionsFromCollections(scope, arrayElementType, request, expressions, wrappedType, wrappers);
}
}
}
}
}
/// <summary>
/// Create enumerable expression using a custom creator
/// </summary>
/// <param name="scope">injection scope</param>
/// <param name="request">expression request</param>
/// <param name="arrayExpressionCreator">array creator</param>
/// <param name="enumerableCreator">custom enumerable creator</param>
/// <returns></returns>
protected virtual IActivationExpressionResult CreateEnumerableExpressionUsingCustomCreator(IInjectionScope scope,
IActivationExpressionRequest request, IArrayExpressionCreator arrayExpressionCreator,
IEnumerableCreator enumerableCreator)
{
var enumerableType = request.ActivationType.GenericTypeArguments[0];
var arrayType = enumerableType.MakeArrayType();
var newRequest =
request.NewRequest(arrayType, request.RequestingStrategy,
request.RequestingStrategy?.ActivationType, request.RequestType, request.Info, true, true);
newRequest.SetFilter(request.Filter);
newRequest.SetEnumerableComparer(request.EnumerableComparer);
var arrayExpression = arrayExpressionCreator.GetArrayExpression(scope, newRequest);
var enumerableExpression =
Expression.Call(Expression.Constant(enumerableCreator),
CreateEnumerableMethod.MakeGenericMethod(enumerableType),
request.ScopeParameter,
arrayExpression.Expression);
var returnResult = request.Services.Compiler.CreateNewResult(request, enumerableExpression);
returnResult.AddExpressionResult(returnResult);
return(returnResult);
}
private IActivationExpressionResult GetExpressionFromDependentStrategy(IInjectionScope scope,
IActivationExpressionRequest request)
{
var newRequest = request.NewRequest(_dependentStrategy.ActivationType, this, request.InjectedType,
request.RequestType, request.Info, true, true);
var instanceResult = _dependentStrategy.GetActivationExpression(scope, newRequest);
Expression propertyExpression;
try
{
propertyExpression = Expression.PropertyOrField(instanceResult.Expression, _propertyOrFieldName);
}
catch (Exception exp)
{
throw new LocateException(request.GetStaticInjectionContext(), exp, $"Could not create property/field expression for {_propertyOrFieldName} on type {instanceResult.Expression.Type.FullName}");
}
var expressionResult = request.Services.Compiler.CreateNewResult(request, propertyExpression);
expressionResult.AddExpressionResult(instanceResult);
return(expressionResult);
}
/// <summary>
///
/// </summary>
/// <param name="scope"></param>
/// <param name="locateType"></param>
/// <param name="instanceValue"></param>
/// <param name="strategy"></param>
/// <param name="request"></param>
/// <param name="method"></param>
/// <param name="importInfo"></param>
/// <returns></returns>
protected virtual IActivationExpressionResult CreateMethodInjectionExpression(IInjectionScope scope, Type locateType, ParameterExpression instanceValue, InjectionStrategy strategy, IActivationExpressionRequest request, MethodInfo method, ImportAttributeInfo importInfo)
{
var expressionResult = scope.StrategyCompiler.CreateNewResult(request);
var list = new List <IActivationExpressionResult>();
foreach (var parameter in method.GetParameters())
{
var parameterRequest = request.NewRequest(parameter.ParameterType, strategy, locateType,
RequestType.MethodParameter, parameter, false, true);
if (scope.ScopeConfiguration.Behaviors.KeyedTypeSelector(parameter.ParameterType))
{
parameterRequest.SetLocateKey(parameter.Name);
}
var result = request.Services.ExpressionBuilder.GetActivationExpression(scope, parameterRequest);
list.Add(result);
expressionResult.AddExpressionResult(result);
}
var callExpression = Expression.Call(instanceValue, method, list.Select(result => result.Expression));
expressionResult.AddExtraExpression(callExpression);
return(expressionResult);
}
/// <summary>
/// Get an activation expression for this strategy
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <returns></returns>
public override IActivationExpressionResult GetActivationExpression(IInjectionScope scope, IActivationExpressionRequest request)
{
var requestType = request.ActivationType.GetTypeInfo().GenericTypeArguments[0];
var constructor = request.ActivationType.GetTypeInfo().DeclaredConstructors.First();
var newRequest = request.NewRequest(requestType, this, request.ActivationType, RequestType.Other, null, true);
var strategy = request.GetWrappedExportStrategy();
if (strategy == null)
{
throw new Exception("Could not find export stragegy to get metadata from");
}
var expressionResult = request.Services.ExpressionBuilder.GetActivationExpression(scope, newRequest);
var newExpression =
Expression.New(constructor, expressionResult.Expression, Expression.Constant(strategy.Metadata));
var newResult = request.Services.Compiler.CreateNewResult(request, newExpression);
newResult.AddExpressionResult(expressionResult);
return(newResult);
}
/// <summary>
/// Get an activation expression for this strategy
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <returns></returns>
public override IActivationExpressionResult GetActivationExpression(IInjectionScope scope, IActivationExpressionRequest request)
{
var optionalType = request.ActivationType.GenericTypeArguments[0];
var newRequest = request.NewRequest(optionalType, this, request.ActivationType, RequestType.Other, null, true, true);
newRequest.SetLocateKey(request.LocateKey);
newRequest.SetFilter(request.Filter);
newRequest.SetEnumerableComparer(request.EnumerableComparer);
var result = request.Services.ExpressionBuilder.GetActivationExpression(scope, newRequest);
Expression expression = null;
if (result.UsingFallbackExpression)
{
var closedMethod =
_optionNone.MakeGenericMethod(optionalType);
expression = Expression.Call(closedMethod);
}
else
{
var closedMethod = _optionSome.MakeGenericMethod(optionalType);
expression = Expression.Call(closedMethod, result.Expression);
}
var expressionResult = request.Services.Compiler.CreateNewResult(request, expression);
expressionResult.AddExpressionResult(result);
return(expressionResult);
}
private ActivationStrategyDelegate CompileDelegate()
{
lock (_lock)
{
if (_delegate == null)
{
var requestType = _request.ActivationType.GenericTypeArguments[0];
var newRequest = _request.NewRequest(requestType, _activationStrategy, typeof(Lazy <TResult>),
RequestType.Other, null, true, true);
newRequest.DisposalScopeExpression = _request.Constants.RootDisposalScope;
var activationExpression = _request.Services.ExpressionBuilder.GetActivationExpression(_scope,
newRequest);
_delegate = _request.Services.Compiler.CompileDelegate(_scope, activationExpression);
_scope = null;
_request = null;
_activationStrategy = null;
}
}
return(_delegate);
}
/// <summary>
/// Get expression for parameter
/// </summary>
/// <param name="parameter"></param>
/// <param name="parameterInfo"></param>
/// <param name="injectionScope"></param>
/// <param name="configuration"></param>
/// <param name="request"></param>
/// <returns></returns>
protected virtual IActivationExpressionResult GetParameterExpression(ParameterInfo parameter, ConstructorParameterInfo parameterInfo, IInjectionScope injectionScope, TypeActivationConfiguration configuration, IActivationExpressionRequest request, out IActivationExpressionRequest newRequest)
{
if (parameterInfo?.ExportFunc != null)
{
newRequest = null;
return(CallExportFunc(configuration.ActivationStrategy, parameter, parameterInfo, injectionScope, request, configuration.ExternallyOwned));
}
newRequest = request.NewRequest(parameterInfo?.UseType ?? parameter.ParameterType,
configuration.ActivationStrategy,
configuration.ActivationType,
RequestType.ConstructorParameter,
parameter,
true,
true);
if (parameterInfo?.LocateWithKey != null)
{
newRequest.SetLocateKey(parameterInfo.LocateWithKey);
}
else if (injectionScope.ScopeConfiguration.Behaviors.KeyedTypeSelector(parameter.ParameterType))
{
newRequest.SetLocateKey(parameter.Name);
}
if (parameterInfo?.DefaultValue != null)
{
newRequest.SetDefaultValue(new DefaultValueInformation {
DefaultValue = parameterInfo.DefaultValue
});
}
else if (parameter.HasDefaultValue)
{
newRequest.SetDefaultValue(new DefaultValueInformation {
DefaultValue = parameter.DefaultValue
});
}
if (parameterInfo != null)
{
newRequest.IsDynamic = parameterInfo.IsDynamic;
newRequest.SetIsRequired(parameterInfo.IsRequired.GetValueOrDefault(!parameter.IsOptional));
newRequest.SetFilter(parameterInfo.ExportStrategyFilter);
newRequest.SetEnumerableComparer(parameterInfo.EnumerableComparer);
}
else
{
newRequest.SetIsRequired(!parameter.IsOptional);
}
return(newRequest.Services.ExpressionBuilder.GetActivationExpression(injectionScope, newRequest));
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <param name="activationStrategy"></param>
public FuncExpression(IInjectionScope scope, IActivationExpressionRequest request, IActivationStrategy activationStrategy)
{
var requestType = request.ActivationType.GenericTypeArguments[0];
var newRequest = request.NewRequest(requestType, activationStrategy, typeof(Func <TResult>), RequestType.Other, null, true);
newRequest.DisposalScopeExpression = request.Constants.RootDisposalScope;
var activationExpression = request.Services.ExpressionBuilder.GetActivationExpression(scope, newRequest);
_action = request.Services.Compiler.CompileDelegate(scope, activationExpression);
}
/// <summary>
/// Internal method for creating acivation expression
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <returns></returns>
protected virtual IActivationExpressionResult InternalGetDecoratorActivationExpression(IInjectionScope scope, IActivationExpressionRequest request)
{
var newRequest = request.NewRequest(typeof(T), this, ActivationType, RequestType.Other, null, true, true);
var expression = request.Services.ExpressionBuilder.GetActivationExpression(scope, newRequest);
var callExpression = Expression.Call(Expression.Constant(_func.Target), _func.GetMethodInfo(), expression.Expression);
var resultExpression = request.Services.Compiler.CreateNewResult(request, callExpression);
return(resultExpression);
}
private IActivationExpressionResult CallExportFunc(IActivationStrategy strategy, ParameterInfo parameter, ConstructorParameterInfo parameterInfo, IInjectionScope injectionScope, IActivationExpressionRequest request, bool configurationExternallyOwned)
{
var exportDelegate = parameterInfo.ExportFunc as Delegate;
if (exportDelegate == null)
{
throw new ArgumentException($"Parameter Info {parameterInfo.ParameterName} is not delegate", nameof(parameterInfo));
}
var newRequest = request.NewRequest(parameter.ParameterType, strategy, strategy.ActivationType,
RequestType.ConstructorParameter, parameter, false, true);
return(ExpressionUtilities.CreateExpressionForDelegate(exportDelegate, ShouldTrackDisposable(configurationExternallyOwned, injectionScope, strategy), injectionScope, newRequest));
}
/// <summary>
/// Create an array of expressions based off an array of types
/// </summary>
/// <param name="strategy"></param>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <param name="resultType"></param>
/// <param name="types"></param>
/// <returns></returns>
public static IActivationExpressionResult[] CreateExpressionsForTypes(IActivationStrategy strategy, IInjectionScope scope,
IActivationExpressionRequest request, Type resultType, params Type[] types)
{
var resultArray = new IActivationExpressionResult[types.Length];
for (var i = 0; i < types.Length; i++)
{
var arg1Request = request.NewRequest(types[i], strategy, resultType, RequestType.Other, null, true, true);
resultArray[i] = request.Services.ExpressionBuilder.GetActivationExpression(scope, arg1Request);
}
return(resultArray);
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <param name="injectionContextCreator"></param>
/// <param name="activationStrategy"></param>
public DelegateExpression(IInjectionScope scope, IActivationExpressionRequest request,
IInjectionContextCreator injectionContextCreator, IActivationStrategy activationStrategy)
{
_injectionContextCreator = injectionContextCreator;
var newRequest = request.NewRequest(typeof(TResult), activationStrategy, typeof(TDelegate), RequestType.Other, null, true);
newRequest.DisposalScopeExpression = request.Constants.RootDisposalScope;
var activationExpression = request.Services.ExpressionBuilder.GetActivationExpression(scope, newRequest);
_action = request.Services.Compiler.CompileDelegate(scope, activationExpression);
_funcMethodInfo = typeof(FuncClass).GetTypeInfo().GetDeclaredMethod("Func");
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <param name="injectionContextCreator"></param>
/// <param name="activationStrategy"></param>
public FuncExpression(IInjectionScope scope, IActivationExpressionRequest request,
IInjectionContextCreator injectionContextCreator, IActivationStrategy activationStrategy)
{
_injectionContextCreator = injectionContextCreator;
var newRequest = request.NewRequest(typeof(TResult), activationStrategy, typeof(Func <T1, T2, T3, TResult>), RequestType.Other, null, true);
newRequest.AddKnownValueExpression(CreateKnownValueExpression(request, typeof(T1), _t1Id));
newRequest.AddKnownValueExpression(CreateKnownValueExpression(request, typeof(T2), _t2Id));
newRequest.AddKnownValueExpression(CreateKnownValueExpression(request, typeof(T3), _t3Id));
newRequest.DisposalScopeExpression = request.Constants.RootDisposalScope;
var activationExpression = request.Services.ExpressionBuilder.GetActivationExpression(scope, newRequest);
_action = request.Services.Compiler.CompileDelegate(scope, activationExpression);
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <param name="injectionContextCreator"></param>
/// <param name="activationStrategy"></param>
public FuncExpression(IInjectionScope scope, IActivationExpressionRequest request,
IInjectionContextCreator injectionContextCreator, IActivationStrategy activationStrategy)
{
_injectionContextCreator = injectionContextCreator;
var requestType = request.ActivationType.GenericTypeArguments[1];
var newRequest = request.NewRequest(requestType, activationStrategy, typeof(Func <TArg1, TResult>), RequestType.Other, null, true);
newRequest.AddKnownValueExpression(CreateKnownValueExpression(request));
newRequest.SetLocateKey(request.LocateKey);
newRequest.DisposalScopeExpression = request.Constants.RootDisposalScope;
var activationExpression = request.Services.ExpressionBuilder.GetActivationExpression(scope, newRequest);
_action = request.Services.Compiler.CompileDelegate(scope, activationExpression);
}
/// <summary>
/// Create enumerable expression that is an array
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <param name="arrayExpressionCreator"></param>
/// <returns></returns>
protected virtual IActivationExpressionResult CreateEnumerableExpressionUsingArrayExpression(IInjectionScope scope,
IActivationExpressionRequest request, IArrayExpressionCreator arrayExpressionCreator)
{
var enumerableType = request.ActivationType.GenericTypeArguments[0];
var arrayType = enumerableType.MakeArrayType();
var newRequest = request.NewRequest(arrayType, request.RequestingStrategy,
request.RequestingStrategy?.ActivationType, request.RequestType, request.Info, true, true);
newRequest.SetFilter(request.Filter);
newRequest.SetEnumerableComparer(request.EnumerableComparer);
newRequest.SetLocateKey(request.LocateKey);
var arrayExpression = arrayExpressionCreator.GetArrayExpression(scope, newRequest);
return(arrayExpression);
}
/// <summary>
/// Create enrichment expressions
/// </summary>
/// <param name="scope">scope for strategy</param>
/// <param name="request">request</param>
/// <param name="activationConfiguration">activation configuration</param>
/// <param name="result">expression result</param>
/// <returns></returns>
public IActivationExpressionResult CreateExpression(IInjectionScope scope, IActivationExpressionRequest request,
TypeActivationConfiguration activationConfiguration, IActivationExpressionResult result)
{
var expression = result.Expression;
foreach (var enrichmentDelegate in activationConfiguration.EnrichmentDelegates.Reverse())
{
var invokeMethod = enrichmentDelegate.GetType().GetRuntimeMethods().First(m => m.Name == "Invoke");
var expressions = new List <Expression>();
foreach (var parameter in invokeMethod.GetParameters())
{
if (parameter.ParameterType.GetTypeInfo().IsAssignableFrom(expression.Type.GetTypeInfo()))
{
expressions.Add(expression);
}
else
{
var arg1Request = request.NewRequest(parameter.ParameterType, activationConfiguration.ActivationStrategy, expression.Type, RequestType.Other, null, true, true);
var activationExpression = request.Services.ExpressionBuilder.GetActivationExpression(scope, arg1Request);
result.AddExpressionResult(activationExpression);
expressions.Add(activationExpression.Expression);
}
}
expression = Expression.Call(Expression.Constant(enrichmentDelegate), invokeMethod,
expressions);
if (activationConfiguration.ActivationType != expression.Type)
{
expression = Expression.Convert(expression, activationConfiguration.ActivationType);
}
}
result.Expression = expression;
return(result);
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <param name="injectionContextCreator"></param>
/// <param name="activationStrategy"></param>
public DelegateExpression(IInjectionScope scope, IActivationExpressionRequest request,
IInjectionContextCreator injectionContextCreator, IActivationStrategy activationStrategy)
{
_injectionContextCreator = injectionContextCreator;
var newRequest = request.NewRequest(typeof(TResult), activationStrategy, typeof(TDelegate), RequestType.Other, null, true);
newRequest.AddKnownValueExpression(CreateKnownValueExpression(request, typeof(T1), _arg1Id));
newRequest.AddKnownValueExpression(CreateKnownValueExpression(request, typeof(T2), _arg2Id));
newRequest.AddKnownValueExpression(CreateKnownValueExpression(request, typeof(T3), _arg3Id));
newRequest.SetLocateKey(request.LocateKey);
newRequest.DisposalScopeExpression = request.Constants.RootDisposalScope;
var activationExpression = request.Services.ExpressionBuilder.GetActivationExpression(scope, newRequest);
_action = request.Services.Compiler.CompileDelegate(scope, activationExpression);
_funcMethodInfo = typeof(FuncClass).GetTypeInfo().GetDeclaredMethod(nameof(FuncClass.Func));
}
/// <summary>
/// Get expression from an activation strategy collection
/// </summary>
/// <param name="scope"></param>
/// <param name="arrayElementType"></param>
/// <param name="request"></param>
/// <param name="expressions"></param>
/// <param name="collection"></param>
/// <param name="wrappedType"></param>
/// <param name="wrappers"></param>
public static void GetExpressionFromCollection(IInjectionScope scope, Type arrayElementType,
IActivationExpressionRequest request, List <IActivationExpressionResult> expressions, IActivationStrategyCollection <ICompiledExportStrategy> collection, Type wrappedType,
ImmutableLinkedList <IActivationPathNode> wrappers)
{
foreach (var strategy in collection.GetStrategies())
{
if (strategy.HasConditions)
{
var staticContext = request.GetStaticInjectionContext();
var pass = true;
foreach (var condition in strategy.Conditions)
{
if (!condition.MeetsCondition(strategy, staticContext))
{
pass = false;
break;
}
}
if (!pass)
{
continue;
}
}
var newRequest = request.NewRequest(arrayElementType, request.RequestingStrategy, request.RequestingStrategy?.ActivationType,
RequestType.Other, null, true);
var newPath =
ImmutableLinkedList <IActivationPathNode> .Empty.Add(
new WrapperActivationPathNode(strategy,
wrappedType, null)).AddRange(wrappers);
newRequest.SetWrapperPath(newPath);
var wrapper = newRequest.PopWrapperPathNode();
expressions.Add(wrapper.GetActivationExpression(scope, newRequest));
}
}
/// <summary>
/// Get an activation expression for this strategy
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <returns></returns>
public override IActivationExpressionResult GetActivationExpression(IInjectionScope scope, IActivationExpressionRequest request)
{
var elementType = request.ActivationType.GenericTypeArguments[0];
var newRequest = request.NewRequest(elementType.MakeArrayType(), this, request.ActivationType, RequestType.Other, null, true, true);
newRequest.SetFilter(request.Filter);
newRequest.SetEnumerableComparer(request.EnumerableComparer);
var arrayResult = request.Services.ExpressionBuilder.GetActivationExpression(scope, newRequest);
var closedMethod = _createMethod.MakeGenericMethod(elementType);
var expression = Expression.Call(closedMethod, arrayResult.Expression);
var expressionResult = request.Services.Compiler.CreateNewResult(request, expression);
expressionResult.AddExpressionResult(arrayResult);
return(expressionResult);
}
private ActivationStrategyDelegate CompileDelegate(
IInjectionScope scope,
IActivationExpressionRequest request)
{
var requestType = request.ActivationType.GenericTypeArguments[0];
var implementationType = typeof(GraceOptional <>).MakeGenericType(requestType);
var newRequest = request.NewRequest(requestType, this, implementationType, RequestType.Other, null, true);
if (request.LocateKey != null)
{
newRequest.SetLocateKey(request.LocateKey);
}
newRequest.DisposalScopeExpression = request.Constants.RootDisposalScope;
newRequest.SetIsRequired(false);
var activationExpression = request.Services.ExpressionBuilder
.GetActivationExpression(scope, newRequest);
var _delegate = request.Services.Compiler.CompileDelegate(scope, activationExpression);
return(_delegate);
}
/// <summary>
/// Get an activation expression for this strategy
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <returns></returns>
public override IActivationExpressionResult GetActivationExpression(IInjectionScope scope, IActivationExpressionRequest request)
{
var elementType = request.ActivationType.GenericTypeArguments[0];
var newRequest = request.NewRequest(elementType.MakeArrayType(), this, request.ActivationType, RequestType.Other, null, true, true);
newRequest.SetFilter(request.Filter);
newRequest.SetEnumerableComparer(request.EnumerableComparer);
var listResult = request.Services.ExpressionBuilder.GetActivationExpression(scope, newRequest);
var fromMethod =
typeof(ImmutableArray).GetRuntimeMethods().First(m => m.Name == "From" && m.GetParameters().Length == 2);
var closedMethod = fromMethod.MakeGenericMethod(elementType);
var expression = Expression.Call(closedMethod, listResult.Expression, Expression.Constant(-1));
var result = request.Services.Compiler.CreateNewResult(request, expression);
result.AddExpressionResult(listResult);
return(result);
}
/// <summary>
/// Get an activation expression for this strategy
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <returns></returns>
public override IActivationExpressionResult GetActivationExpression(IInjectionScope scope, IActivationExpressionRequest request)
{
var elementType = request.ActivationType.GenericTypeArguments[0];
var newRequest = request.NewRequest(elementType.MakeArrayType(), this, request.ActivationType, RequestType.Other, null, true, true);
newRequest.SetFilter(request.Filter);
newRequest.SetEnumerableComparer(request.EnumerableComparer);
var listResult = request.Services.ExpressionBuilder.GetActivationExpression(scope, newRequest);
var createMethod =
typeof(ImmutableLinkListStrategy).GetTypeInfo().GetDeclaredMethod("CreateImmutableLinkedList");
var closedMethod = createMethod.MakeGenericMethod(elementType);
var expression = Expression.Call(closedMethod, listResult.Expression);
var expressionResult = request.Services.Compiler.CreateNewResult(request, expression);
expressionResult.AddExpressionResult(listResult);
return(expressionResult);
}
