예제 #1
0
        protected IEnumerable <TType> GetResults(ParameterBuilder paramaters)
        {
            var keyValuePairs = paramaters.Build();

            return(client.Execute <TType>(keyValuePairs));
        }
예제 #2
0
        protected IEnumerable GetResults(Type type, ParameterBuilder paramaters)
        {
            var keyValuePairs = paramaters.Build();

            return(client.Execute(type, keyValuePairs));
        }
예제 #3
0
        public object ProcessMethodCall <T>(MethodCallExpression methodCall, ParameterBuilder builder, Func <ParameterBuilder, IEnumerable <T> > resultLoader, Func <Type, ParameterBuilder, IEnumerable> intermediateResultLoader)
        {
            if (methodCall == null)
            {
                return(null);
            }

            var method = methodCall.Method.Name;

            switch (method)
            {
            case "First":
            case "FirstOrDefault":
                builder.TakeParameter = "1";
                return(methodCall.Arguments.Count >= 2
                                ? GetMethodResult(methodCall, builder, resultLoader, intermediateResultLoader)
                                : GetResult(methodCall, builder, resultLoader, intermediateResultLoader));

            case "Single":
            case "SingleOrDefault":
                builder.TakeParameter = "2";
                return(methodCall.Arguments.Count >= 2
                            ? GetMethodResult(methodCall, builder, resultLoader, intermediateResultLoader)
                            : GetResult(methodCall, builder, resultLoader, intermediateResultLoader));

            case "Last":
            case "LastOrDefault":
                return(methodCall.Arguments.Count >= 2
                            ? GetMethodResult(methodCall, builder, resultLoader, intermediateResultLoader)
                            : GetResult(methodCall, builder, resultLoader, intermediateResultLoader));

            case "Count":
            case "LongCount":
                builder.IncludeCount = true;
                return(methodCall.Arguments.Count >= 2
                            ? GetMethodResult(methodCall, builder, resultLoader, intermediateResultLoader)
                            : GetResult(methodCall, builder, resultLoader, intermediateResultLoader));

            case "Where":
            {
                var result = ProcessMethodCall(methodCall.Arguments[0] as MethodCallExpression, builder, resultLoader, intermediateResultLoader);
                if (result != null)
                {
                    return(InvokeEager(methodCall, result));
                }

                var newFilter = _writer.Write(methodCall.Arguments[1]);

                builder.FilterParameter = string.IsNullOrWhiteSpace(builder.FilterParameter)
                                                    ? newFilter
                                                    : string.Format("({0}) and ({1})", builder.FilterParameter, newFilter);
            }

            break;

            case "Select":
            {
                var result = ProcessMethodCall(methodCall.Arguments[0] as MethodCallExpression, builder, resultLoader, intermediateResultLoader);
                if (result != null)
                {
                    return(InvokeEager(methodCall, result));
                }

                if (!string.IsNullOrWhiteSpace(builder.SelectParameter))
                {
                    return(ExecuteMethod(methodCall, builder, resultLoader, intermediateResultLoader));
                }

                var unaryExpression = methodCall.Arguments[1] as UnaryExpression;
                if (unaryExpression != null)
                {
                    var lambdaExpression = unaryExpression.Operand as LambdaExpression;
                    if (lambdaExpression != null)
                    {
                        return(ResolveProjection(builder, lambdaExpression));
                    }
                }
            }

            break;

            case "OrderBy":
            case "ThenBy":
            {
                var result = ProcessMethodCall(methodCall.Arguments[0] as MethodCallExpression, builder, resultLoader, intermediateResultLoader);
                if (result != null)
                {
                    return(InvokeEager(methodCall, result));
                }

                var item = _writer.Write(methodCall.Arguments[1]);
                builder.OrderByParameter.Add(item);
            }

            break;

            case "OrderByDescending":
            case "ThenByDescending":
            {
                var result = ProcessMethodCall(methodCall.Arguments[0] as MethodCallExpression, builder, resultLoader, intermediateResultLoader);
                if (result != null)
                {
                    return(InvokeEager(methodCall, result));
                }

                var visit = _writer.Write(methodCall.Arguments[1]);
                builder.OrderByParameter.Add(visit + " desc");
            }

            break;

            case "Take":
            {
                var result = ProcessMethodCall(methodCall.Arguments[0] as MethodCallExpression, builder, resultLoader, intermediateResultLoader);
                if (result != null)
                {
                    return(InvokeEager(methodCall, result));
                }

                builder.TakeParameter = _writer.Write(methodCall.Arguments[1]);
            }

            break;

            case "Skip":
            {
                var result = ProcessMethodCall(methodCall.Arguments[0] as MethodCallExpression, builder, resultLoader, intermediateResultLoader);
                if (result != null)
                {
                    return(InvokeEager(methodCall, result));
                }

                builder.SkipParameter = _writer.Write(methodCall.Arguments[1]);
            }

            break;

            case "Expand":
            {
                var result = ProcessMethodCall(methodCall.Arguments[0] as MethodCallExpression, builder, resultLoader, intermediateResultLoader);
                if (result != null)
                {
                    return(InvokeEager(methodCall, result));
                }

                var expression = methodCall.Arguments[1];


                var objectMember = Expression.Convert(expression, typeof(object));
                var getterLambda = Expression.Lambda <Func <object> >(objectMember).Compile();

                builder.ExpandParameter = getterLambda().ToString();
            }

            break;

            default:
                return(ExecuteMethod(methodCall, builder, resultLoader, intermediateResultLoader));
            }

            return(null);
        }