C# Expression.ToReadOnlyCollection方法代码示例

        protected virtual MethodDefinitionExpression CreateCreateClientMethod()
        {
            var client = Expression.Variable(FickleType.Define("PKWebServiceClient"), "client");
            var self = FickleExpression.Variable(currentType, "self");
            var options = FickleExpression.Parameter(FickleType.Define("NSDictionary"), "options");
            var url = Expression.Parameter(typeof(string), "urlIn");
            var parameters = new Expression[] { url, options };
            var operationQueue = FickleExpression.Call(options, "objectForKey", "OperationQueue");

            var variables = new [] { client };

            var body = FickleExpression.Block
            (
                variables,
                Expression.Assign(client, FickleExpression.StaticCall("PKWebServiceClient", "PKWebServiceClient", "clientWithURL", new
                {
                    url = FickleExpression.New("NSURL", "initWithString", url),
                    options = options,
                    operationQueue
                })),
                Expression.Return(Expression.Label(), client)
            );

            return new MethodDefinitionExpression("createClientWithURL", parameters.ToReadOnlyCollection(), FickleType.Define("PKWebServiceClient"), body, false, null);
        }

        protected virtual Expression CreateTryParseMethod()
        {
            var value = Expression.Parameter(typeof(string), "value");
            var methodName = currentTypeDefinition.Type.Name.Capitalize() + "TryParse";
            var result = Expression.Parameter(currentTypeDefinition.Type.MakeByRefType(), "result");

            var parameters = new Expression[]
            {
                value,
                result
            };

            var defaultBody = Expression.Return(Expression.Label(), Expression.Constant(false)).ToStatement();
            var cases = new List<SwitchCase>();

            foreach (var enumValue in ((FickleType)currentTypeDefinition.Type).ServiceEnum.Values)
            {
                cases.Add(Expression.SwitchCase(Expression.Assign(result, Expression.Convert(Expression.Constant((int)enumValue.Value), currentTypeDefinition.Type)).ToStatement(), Expression.Constant(enumValue.Name)));
            }

            var switchStatement = Expression.Switch(value, defaultBody, cases.ToArray());

            var body = FickleExpression.Block(switchStatement, Expression.Return(Expression.Label(), Expression.Constant(true)));

            return new MethodDefinitionExpression(methodName, parameters.ToReadOnlyCollection(), AccessModifiers.Static | AccessModifiers.ClasseslessFunction, typeof(bool), body, false, "__unused", null);
        }

        protected virtual Expression CreateToStringMethod()
        {
            var value = Expression.Parameter(currentTypeDefinition.Type, "value");
            var methodName = currentTypeDefinition.Type.Name.Capitalize() + "ToString";

            var parameters = new Expression[]
            {
                value
            };

            var array = FickleExpression.Variable("NSMutableArray", "array");
            var temp = FickleExpression.Variable(currentTypeDefinition.Type, "temp");

            var expressions = new List<Expression>
            {
                Expression.Assign(array, Expression.New(array.Type))
            };

            foreach (var enumValue in ((FickleType)currentTypeDefinition.Type).ServiceEnum.Values)
            {
                var currentEnumValue = Expression.Constant((int)enumValue.Value);

                expressions.Add
                (
                    Expression.IfThen
                    (
                        Expression.Equal(Expression.And(currentEnumValue, Expression.Convert(value, typeof(int))), Expression.Convert(currentEnumValue, typeof(int))),
                        FickleExpression.StatementisedGroupedExpression
                        (
                            GroupedExpressionsExpressionStyle.Wide,
                            FickleExpression.Call(array, typeof(void), "addObject", Expression.Constant(enumValue.Name)),
                            Expression.Assign(temp, Expression.Convert(Expression.Or(Expression.Convert(temp, typeof(int)), currentEnumValue), currentTypeDefinition.Type))
                        ).ToBlock()
                    )
                );
            }

            expressions.Add(Expression.IfThen(Expression.NotEqual(value, temp), FickleExpression.Return(FickleExpression.Call(Expression.Convert(value, typeof(object)), typeof(string), "stringValue", null)).ToStatementBlock()));
            expressions.Add(FickleExpression.Return(FickleExpression.Call(array, "componentsJoinedByString", Expression.Constant(","))));

            var defaultBody = FickleExpression.StatementisedGroupedExpression
            (
                GroupedExpressionsExpressionStyle.Wide,
                expressions.ToArray()
            );

            var cases = new List<SwitchCase>();

            foreach (var enumValue in ((FickleType)currentTypeDefinition.Type).ServiceEnum.Values)
            {
                cases.Add(Expression.SwitchCase(Expression.Return(Expression.Label(), Expression.Constant(enumValue.Name)).ToStatement(), Expression.Constant((int)enumValue.Value, currentTypeDefinition.Type)));
            }

            var switchStatement = Expression.Switch(value, defaultBody, cases.ToArray());

            var body = FickleExpression.Block(new [] { array, temp }, switchStatement);

            return new MethodDefinitionExpression(methodName, parameters.ToReadOnlyCollection(), AccessModifiers.Static | AccessModifiers.ClasseslessFunction, typeof(string), body, false, "__unused", null);
        }

        protected virtual Expression CreateConstructor()
        {
            var valParam = Expression.Parameter(typeof(int), "value");

            var parameters = new Expression[]
            {
                valParam
            };

            var valueMember = Expression.Variable(enumValueField.PropertyType, "this." + enumValueField.PropertyName);

            var body = FickleExpression.Block(Expression.Assign(valueMember, valParam).ToStatement());

            return new MethodDefinitionExpression(currentTypeDefinition.Type.Name, parameters.ToReadOnlyCollection(), null, body, false, null);
        }

        private Expression CreateParameterisedConstructor()
        {
            var valParam = Expression.Parameter(webServiceClientType, "client");

            var parameters = new Expression[]
            {
                valParam
            };

            var client = Expression.Variable(webServiceClientType, "webServiceClient");

            var body = FickleExpression.Block(Expression.Assign(client, valParam).ToStatement());

            return new MethodDefinitionExpression(currentTypeDefinitionExpression.Type.Name, parameters.ToReadOnlyCollection(), AccessModifiers.Public, null, body, false, null, null);
        }

        protected virtual MethodDefinitionExpression CreateCreateErrorResponseMethod()
        {
            var errorCode = Expression.Parameter(typeof(string), "errorCode");
            var message = Expression.Parameter(typeof(string), "errorMessage");
            var stackTrace = Expression.Parameter(typeof(string), "stackTrace");

            var parameters = new Expression[]
            {
                errorCode,
                message,
                stackTrace
            };

            var responseStatusType = FickleType.Define("ResponseStatus");

            var result = FickleExpression.Variable(currentType, "result");
            var responseStatus = FickleExpression.Variable(responseStatusType, "responseStatus");

            var newResult = Expression.Assign(result, Expression.New(currentType));
            var newResponseStatus = Expression.Assign(responseStatus, Expression.New(responseStatusType));

            var methodVariables = new List<ParameterExpression>
            {
                result,
                responseStatus
            };

            var methodStatements = new List<Expression>
            {
                newResponseStatus,
                FickleExpression.Call(responseStatus, "setErrorCode", errorCode),
                FickleExpression.Call(responseStatus, "setMessage", message),
                FickleExpression.Call(responseStatus, "setStackTrace", stackTrace),
                newResult,
                FickleExpression.Call(result, "setResponseStatus", responseStatus),
                Expression.Return(Expression.Label(), result)
            };

            var body = FickleExpression.Block(methodVariables.ToArray(), methodStatements.ToArray());

            return new MethodDefinitionExpression("createErrorResponse", parameters.ToReadOnlyCollection(), AccessModifiers.Public | AccessModifiers.Static, currentType, body, false, null);
        }

		MethodCallExpression ReplaceQueryableMethod (MethodCallExpression old)
		{
			Expression target = null;
			if (old.Object != null)
				target = Visit (old.Object);

			var method = ReplaceQueryableMethod (old.Method);
			var parameters = method.GetParameters ();
			var arguments = new Expression [old.Arguments.Count];

			for (int i = 0; i < arguments.Length; i++) {
				arguments [i] = UnquoteIfNeeded (
					Visit (old.Arguments [i]),
					parameters [i].ParameterType);
			}

			return new MethodCallExpression (target, method, arguments.ToReadOnlyCollection ());
		}

        private Expression CreateParameterisedConstructor()
        {
            var httpClientParam = Expression.Parameter(this.httpClientType, HttpClientFieldName);
            var httpStreamSerializerParam = Expression.Parameter(this.httpStreamSerializerType, HttpStreamSerializerFieldName);

            var parameters = new Expression[]
            {
                httpClientParam,
                httpStreamSerializerParam
            };

            var clientField = Expression.Variable(this.httpClientType, "this." + HttpClientFieldName);
            var serailizerField = Expression.Variable(this.httpStreamSerializerType, "this." + HttpStreamSerializerFieldName);

            var body = FickleExpression.Block(new Expression[]
            {
                Expression.Assign(clientField, httpClientParam).ToStatement(),
                Expression.Assign(serailizerField, httpStreamSerializerParam).ToStatement()

            } );

            return new MethodDefinitionExpression(this.currentTypeDefinitionExpression.Type.Name, parameters.ToReadOnlyCollection(), AccessModifiers.Public, null, body, false, null, null);
        }

        protected virtual MethodDefinitionExpression CreateCreateErrorResponseWithErrorCodeMethod()
        {
            var client = Expression.Parameter(FickleType.Define("PKWebServiceClient"), "client");
            var errorCode = Expression.Parameter(typeof(string), "createErrorResponseWithErrorCode");
            var message = Expression.Parameter(typeof(string), "andMessage");

            var parameters = new Expression[]
            {
                client,
                errorCode,
                message
            };

            var clientOptions = FickleExpression.Property(client, FickleType.Define("NSDictionary"), "options");
            var response = FickleExpression.Variable(FickleType.Define("id"), "response");
            var responseClass = FickleExpression.Call(clientOptions, "Class", "objectForKey", "$ResponseClass");
            var responseStatus = FickleExpression.Call(response, "ResponseStatus", "responseStatus", null);
            var newResponseStatus = FickleExpression.New("ResponseStatus", "init", null);

            var body = FickleExpression.Block
            (
                new [] { response },
                Expression.Assign(response, FickleExpression.Call(FickleExpression.Call(responseClass, response.Type, "alloc", null), response.Type, "init", null)),
                Expression.IfThen(Expression.IsTrue(Expression.Equal(responseStatus, Expression.Constant(null, responseStatus.Type))), FickleExpression.Block(FickleExpression.Call(response, "setResponseStatus", newResponseStatus))),
                FickleExpression.StatementisedGroupedExpression
                (
                    FickleExpression.Call(responseStatus, typeof(string), "setErrorCode", errorCode),
                    FickleExpression.Call(responseStatus, typeof(string), "setMessage", message)
                ),
                Expression.Return(Expression.Label(), response)
            );

            return new MethodDefinitionExpression("webServiceClient", parameters.ToReadOnlyCollection(), FickleType.Define("id"), body, false, null);
        }

        protected virtual MethodDefinitionExpression CreateParseResultMethod()
        {
            var client = Expression.Parameter(FickleType.Define("PKWebServiceClient"), "client");
            var data = Expression.Parameter(FickleType.Define("NSData"), "parseResult");
            var contentType = Expression.Parameter(typeof(string), "withContentType");
            var statusCode = Expression.Parameter(typeof(int), "andStatusCode");
            var response = FickleExpression.Variable("id", "response");
            var options = FickleExpression.Property(client, "NSDictionary", "options");

            var parameters = new Expression[]
            {
                client,
                data,
                contentType,
                statusCode
            };

            var bodyExpressions = new List<Expression>();
            var delegateType = new FickleDelegateType(FickleType.Define("id"), new FickleParameterInfo(client.Type, "client"), new FickleParameterInfo(FickleType.Define("NSData"), "data"));
            var block = Expression.Variable(delegateType, "block");

            bodyExpressions.Add(Expression.Assign(block, FickleExpression.Call(options, FickleType.Define("id"), "objectForKey", Expression.Constant("$ParseResultBlock"))));
            bodyExpressions.Add(Expression.Assign(response, FickleExpression.Call(block, "id", "Invoke", new { client, data })).ToStatement());

            var setResponseStatus = Expression.IfThen
            (
                Expression.Equal(FickleExpression.Call(response, "id", "responseStatus", null), Expression.Constant(null, FickleType.Define("id"))),
                FickleExpression.Call(response, "setResponseStatus", FickleExpression.New("ResponseStatus", "init", null)).ToStatementBlock()
            );

            var populateResponseStatus = FickleExpression.Call(FickleExpression.Call(response, "id", "responseStatus", null), "setHttpStatus", statusCode);

            bodyExpressions.Add(setResponseStatus);
            bodyExpressions.Add(populateResponseStatus);
            bodyExpressions.Add(FickleExpression.Return(response));

            var body = FickleExpression.Block
            (
                new[] { response, block },
                bodyExpressions.ToArray()
            );

            return new MethodDefinitionExpression
            (
                "webServiceClient",
                parameters.ToReadOnlyCollection(),
                FickleType.Define("id"),
                body,
                false,
                null
            );
        }

        protected virtual Expression CreateTryParseMethod()
        {
            var value = Expression.Parameter(typeof(string), "value");
            var methodName = currentTypeDefinition.Type.Name.Capitalize() + "TryParse";
            var result = Expression.Parameter(currentTypeDefinition.Type.MakeByRefType(), "result");
            var retval = Expression.Variable(currentTypeDefinition.Type, "retval");

            var parameters = new Expression[]
            {
                value,
                result
            };

            var parts = Expression.Variable(FickleType.Define("NSArray"), "parts");
            var splitCall = FickleExpression.Call(value, FickleType.Define("NSArray"), "componentsSeparatedByString", new { value = Expression.Constant(",") });
            var part = Expression.Variable(typeof(string), "part");
            var flagCases = new List<SwitchCase>();
            var number = Expression.Variable(FickleType.Define("NSNumber"), "number");

            foreach (var enumValue in ((FickleType)currentTypeDefinition.Type).ServiceEnum.Values)
            {
                flagCases.Add(Expression.SwitchCase(Expression.Assign(retval, Expression.Convert(Expression.Or(Expression.Convert(retval, typeof(int)), Expression.Constant((int)enumValue.Value)), currentTypeDefinition.Type)).ToStatement(), Expression.Constant(enumValue.Name)));
            }

            var foreachBody = FickleExpression.StatementisedGroupedExpression
            (
                Expression.Switch(part, FickleExpression.Return(Expression.Constant(false)).ToStatement(), flagCases.ToArray())
            ).ToBlock();

            var defaultBody = FickleExpression.StatementisedGroupedExpression
            (
                GroupedExpressionsExpressionStyle.Wide,
                Expression.Assign(number, FickleExpression.Call(Expression.New(FickleType.Define("NSNumberFormatter")), number.Type, "numberFromString", value)),
                Expression.IfThen
                (
                    Expression.NotEqual(number, Expression.Constant(null, number.Type)),
                    FickleExpression.StatementisedGroupedExpression
                    (
                        GroupedExpressionsExpressionStyle.Wide,
                        Expression.Assign(result, Expression.Convert(FickleExpression.Call(number, typeof(int), "intValue", null), currentTypeDefinition.Type)),
                        Expression.Return(Expression.Label(), Expression.Constant(true))
                    ).ToBlock()
                ),
                Expression.Assign(parts, splitCall),
                Expression.Assign(retval, Expression.Convert(Expression.Constant(0), currentTypeDefinition.Type)),
                FickleExpression.ForEach(part, parts, foreachBody),
                Expression.Assign(result, retval),
                Expression.Return(Expression.Label(), Expression.Constant(true))
            );

            var cases = new List<SwitchCase>();

            foreach (var enumValue in ((FickleType)currentTypeDefinition.Type).ServiceEnum.Values)
            {
                cases.Add(Expression.SwitchCase(Expression.Assign(result, Expression.Convert(Expression.Constant((int)enumValue.Value), currentTypeDefinition.Type)).ToStatement(), Expression.Constant(enumValue.Name)));
            }

            var switchStatement = Expression.Switch(value, defaultBody, cases.ToArray());

            var body = FickleExpression.Block(new[] { parts, number, retval }, switchStatement, Expression.Return(Expression.Label(), Expression.Constant(true)));

            return new MethodDefinitionExpression(methodName, parameters.ToReadOnlyCollection(), AccessModifiers.Static | AccessModifiers.ClasseslessFunction, typeof(bool), body, false, "__unused", null);
        }

		protected virtual FunctionResolveResult ResolveSqlFunction(SqlFunctionCallExpression functionExpression)
		{
			var function = functionExpression.Function;
			var arguments = functionExpression.Arguments;

			switch (function)
			{
			case SqlFunction.IsNull:
				return new FunctionResolveResult("", true, arguments)
				{
					functionSuffix = " IS NULL"
				};
			case SqlFunction.IsNotNull:
				return new FunctionResolveResult("", true, arguments)
				{
					functionSuffix = " IS NOT NULL"
				};
			case SqlFunction.In:
				return new FunctionResolveResult("IN", true, arguments);
			case SqlFunction.Exists:
				return new FunctionResolveResult("EXISTSOPERATOR", true, arguments)
				{
					functionPrefix = " EXISTS "
				};
			case SqlFunction.UserDefined:
				return new FunctionResolveResult(functionExpression.UserDefinedFunctionName, false, arguments);
			case SqlFunction.Coalesce:
				return new FunctionResolveResult("COALESCE", false, arguments);
			case SqlFunction.Like:
				return new FunctionResolveResult(this.sqlDialect.GetSyntaxSymbolString(SqlSyntaxSymbol.Like), true, arguments);
			case SqlFunction.CompareObject:
				var expressionType = (ExpressionType)((ConstantExpression)arguments[0].StripConstantWrappers()).Value;
				var args = new Expression[2];

				args[0] = arguments[1];
				args[1] = arguments[2];

				switch (expressionType)
				{
					case ExpressionType.LessThan:
						return new FunctionResolveResult("<", true, args.ToReadOnlyCollection());
					case ExpressionType.LessThanOrEqual:
						return new FunctionResolveResult("<=", true, args.ToReadOnlyCollection());
					case ExpressionType.GreaterThan:
						return new FunctionResolveResult(">", true, args.ToReadOnlyCollection());
					case ExpressionType.GreaterThanOrEqual:
						return new FunctionResolveResult(">=", true, args.ToReadOnlyCollection());
				}
				throw new InvalidOperationException();
			case SqlFunction.NotLike:
				return new FunctionResolveResult("NOT " + this.sqlDialect.GetSyntaxSymbolString(SqlSyntaxSymbol.Like), true, arguments);
			case SqlFunction.ServerNow:
				return new FunctionResolveResult("NOW", false, arguments);
			case SqlFunction.ServerUtcNow:
				return new FunctionResolveResult("UTCNOW", false, arguments);
			case SqlFunction.StartsWith:
			{
				var newArgument = new SqlFunctionCallExpression(typeof(string), SqlFunction.Concat, arguments[1], Expression.Constant("%"));
				var optimisedNewArgument = SqlRedundantFunctionCallRemover.Remove(newArgument);

				if (optimisedNewArgument != newArgument)
				{
					if (SqlExpressionFinder.FindExists(arguments[1], c => c.NodeType == (ExpressionType)SqlExpressionType.ConstantPlaceholder))
					{
						canReuse = false;
						this.parameterIndexToPlaceholderIndexes = null;
					}
				}

				var list = new List<Expression>
				{
					arguments[0],
					optimisedNewArgument
				};

				return new FunctionResolveResult(this.sqlDialect.GetSyntaxSymbolString(SqlSyntaxSymbol.Like), true, list.ToReadOnlyCollection());
			}
			case SqlFunction.ContainsString:
			{
				var newArgument = new SqlFunctionCallExpression(typeof(string), SqlFunction.Concat, arguments[1], Expression.Constant("%"));
				newArgument = new SqlFunctionCallExpression(typeof(string), SqlFunction.Concat, Expression.Constant("%"), newArgument);
				var optimisedNewArgument = SqlRedundantFunctionCallRemover.Remove(newArgument);

				if (optimisedNewArgument != newArgument)
				{
					if (SqlExpressionFinder.FindExists(arguments[1], c => c.NodeType == (ExpressionType)SqlExpressionType.ConstantPlaceholder))
					{
						canReuse = false;
						this.parameterIndexToPlaceholderIndexes = null;
					}
				}

				var list = new List<Expression>
				{
					arguments[0],
					optimisedNewArgument
				};

				return new FunctionResolveResult(this.sqlDialect.GetSyntaxSymbolString(SqlSyntaxSymbol.Like), true, list.ToReadOnlyCollection());
			}
//.........这里部分代码省略.........