/// <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);
request.RequireExportScope();
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);
}
/// <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 closedClass = typeof(LazyExpression <,>).MakeGenericType(request.ActivationType.GenericTypeArguments);
var closedMethod = closedClass.GetRuntimeMethod(nameof(LazyExpression <object, object> .CreateLazy), new[] { typeof(IExportLocatorScope), typeof(IDisposalScope), typeof(IInjectionContext) });
var wrappedStrategy = request.GetWrappedStrategy();
if (wrappedStrategy == null)
{
throw new LocateException(request.GetStaticInjectionContext(), "Could not find strategy that is wrapped");
}
var metadata = _strongMetadataInstanceProvider.GetMetadata(request.ActivationType.GenericTypeArguments[1],
wrappedStrategy.Metadata);
var instance = Activator.CreateInstance(closedClass, scope, request, this, metadata);
request.RequireExportScope();
request.RequireDisposalScope();
var callExpression =
Expression.Call(Expression.Constant(instance), closedMethod, request.ScopeParameter,
request.DisposalScopeExpression, request.InjectionContextParameter);
request.RequireInjectionContext();
return(request.Services.Compiler.CreateNewResult(request, callExpression));
}
/// <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>
/// Get an activation expression for this strategy
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <returns></returns>
public IActivationExpressionResult GetActivationExpression(IInjectionScope scope,
IActivationExpressionRequest request)
{
Expression assignStatement = null;
ParameterExpression newScope = null;
if (ActivationConfiguration.CustomScopeName != null)
{
request.RequireExportScope();
newScope = Expression.Variable(typeof(IExportLocatorScope));
var beginScopeMethod =
typeof(IExportLocatorScope).GetTypeInfo().GetDeclaredMethod(nameof(IExportLocatorScope.BeginLifetimeScope));
assignStatement =
Expression.Assign(newScope,
Expression.Call(request.ScopeParameter, beginScopeMethod,
Expression.Constant(ActivationConfiguration.CustomScopeName)));
request.ScopeParameter = newScope;
}
var result = request.Services.ExpressionBuilder.DecorateExportStrategy(scope, request, this) ??
_builder.GetActivationExpression(scope, request, ActivationConfiguration, ActivationConfiguration.Lifestyle);
if (newScope != null)
{
result.AddExtraParameter(newScope);
result.AddExtraExpression(assignStatement, true);
}
return(result);
}
/// <summary>
/// Get an activation expression for this strategy
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <returns></returns>
public IActivationExpressionResult GetActivationExpression(IInjectionScope scope, IActivationExpressionRequest request)
{
var openMethod = typeof(KeyedLocateDelegateStrategy).GetRuntimeMethod(nameof(CreateKeyedDelegate),
new[] { typeof(IExportLocatorScope) });
var closedMethod = openMethod.MakeGenericMethod(request.ActivationType.GenericTypeArguments);
request.RequireExportScope();
var expression = Expression.Call(null, closedMethod, request.ScopeParameter);
return(request.Services.Compiler.CreateNewResult(request, expression));
}
/// <summary>
/// get activation strategy delegate
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <returns></returns>
public override IActivationExpressionResult GetActivationExpression(IInjectionScope scope, IActivationExpressionRequest request)
{
var closedClass = typeof(TypedDelegateExpression <>).MakeGenericType(request.ActivationType.GenericTypeArguments);
var closedMethod = closedClass.GetRuntimeMethod(nameof(TypedDelegateExpression <object> .CreateFunc), new Type[] { });
var instance = Activator.CreateInstance(closedClass, scope, request, this);
request.RequireExportScope();
request.RequireDisposalScope();
var callExpression =
Expression.Call(Expression.Constant(instance), closedMethod);
return(request.Services.Compiler.CreateNewResult(request, callExpression));
}
/// <summary>
/// Create instantiation expression
/// </summary>
/// <param name="scope">scope the configuration is associated with</param>
/// <param name="request">expression request</param>
/// <param name="activationConfiguration">configuration</param>
/// <returns>expression result</returns>
public override IActivationExpressionResult CreateExpression(IInjectionScope scope, IActivationExpressionRequest request,
TypeActivationConfiguration activationConfiguration)
{
request.RequireExportScope();
// manipulate scope parameter rather
var currentScope = request.ScopeParameter;
request.ScopeParameter = request.Constants.ScopeParameter;
var activationDelegate = CreateActivationDelegate(scope, request, activationConfiguration);
request.ScopeParameter = currentScope;
return(CreateCallExpression(scope, request, activationConfiguration, activationDelegate));
}
/// <summary>
/// Provide an expression that uses the lifestyle
/// </summary>
/// <param name="scope">scope for the strategy</param>
/// <param name="request">activation request</param>
/// <param name="activationExpression">expression to create strategy type</param>
/// <returns></returns>
public IActivationExpressionResult ProvideLifestyleExpression(IInjectionScope scope, IActivationExpressionRequest request, Func <IActivationExpressionRequest, IActivationExpressionResult> activationExpression)
{
var context = request.GetStaticInjectionContext();
var ancestorId = GetAncestorRequestId(context);
var newDelegate = request.Services.Compiler.CompileDelegate(scope, activationExpression(request));
MethodInfo closedMethod;
if (_guaranteeOnlyOne)
{
var openMethod = typeof(SingletonPerAncestor).GetRuntimeMethod(nameof(GetValueGuaranteeOnce),
new[]
{
typeof(IExportLocatorScope),
typeof(IDisposalScope),
typeof(IInjectionContext),
typeof(ActivationStrategyDelegate),
typeof(string)
});
closedMethod = openMethod.MakeGenericMethod(request.ActivationType);
}
else
{
var openMethod = typeof(SingletonPerAncestor).GetRuntimeMethod(nameof(GetValue),
new[]
{
typeof(IExportLocatorScope),
typeof(IDisposalScope),
typeof(IInjectionContext),
typeof(ActivationStrategyDelegate),
typeof(string)
});
closedMethod = openMethod.MakeGenericMethod(request.ActivationType);
}
var expression = Expression.Call(closedMethod, request.ScopeParameter,
request.DisposalScopeExpression, request.InjectionContextParameter,
Expression.Constant(newDelegate), Expression.Constant(ancestorId));
request.RequireInjectionContext();
request.RequireExportScope();
return(request.Services.Compiler.CreateNewResult(request, expression));
}
/// <summary>
/// Get an activation expression for this strategy
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <returns></returns>
public IActivationExpressionResult GetActivationExpression(IInjectionScope scope, IActivationExpressionRequest request)
{
var activationType = request.ActivationType;
var closedType = ReflectionHelper.CreateClosedExportTypeFromRequestingType(ActivationType, activationType);
if (closedType == null)
{
return(null);
}
var activation = GetActivationConfiguration(closedType);
scope.ScopeConfiguration.Trace?.Invoke($"Activating {closedType.FullName} with lifestyle '{Lifestyle}' for request type {activationType.FullName}");
Expression assignStatement = null;
ParameterExpression newScope = null;
if (ActivationConfiguration.CustomScopeName != null)
{
request.RequireExportScope();
newScope = Expression.Variable(typeof(IExportLocatorScope));
var beginScopeMethod =
typeof(IExportLocatorScope).GetTypeInfo().GetDeclaredMethod(nameof(IExportLocatorScope.BeginLifetimeScope));
assignStatement =
Expression.Assign(newScope,
Expression.Call(request.ScopeParameter, beginScopeMethod,
Expression.Constant(ActivationConfiguration.CustomScopeName)));
request.ScopeParameter = newScope;
}
var result = request.Services.ExpressionBuilder.DecorateExportStrategy(scope, request, this) ??
_builder.GetActivationExpression(scope, request, activation, activation.Lifestyle);
if (newScope != null)
{
result.AddExtraParameter(newScope);
result.AddExtraExpression(assignStatement, true);
}
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 closedClass = typeof(FuncExpression <, , ,>).MakeGenericType(request.ActivationType.GenericTypeArguments);
var closedMethod = closedClass.GetRuntimeMethod(nameof(FuncExpression <object, object, object, object> .CreateFunc), new[] { typeof(IExportLocatorScope), typeof(IDisposalScope), typeof(IInjectionContext) });
var instance = Activator.CreateInstance(closedClass, scope, request, request.Services.InjectionContextCreator, this);
request.RequireExportScope();
request.RequireDisposalScope();
var callExpression =
Expression.Call(Expression.Constant(instance), closedMethod, request.ScopeParameter,
request.DisposalScopeExpression, request.InjectionContextParameter);
return(request.Services.Compiler.CreateNewResult(request, callExpression));
}
/// <summary>
/// Get an activation expression for this strategy
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <returns></returns>
public IActivationExpressionResult GetActivationExpression(IInjectionScope scope, IActivationExpressionRequest request)
{
Expression expression;
request.RequireExportScope();
if (_func.Target != null)
{
expression = Expression.Call(Expression.Constant(_func.Target), _func.GetMethodInfo(),
request.ScopeParameter);
}
else
{
expression = Expression.Call(_func.GetMethodInfo(), request.ScopeParameter);
}
return(request.Services.Compiler.CreateNewResult(request, expression));
}
/// <summary>
/// Creates expression for calling method GetValueFromInjectionContext
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <returns></returns>
public virtual IActivationExpressionResult GetValueFromInjectionContext(IInjectionScope scope, IActivationExpressionRequest request)
{
var valueMethod = _contextValueProvider.GetType().GetRuntimeMethod(nameof(GetValueFromInjectionContext), new[]
{
typeof(IExportLocatorScope),
typeof(StaticInjectionContext),
typeof(object),
typeof(IInjectionContext),
typeof(object),
typeof(bool),
typeof(bool)
});
var closedMethod = valueMethod.MakeGenericMethod(request.ActivationType);
var key = request.LocateKey;
if (key is string)
{
key = ((string)key).ToLowerInvariant();
}
request.RequireExportScope();
var expression = Expression.Call(Expression.Constant(_contextValueProvider),
closedMethod,
request.ScopeParameter,
Expression.Constant(request.GetStaticInjectionContext()),
Expression.Constant(key, typeof(object)),
request.InjectionContextParameter,
Expression.Constant(request.DefaultValue?.DefaultValue, typeof(object)),
Expression.Constant(request.DefaultValue != null),
Expression.Constant(request.IsRequired));
var result = request.Services.Compiler.CreateNewResult(request, expression);
result.UsingFallbackExpression = true;
return(result);
}
/// <summary>
/// Provide an expression that uses the lifestyle
/// </summary>
/// <param name="scope">scope for the strategy</param>
/// <param name="request">activation request</param>
/// <param name="activationExpression">expression to create strategy type</param>
/// <returns></returns>
public IActivationExpressionResult ProvideLifestyleExpression(IInjectionScope scope, IActivationExpressionRequest request, Func <IActivationExpressionRequest, IActivationExpressionResult> activationExpression)
{
if (CompiledDelegate == null)
{
// new request as we don't want to carry any info over from parent request
var newRequest = request.NewRootedRequest(request.ActivationType, scope, true);
var localDelegate = request.Services.Compiler.CompileDelegate(scope, activationExpression(newRequest));
Interlocked.CompareExchange(ref CompiledDelegate, localDelegate, null);
}
var getValueFromScopeMethod =
typeof(SingletonPerNamedScopeLifestyle).GetRuntimeMethod(nameof(GetValueFromScope),
new[]
{
typeof(IExportLocatorScope),
typeof(ActivationStrategyDelegate),
typeof(string),
typeof(string),
typeof(bool),
typeof(IInjectionContext),
typeof(StaticInjectionContext)
});
var closedMethod = getValueFromScopeMethod.MakeGenericMethod(request.ActivationType);
var expression = Expression.Call(closedMethod,
request.ScopeParameter,
Expression.Constant(CompiledDelegate),
Expression.Constant(UniqueId),
Expression.Constant(_scopeName),
Expression.Constant(scope.ScopeConfiguration.SingletonPerScopeShareContext),
request.InjectionContextParameter,
Expression.Constant(request.GetStaticInjectionContext()));
request.RequireExportScope();
return(request.Services.Compiler.CreateNewResult(request, expression));
}
/// <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 invokeMethod = request.ActivationType.GetTypeInfo().GetDeclaredMethod("Invoke");
var list = new List <Type>(invokeMethod.GetParameters().Select(p => p.ParameterType));
list.Add(invokeMethod.ReturnType);
list.Add(request.ActivationType);
var closedClass = typeof(DelegateExpression <, ,>).MakeGenericType(list.ToArray());
var closedMethod = closedClass.GetRuntimeMethod(nameof(DelegateExpression <object, object, object> .CreateDelegate), new[] { typeof(IExportLocatorScope), typeof(IDisposalScope), typeof(IInjectionContext) });
var instance = Activator.CreateInstance(closedClass, scope, request, request.Services.InjectionContextCreator, this);
request.RequireExportScope();
request.RequireDisposalScope();
var callExpression =
Expression.Call(Expression.Constant(instance), closedMethod, request.ScopeParameter,
request.DisposalScopeExpression, request.InjectionContextParameter);
return(request.Services.Compiler.CreateNewResult(request, callExpression));
}
/// <summary>
/// Provide an expression that uses the lifestyle
/// </summary>
/// <param name="scope">scope for the strategy</param>
/// <param name="request">activation request</param>
/// <param name="activationExpression">expression to create strategy type</param>
/// <returns></returns>
public virtual IActivationExpressionResult ProvideLifestyleExpression(IInjectionScope scope, IActivationExpressionRequest request, Func <IActivationExpressionRequest, IActivationExpressionResult> activationExpression)
{
var local = request.PerDelegateData.GetExtraDataOrDefaultValue <ParameterExpression>("local" + UniqueId);
if (local != null)
{
return(request.Services.Compiler.CreateNewResult(request, local));
}
request.RequireExportScope();
if (CompiledDelegate == null)
{
// new request as we don't want to carry any info over from parent request
var newRequest = request.NewRootedRequest(request.ActivationType, scope, true);
var newResult = activationExpression(newRequest);
Delegate localDelegate = null;
if (ThreadSafe || newRequest.ExportScopeRequired() || newRequest.DisposalScopeRequired() ||
newRequest.InjectionContextRequired())
{
localDelegate = request.Services.Compiler.CompileDelegate(scope, newResult);
}
else
{
var openMethod = GetType().GetTypeInfo().GetDeclaredMethod(nameof(CompileFuncDelage));
var closed = openMethod.MakeGenericMethod(newResult.Expression.Type);
localDelegate = (Delegate)closed.Invoke(null, new object[] { request, scope, newResult });
}
Interlocked.CompareExchange(ref CompiledDelegate, localDelegate, null);
}
Expression createExpression;
if (ThreadSafe)
{
var getValueFromScopeMethod = typeof(SingletonPerScopeLifestyle).GetRuntimeMethod(nameof(GetValueFromScopeThreadSafe), new[]
{
typeof(IExportLocatorScope),
typeof(ActivationStrategyDelegate),
typeof(string),
typeof(bool),
typeof(IInjectionContext)
});
var closedMethod = getValueFromScopeMethod.MakeGenericMethod(request.ActivationType);
createExpression = Expression.Call(closedMethod,
request.ScopeParameter,
Expression.Constant(CompiledDelegate),
Expression.Constant(UniqueId),
Expression.Constant(scope.ScopeConfiguration.SingletonPerScopeShareContext),
request.InjectionContextParameter);
}
else
{
var invokeMethodFastLane = CompiledDelegate.GetMethodInfo().GetParameters().Length < 3;
if (invokeMethodFastLane)
{
var getOrCreateMethod = typeof(IExportLocatorScope).GetTypeInfo()
.GetDeclaredMethods(nameof(IExportLocatorScope.GetOrCreateScopedService)).First(m => m.GetParameters().Length == 2);
var closedMethod = getOrCreateMethod.MakeGenericMethod(request.ActivationType);
createExpression = Expression.Call(request.ScopeParameter, closedMethod,
Expression.Constant(UniqueIntIdValue), Expression.Constant(CompiledDelegate));
}
else
{
var getOrCreateMethod = typeof(IExportLocatorScope).GetRuntimeMethod(nameof(IExportLocatorScope.GetOrCreateScopedService),
new[] { typeof(int), typeof(ActivationStrategyDelegate), typeof(IInjectionContext) });
var closedMethod = getOrCreateMethod.MakeGenericMethod(request.ActivationType);
createExpression = Expression.Call(request.ScopeParameter, closedMethod,
Expression.Constant(UniqueIntIdValue), Expression.Constant(CompiledDelegate),
request.InjectionContextParameter);
}
}
local = Expression.Variable(request.ActivationType);
request.PerDelegateData.SetExtraData("local" + UniqueId, local);
var assignExpression = Expression.Assign(local, createExpression);
var result = request.Services.Compiler.CreateNewResult(request, local);
result.AddExtraParameter(local);
result.AddExtraExpression(assignExpression);
return(result);
}
/// <inheritdoc />
protected override IActivationExpressionResult CreateExpression(IInjectionScope scope, IActivationExpressionRequest request, ICompiledLifestyle lifestyle)
{
if (_proxyType == null)
{
lock (_proxyTypeLock)
{
if (_proxyType == null)
{
var builder = new DynamicTypeBuilder();
_proxyType = builder.CreateType(ActivationType, out _delegateInfo);
}
}
}
request.RequireExportScope();
request.RequireDisposalScope();
request.RequireInjectionContext();
var parameters = new List <Expression>
{
request.ScopeParameter,
request.DisposalScopeExpression,
request.InjectionContextParameter
};
var uniqueId = UniqueStringId.Generate();
foreach (var delegateInfo in _delegateInfo)
{
var locateType = delegateInfo.Method.ReturnType;
var newRequest = request.NewRequest(locateType, this, ActivationType, RequestType.Other, null, true);
newRequest.AddKnownValueExpression(
CreateKnownValueExpression(newRequest, ActivationType, uniqueId));
if (delegateInfo.Method.Name.StartsWith("Get"))
{
newRequest.SetLocateKey(delegateInfo.Method.Name.Substring("Get".Length));
}
if (delegateInfo.ParameterInfos != null)
{
foreach (var parameter in delegateInfo.ParameterInfos)
{
newRequest.AddKnownValueExpression(
CreateKnownValueExpression(newRequest, parameter.ParameterInfo.ParameterType, parameter.UniqueId, parameter.ParameterInfo.Name, parameter.ParameterInfo.Position));
}
}
var result = request.Services.ExpressionBuilder.GetActivationExpression(request.RequestingScope, newRequest);
var compiledDelegate = request.Services.Compiler.CompileDelegate(request.RequestingScope, result);
parameters.Add(Expression.Constant(compiledDelegate));
}
var constructor = _proxyType.GetTypeInfo().DeclaredConstructors.First();
request.RequireInjectionContext();
var newStatement = Expression.New(constructor, parameters);
var setMethod = typeof(IExtraDataContainer).GetRuntimeMethod(nameof(IExtraDataContainer.SetExtraData),
new[] { typeof(object), typeof(object), typeof(bool) });
var invokeStatement = Expression.Call(request.InjectionContextParameter, setMethod,
Expression.Constant(uniqueId), newStatement, Expression.Constant(true));
var castStatement = Expression.Convert(invokeStatement, ActivationType);
return(request.Services.Compiler.CreateNewResult(request, castStatement));
}
/// <summary>
/// Get expression result from request
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <param name="activationType"></param>
/// <param name="key"></param>
/// <returns></returns>
protected virtual IActivationExpressionResult GetValueFromRequest(IInjectionScope scope,
IActivationExpressionRequest request,
Type activationType,
object key)
{
var knownValues =
request.KnownValueExpressions.Where(
v => activationType.GetTypeInfo().IsAssignableFrom(v.ActivationType.GetTypeInfo())).ToArray();
if (knownValues.Length > 0)
{
if (knownValues.Length == 1)
{
return(knownValues[0].ValueExpression(request));
}
if (key != null)
{
IKnownValueExpression knownValue;
if (key is string keyString)
{
knownValue =
knownValues.FirstOrDefault(v =>
string.Compare(keyString, v.Key as string, StringComparison.CurrentCultureIgnoreCase) == 0);
}
else
{
knownValue = knownValues.FirstOrDefault(v => v.Key == key);
}
if (knownValue != null)
{
return(knownValue.ValueExpression(request));
}
}
if (request.Info is MemberInfo memberInfo)
{
var knownValue = knownValues.FirstOrDefault(v => Equals(v.Key, memberInfo.Name));
if (knownValue != null)
{
return(knownValue.ValueExpression(request));
}
}
if (request.Info is ParameterInfo parameterInfo)
{
var knownValue = knownValues.FirstOrDefault(v => Equals(v.Key, parameterInfo.Name));
if (knownValue != null)
{
return(knownValue.ValueExpression(request));
}
knownValue = knownValues.FirstOrDefault(v =>
Equals(v.Position.GetValueOrDefault(-1), parameterInfo.Position));
if (knownValue != null)
{
return(knownValue.ValueExpression(request));
}
}
return(knownValues[0].ValueExpression(request));
}
if (request.WrapperPathNode != null)
{
var configuration = request.WrapperPathNode.Strategy.GetActivationConfiguration(activationType);
if (configuration.ActivationType != null &&
(activationType.GetTypeInfo().IsAssignableFrom(configuration.ActivationType.GetTypeInfo()) ||
activationType.IsConstructedGenericType && activationType.GetGenericTypeDefinition() == configuration.ActivationType))
{
var wrapper = request.PopWrapperPathNode();
return(ProcessPathNode(scope, request, activationType, wrapper));
}
}
else if (request.DecoratorPathNode != null)
{
var configuration = request.DecoratorPathNode.Strategy.GetActivationConfiguration(activationType);
if (configuration.ActivationType != null &&
(activationType.GetTypeInfo().IsAssignableFrom(configuration.ActivationType.GetTypeInfo()) ||
activationType.IsConstructedGenericType && activationType.GetGenericTypeDefinition() == configuration.ActivationType))
{
var decorator = request.PopDecoratorPathNode();
return(ProcessPathNode(scope, request, activationType, decorator));
}
}
if (request.ActivationType == typeof(IInjectionScope))
{
if (!scope.ScopeConfiguration.Behaviors.AllowInjectionScopeLocation)
{
throw new ImportInjectionScopeException(request.GetStaticInjectionContext());
}
request.RequireExportScope();
var method = typeof(IExportLocatorScopeExtensions).GetRuntimeMethod(nameof(IExportLocatorScopeExtensions.GetInjectionScope), new[] { typeof(IExportLocatorScope) });
var expression = Expression.Call(method, request.ScopeParameter);
return(request.Services.Compiler.CreateNewResult(request, expression));
}
if (request.ActivationType == typeof(IExportLocatorScope) ||
request.ActivationType == typeof(ILocatorService))
{
request.RequireExportScope();
return(request.Services.Compiler.CreateNewResult(request, request.ScopeParameter));
}
if (request.ActivationType == typeof(IDisposalScope) ||
(request.ActivationType == typeof(IDisposable) &&
request.RequestingScope.ScopeConfiguration.InjectIDisposable))
{
request.RequireDisposalScope();
return(request.Services.Compiler.CreateNewResult(request, request.DisposalScopeExpression));
}
if (request.ActivationType == typeof(IInjectionContext))
{
request.RequireInjectionContext();
return(request.Services.Compiler.CreateNewResult(request, request.InjectionContextParameter));
}
if (request.ActivationType == typeof(StaticInjectionContext))
{
var staticContext = request.Parent != null?
request.Parent.GetStaticInjectionContext() :
request.GetStaticInjectionContext();
return(request.Services.Compiler.CreateNewResult(request, Expression.Constant(staticContext)));
}
if (request.IsDynamic)
{
var dynamicMethod =
typeof(ActivationExpressionBuilder).GetRuntimeMethod(nameof(GetDynamicValue),
new[]
{
typeof(IExportLocatorScope),
typeof(IDisposalScope),
typeof(StaticInjectionContext),
typeof(IInjectionContext),
typeof(object),
typeof(bool),
typeof(bool),
typeof(object)
});
var closedMethod = dynamicMethod.MakeGenericMethod(request.ActivationType);
Expression defaultExpression =
Expression.Constant(request.DefaultValue?.DefaultValue, typeof(object));
request.RequireExportScope();
request.RequireDisposalScope();
request.RequireInjectionContext();
var expression = Expression.Call(closedMethod,
request.ScopeParameter,
request.DisposalScopeExpression,
Expression.Constant(request.GetStaticInjectionContext()),
request.InjectionContextParameter,
Expression.Constant(request.LocateKey, typeof(object)),
Expression.Constant(request.IsRequired),
Expression.Constant(request.DefaultValue != null),
defaultExpression);
return(request.Services.Compiler.CreateNewResult(request, expression));
}
return(null);
}
