/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertUnaryPlus(converter converter, Expression expression) { expression = ((UnaryExpression)expression).Expression; converter.Stream.SimpleWriteNotNull("+("); converters[(int)expression.NodeType](converter, expression); converter.Stream.Write(')'); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="binaryExpression">表达式</param> /// <param name="type">操作字符串</param> private void convertBinaryExpression(converter converter, BinaryExpression binaryExpression, string type) { charStream stream = converter.Stream; Expression left = binaryExpression.Left, right = binaryExpression.Right; stream.Write('('); if (left.IsSimple) { converters[(int)left.NodeType](converter, left); stream.Write('='); stream.Write('1'); } else { converters[(int)left.NodeType](converter, left); } stream.Write(')'); stream.SimpleWriteNotNull(type); stream.Write('('); if (right.IsSimple) { converters[(int)right.NodeType](converter, right); stream.Write('='); stream.Write('1'); } else { converters[(int)right.NodeType](converter, right); } stream.Write(')'); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="unaryExpression">表达式</param> private void convertNegate(converter converter, Expression expression) { expression = ((UnaryExpression)expression).Expression; converter.Stream.Write("-("); converters[(int)expression.NodeType](converter, expression); converter.Stream.Write(')'); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="binaryExpression">表达式</param> /// <param name="char1">操作字符1</param> /// <param name="char2">操作字符2</param> protected void convertBinaryExpression(converter converter, BinaryExpression binaryExpression, char char1, char char2 = ' ') { charStream stream = converter.Stream; Expression left = binaryExpression.Left, right = binaryExpression.Right; if (left.IsSimple) { converters[(int)left.NodeType](converter, left); } else { stream.Write('('); converters[(int)left.NodeType](converter, left); stream.Write(')'); } stream.Write(char1); stream.Write(char2); if (right.IsSimple) { converters[(int)right.NodeType](converter, right); } else { stream.Write('('); converters[(int)right.NodeType](converter, right); stream.Write(')'); } }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertConvert(converter converter, Expression expression) { ConvertExpression convertExpression = (ConvertExpression)expression; converter.Stream.SimpleWriteNotNull("cast("); converters[(int)convertExpression.Expression.NodeType](converter, convertExpression.Expression); converter.Stream.SimpleWriteNotNull(" as "); converter.Stream.SimpleWriteNotNull(convertExpression.ConvertType.formCSharpType().ToString()); converter.Stream.Write(')'); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertUnbox(converter converter, Expression expression) { expression = ((UnaryExpression)expression).Expression; if (expression.IsSimple) { converters[(int)expression.NodeType](converter, expression); } else { converter.Stream.Write('('); converters[(int)expression.NodeType](converter, expression); converter.Stream.Write(')'); } }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertIsFalse(converter converter, Expression expression) { expression = ((UnaryExpression)expression).Expression; if (expression.IsSimple) { converters[(int)expression.NodeType](converter, expression); converter.Stream.SimpleWriteNotNull("=0"); } else { converter.Stream.Write('('); converters[(int)expression.NodeType](converter, expression); converter.Stream.SimpleWriteNotNull(")=0"); } }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="memberExpression">表达式</param> /// <param name="name">成员名称</param> private void convertMemberAccess(converter converter, MemberExpression memberExpression, string name) { if (memberExpression.Expression.GetType() == typeof(ParameterExpression)) { string sqlName = fastCSharp.code.cSharp.sqlModel.ToSqlName(name); if (converter.FirstMemberName == null) { converter.FirstMemberName = name; converter.FirstMemberSqlName = sqlName; } converter.Stream.SimpleWriteNotNull(sqlName); } else { fastCSharp.log.Error.Throw("未知成员表达式类型 " + memberExpression.Expression.GetType().Name, new System.Diagnostics.StackFrame(), true); } }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertConditional(converter converter, Expression expression) { charStream stream = converter.Stream; ConditionalExpression conditionalExpression = (ConditionalExpression)expression; Expression test = conditionalExpression.Test, ifTrue = conditionalExpression.IfTrue, ifFalse = conditionalExpression.IfFalse; stream.SimpleWriteNotNull("case when "); if (test.IsSimple) { converters[(int)test.NodeType](converter, test); stream.Write('='); stream.Write('1'); } else { converters[(int)test.NodeType](converter, test); } stream.SimpleWriteNotNull(" then "); if (ifTrue.IsSimple) { converters[(int)ifTrue.NodeType](converter, ifTrue); } else { stream.Write('('); converters[(int)ifTrue.NodeType](converter, ifTrue); stream.Write(')'); } stream.SimpleWriteNotNull(" else "); if (ifFalse.IsSimple) { converters[(int)ifFalse.NodeType](converter, ifFalse); } else { stream.Write('('); converters[(int)ifFalse.NodeType](converter, ifFalse); stream.Write(')'); } stream.SimpleWriteNotNull(" end"); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> /// <param name="name">成员名称</param> private void convertMemberAccess(converter converter, MemberExpression memberExpression, string name) { if (memberExpression.Expression.GetType() == typeof(ParameterExpression)) { if (converter.parameterMemberNames.indexOf(name) == -1) { converter.parameterMemberNames = converter.parameterMemberNames.add(name); } charStream stream = converter.Stream; if (converter.NameType != converter.getNameType.None) { stream.Write(converter.Name ?? converter.GetName(((ParameterExpression)memberExpression.Expression).Name)); stream.Write('.'); } stream.Write(name); } else { fastCSharp.log.Default.Throw("未知成员表达式类型 " + memberExpression.Expression.GetType().Name, false, true); } }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertNotEqual(converter converter, Expression expression) { BinaryExpression binaryExpression = (BinaryExpression)expression; if (binaryExpression.Left.IsConstantNull) { charStream stream = converter.Stream; if (binaryExpression.Right.IsSimple) { converters[(int)binaryExpression.Right.NodeType](converter, binaryExpression.Right); } else { stream.Write('('); converters[(int)binaryExpression.Right.NodeType](converter, binaryExpression.Right); stream.Write(')'); } stream.SimpleWriteNotNull(" is not null"); } else if (binaryExpression.Right.IsConstantNull) { charStream stream = converter.Stream; if (binaryExpression.Left.IsSimple) { converters[(int)binaryExpression.Left.NodeType](converter, binaryExpression.Left); } else { stream.Write('('); converters[(int)binaryExpression.Left.NodeType](converter, binaryExpression.Left); stream.Write(')'); } stream.SimpleWriteNotNull(" is not null"); } else { convertNotEqual(converter, (BinaryExpression)expression); } }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertCall(converter converter, Expression expression) { MethodCallExpression methodCallExpression = (MethodCallExpression)expression; charStream stream = converter.Stream; stream.SimpleWriteNotNull(methodCallExpression.Method.Name); stream.Write('('); if (methodCallExpression.Arguments != null) { bool isNext = false; foreach (Expression argumentExpression in methodCallExpression.Arguments) { if (isNext) { stream.Write(','); } converters[(int)argumentExpression.NodeType](converter, argumentExpression); isNext = true; } } stream.Write(')'); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> /// <param name="type">操作字符串</param> private void convertBinaryExpression(converter converter, BinaryExpression binaryExpression, string type) { charStream stream = converter.Stream; Expression left = binaryExpression.Left, right = binaryExpression.Right; stream.Write('('); if (left.IsSimple) { converters[(int)left.NodeType](converter, left); stream.Write('='); stream.Write('1'); } else converters[(int)left.NodeType](converter, left); stream.Write(')'); stream.Write(type); stream.Write('('); if (right.IsSimple) { converters[(int)right.NodeType](converter, right); stream.Write('='); stream.Write('1'); } else converters[(int)right.NodeType](converter, right); stream.Write(')'); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertExclusiveOr(converter converter, Expression expression) { convertBinaryExpression(converter, (BinaryExpression)expression, '^'); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertRightShift(converter converter, Expression expression) { convertBinaryExpression(converter, (BinaryExpression)expression, '>', '>'); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertModulo(converter converter, Expression expression) { convertBinaryExpression(converter, (BinaryExpression)expression, '%'); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertOr(converter converter, Expression expression) { convertBinaryExpression(converter, (BinaryExpression)expression, '|'); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="unaryExpression">表达式</param> private void convertConvert(converter converter, Expression expression) { ConvertExpression convertExpression = (ConvertExpression)expression; converter.Stream.Write("cast("); converters[(int)convertExpression.Expression.NodeType](converter, convertExpression.Expression); converter.Stream.Write(" as "); converter.Stream.Write(convertExpression.ConvertType.formCSharpType().ToString()); converter.Stream.Write(')'); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertFieldAccess(converter converter, Expression expression) { fieldExpression fieldExpression = (fieldExpression)expression; convertMemberAccess(converter, fieldExpression, fieldExpression.FieldInfo.Name); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertPropertyAccess(converter converter, Expression expression) { propertyExpression propertyExpression = (propertyExpression)expression; convertMemberAccess(converter, propertyExpression, propertyExpression.PropertyInfo.Name); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertPower(converter converter, Expression expression) { fastCSharp.log.Error.Throw(log.exceptionType.ErrorOperation); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertLeftShift(converter converter, Expression expression) { convertBinaryExpression(converter, (BinaryExpression)expression, '<', '<'); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertDivide(converter converter, Expression expression) { convertBinaryExpression(converter, (BinaryExpression)expression, '/'); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="unaryExpression">表达式</param> private void convertUnaryPlus(converter converter, Expression expression) { expression = ((UnaryExpression)expression).Expression; converter.Stream.Write("+("); converters[(int)expression.NodeType](converter, expression); converter.Stream.Write(')'); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertMultiply(converter converter, Expression expression) { convertBinaryExpression(converter, (BinaryExpression)expression, '*'); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertCall(converter converter, Expression expression) { MethodCallExpression methodCallExpression = (MethodCallExpression)expression; charStream stream = converter.Stream; stream.Write(methodCallExpression.Method.Name); stream.Write('('); if (methodCallExpression.Arguments != null) { bool isNext = false; foreach (Expression argumentExpression in methodCallExpression.Arguments) { if (isNext) stream.Write(','); converters[(int)argumentExpression.NodeType](converter, argumentExpression); isNext = true; } } stream.Write(')'); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertSubtract(converter converter, Expression expression) { convertBinaryExpression(converter, (BinaryExpression)expression, '-'); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertLessThanOrEqual(converter converter, Expression expression) { convertBinaryExpression(converter, (BinaryExpression)expression, '<', '='); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertPower(converter converter, Expression expression) { fastCSharp.log.Default.Throw(log.exceptionType.ErrorOperation); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertGreaterThan(converter converter, Expression expression) { convertBinaryExpression(converter, (BinaryExpression)expression, '>'); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertAnd(converter converter, Expression expression) { convertBinaryExpression(converter, (BinaryExpression)expression, '&'); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertAndAlso(converter converter, Expression expression) { convertBinaryExpression(converter, (BinaryExpression)expression, "and"); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> protected virtual void convertNotEqual(converter converter, BinaryExpression expression) { convertBinaryExpression(converter, expression, '<', '>'); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> /// <param name="char1">操作字符1</param> /// <param name="char2">操作字符2</param> private void convertBinaryExpression(converter converter, BinaryExpression binaryExpression, char char1, char char2 = ' ') { charStream stream = converter.Stream; Expression left = binaryExpression.Left, right = binaryExpression.Right; if (left.IsSimple) { converters[(int)left.NodeType](converter, left); } else { stream.Write('('); converters[(int)left.NodeType](converter, left); stream.Write(')'); } stream.Write(char1); stream.Write(char2); if (right.IsSimple) { converters[(int)right.NodeType](converter, right); } else { stream.Write('('); converters[(int)right.NodeType](converter, right); stream.Write(')'); } }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> /// <param name="name">成员名称</param> private void convertMemberAccess(converter converter, MemberExpression memberExpression, string name) { if (memberExpression.Expression.GetType() == typeof(ParameterExpression)) { if (converter.parameterMemberNames.indexOf(name) == -1) { converter.parameterMemberNames = converter.parameterMemberNames.add(name); } charStream stream = converter.Stream; if (converter.NameType != converter.getNameType.None) { stream.Write(converter.Name ?? converter.GetName(((ParameterExpression)memberExpression.Expression).Name)); stream.Write('.'); } stream.Write(name); } else fastCSharp.log.Default.Throw("未知成员表达式类型 " + memberExpression.Expression.GetType().Name, false, true); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="unaryExpression">表达式</param> private void convertIsFalse(converter converter, Expression expression) { expression = ((UnaryExpression)expression).Expression; if (expression.IsSimple) { converters[(int)expression.NodeType](converter, expression); converter.Stream.Write("=0"); } else { converter.Stream.Write('('); converters[(int)expression.NodeType](converter, expression); converter.Stream.Write(")=0"); } }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertConditional(converter converter, Expression expression) { charStream stream = converter.Stream; ConditionalExpression conditionalExpression = (ConditionalExpression)expression; Expression test = conditionalExpression.Test, ifTrue = conditionalExpression.IfTrue, ifFalse = conditionalExpression.IfFalse; stream.Write("case when "); if (test.IsSimple) { converters[(int)test.NodeType](converter, test); stream.Write('='); stream.Write('1'); } else converters[(int)test.NodeType](converter, test); stream.Write(" then "); if (ifTrue.IsSimple) converters[(int)ifTrue.NodeType](converter, ifTrue); else { stream.Write('('); converters[(int)ifTrue.NodeType](converter, ifTrue); stream.Write(')'); } stream.Write(" else "); if (ifFalse.IsSimple) converters[(int)ifFalse.NodeType](converter, ifFalse); else { stream.Write('('); converters[(int)ifFalse.NodeType](converter, ifFalse); stream.Write(')'); } stream.Write(" end"); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertOrElse(converter converter, Expression expression) { convertBinaryExpression(converter, (BinaryExpression)expression, "or"); }
/// <summary> /// 转换表达式 /// </summary> /// <param name="converter">表达式转换器</param> /// <param name="expression">表达式</param> private void convertEqual(converter converter, Expression expression) { BinaryExpression binaryExpression = (BinaryExpression)expression; if (binaryExpression.Left.IsConstantNull) { charStream stream = converter.Stream; if (binaryExpression.Right.IsSimple) { converters[(int)binaryExpression.Right.NodeType](converter, binaryExpression.Right); } else { stream.Write('('); converters[(int)binaryExpression.Right.NodeType](converter, binaryExpression.Right); stream.Write(')'); } stream.Write(" is null"); } else if (binaryExpression.Right.IsConstantNull) { charStream stream = converter.Stream; if (binaryExpression.Left.IsSimple) { converters[(int)binaryExpression.Left.NodeType](converter, binaryExpression.Left); } else { stream.Write('('); converters[(int)binaryExpression.Left.NodeType](converter, binaryExpression.Left); stream.Write(')'); } stream.Write(" is null"); } else convertBinaryExpression(converter, (BinaryExpression)expression, '='); }