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