Exemple #1
0
        public Expression GetExpression(
            IResolutionStrategy resolutionStrategy,
            TypeInformation typeInfo,
            ResolutionContext resolutionContext)
        {
            var args             = typeInfo.Type.GetGenericArguments();
            var tupleConstructor = typeInfo.Type.GetConstructor(args);
            var length           = args.Length;
            var expressions      = new Expression[length];

            for (var i = 0; i < length; i++)
            {
                var argumentInfo = typeInfo.CloneForType(args[i]);
                var expr         = resolutionStrategy.BuildExpressionForType(resolutionContext, argumentInfo);

                if (expr != null)
                {
                    expressions[i] = expr;
                }
                else
                {
                    return(null);
                }
            }

            return(tupleConstructor.MakeNew(expressions));
        }
Exemple #2
0
 private Expression GetLazyFuncExpression(TypeInformation argumentType,
                                          ResolutionContext resolutionContext, IResolutionStrategy resolutionStrategy) =>
 resolutionContext.CurrentContainerContext.ContainerConfiguration.CircularDependenciesWithLazyEnabled
         ? resolutionContext.CurrentScopeParameter
 .CallMethod(Constants.ResolveMethod, argumentType.Type.AsConstant(),
             argumentType.DependencyName.AsConstant(), false.AsConstant(),
             Constants.ObjectType.InitNewArray(resolutionContext.ParameterExpressions
                                               .SelectMany(x => x.Select(i => i.I2.ConvertTo(Constants.ObjectType)))))
 .ConvertTo(argumentType.Type)
         : resolutionStrategy.BuildExpressionForType(resolutionContext, argumentType);
Exemple #3
0
        public Expression GetExpression(IResolutionStrategy resolutionStrategy, TypeInformation typeInfo,
                                        ResolutionContext resolutionContext)
        {
            var args             = typeInfo.Type.GetGenericArguments();
            var wrappedType      = args.LastElement();
            var funcArgumentInfo = typeInfo.CloneForType(wrappedType);

            var parameters = args.SelectButLast(a => a.AsParameter());
            var expression = resolutionStrategy.BuildExpressionForType(resolutionContext
                                                                       .BeginContextWithFunctionParameters(parameters), funcArgumentInfo);

            return(expression?.AsLambda(typeInfo.Type, parameters));
        }
Exemple #4
0
 public Expression GetExpression(
     IResolutionStrategy resolutionStrategy,
     TypeInformation typeInfo,
     ResolutionContext resolutionContext) =>
 resolutionStrategy.BuildExpressionForType(resolutionContext.BeginCrossContainerContext(resolutionContext
                                                                                        .CurrentContainerContext.ParentContext), typeInfo);