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