-

OrmTest/ExpressionTest/Select.cs

@@ -36,7 +36,7 @@ namespace OrmTest.ExpressionTest
         }
         private static void MultipleDynamic()
         {
-            Expression<Func<Student, School, object>> exp = (it, school) => new{ Name = "a", Id = it.Id, SchoolId = school.Id };
+            Expression<Func<Student, School, object>> exp = (it, school) => new{ Name = "a", Id = it.Id/2, SchoolId = school.Id };
             ExpressionContext expContext = new ExpressionContext(exp, ResolveExpressType.SelectMultiple);
             expContext.Resolve();
             var selectorValue = expContext.Result.GetString();

SqlSugar/ExpressionsToSql/Common/ExpressionParameter.cs

@@ -17,5 +17,6 @@ namespace SqlSugar
         public object TempDate { get; set; }
         public ExpressionParameter BaseParameter { get; set; }
         public int SwitchCaseNumber { get; set; }
+        public bool IsOnlyAddTempDate { get; set; }
     }
 }

SqlSugar/ExpressionsToSql/Common/ExpressionResult.cs

@@ -81,14 +81,14 @@ namespace SqlSugar
         {
             switch (this._ResolveExpressType)
             {
+                case ResolveExpressType.SelectSingle:
+                case ResolveExpressType.SelectMultiple:
+                    parameter = parameter + ",";
+                    break;
                 case ResolveExpressType.WhereSingle:
                     break;
                 case ResolveExpressType.WhereMultiple:
                     break;
-                case ResolveExpressType.SelectSingle:
-                    break;
-                case ResolveExpressType.SelectMultiple:
-                    break;
                 case ResolveExpressType.FieldSingle:
                     break;
                 case ResolveExpressType.FieldMultiple:

SqlSugar/ExpressionsToSql/ResolveItems/BinaryExpressionResolve.cs

@@ -9,7 +9,15 @@ namespace SqlSugar
     {
         public BinaryExpressionResolve(ExpressionParameter parameter) : base(parameter)
         {
-            parameter.BinaryExpressionInfoList =new List<KeyValuePair<string, BinaryExpressionInfo>>();
+            if (parameter.BaseParameter.TempDate != null && parameter.BaseParameter.TempDate.Equals("simple"))
+            {
+                parameter.IsOnlyAddTempDate = true;
+                new SimpleBinaryExpressionResolve(parameter);
+                parameter.IsOnlyAddTempDate = false;
+            }
+            else
+            {
+                parameter.BinaryExpressionInfoList = new List<KeyValuePair<string, BinaryExpressionInfo>>();
                 var expression = this.Expression as BinaryExpression;
                 var operatorValue = ExpressionTool.GetOperator(expression.NodeType);
                 var isComparisonOperator =
@@ -27,7 +35,7 @@ namespace SqlSugar
                 base.IsLeft = null;
                 string leftString = GetLeftString(parameter);
                 string rightString = GetRightString(parameter);
-            string binarySql =string.Format(ExpressionConst.BinaryFormatString,leftString,operatorValue,rightString);
+                string binarySql = string.Format(ExpressionConst.BinaryFormatString, leftString, operatorValue, rightString);
                 string sqlWhereString = base.Context.Result.GetResultString();
                 if (sqlWhereString.Contains(ExpressionConst.Format0))
                 {
@@ -42,6 +50,7 @@ namespace SqlSugar
                     base.Context.Result.Replace(ExpressionConst.Format1, ExpressionConst.Format0);
                 }
             }
+        }
 
         private string GetRightString(ExpressionParameter parameter)
         {

SqlSugar/ExpressionsToSql/ResolveItems/MemberInitExpressionResolve.cs

@@ -53,11 +53,14 @@ namespace SqlSugar
                     parameter.Context.Result.Append(parameterName);
                     this.Context.Parameters.Add(new SugarParameter(parameterName, parameter.TempDate));
                 }
-                else if(item is MemberExpression)
+                else if (item is MemberExpression)
                 {
-                    base.Expression= memberAssignment.Expression;
+                    base.Expression = memberAssignment.Expression;
                     base.Start();
                 }
+                else {
+                     Check.ThrowNotSupportedException(item.GetType().Name);
+                }
             }
         }
     }

SqlSugar/ExpressionsToSql/ResolveItems/NewExpressionResolve.cs

@@ -49,19 +49,21 @@ namespace SqlSugar
                         parameter.Context.Result.Append(parameterName);
                         this.Context.Parameters.Add(new SugarParameter(parameterName, parameter.TempDate));
                     }
-                    else
+                    else if (item is MemberExpression)
                     {
-                        var memberExpression = (MemberExpression)item;
-                        var fieldNme = (memberExpression).Member.Name;
-                        if (isSingle)
+                        base.Expression = item;
+                        base.Start();
+                    }
+                    else if (item is BinaryExpression)
                     {
-                            parameter.Context.Result.Append(fieldNme);
+                        base.Expression = item;
+                        parameter.TempDate = "simple";
+                        base.Start();
+                        parameter.TempDate =null;
                     }
                     else
                     {
-                            var shortName = memberExpression.Expression.ToString();
-                            parameter.Context.Result.Append(shortName + "." + fieldNme);
-                        }
+                        Check.ThrowNotSupportedException(item.GetType().Name);
                     }
                 }
             }

SqlSugar/ExpressionsToSql/ResolveItems/SimpleBinaryExpressionResolve.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Linq.Expressions;
+namespace SqlSugar
+{
+    public class SimpleBinaryExpressionResolve : BaseResolve
+    {
+        public SimpleBinaryExpressionResolve(ExpressionParameter parameter) : base(parameter)
+        {
+            var expression = base.Expression as  BinaryExpression;
+            switch (parameter.Context.ResolveType)
+            {
+                case ResolveExpressType.SelectSingle:
+                case ResolveExpressType.SelectMultiple:
+
+                    base.Expression = expression.Right;
+                    base.Start();
+                    var rightValue = parameter.TempDate;
+                    base.Expression = expression.Left;
+                    base.Start();
+                    var leftValue = parameter.TempDate;
+                    break;
+                case ResolveExpressType.WhereSingle:
+                case ResolveExpressType.WhereMultiple:
+                case ResolveExpressType.FieldSingle:
+                case ResolveExpressType.FieldMultiple:
+                default:
+       
+                    break;
+            }
+        }
+    }
+}

SqlSugar/SqlSugar.csproj

@@ -126,6 +126,7 @@
     <Compile Include="ExpressionsToSql\ResolveItems\MemberExpressionResolve.cs" />
     <Compile Include="ExpressionsToSql\ResolveItems\MethodCallExpressionResolve.cs" />
     <Compile Include="ExpressionsToSql\ResolveItems\NewExpressionResolve.cs" />
+    <Compile Include="ExpressionsToSql\ResolveItems\SimpleBinaryExpressionResolve.cs" />
     <Compile Include="ExpressionsToSql\ResolveItems\UnaryExpressionResolve.cs" />
     <Compile Include="ExpressionsToSql\Common\ExpResolveAccessory.cs" />
     <Compile Include="ExpressionsToSql\ExpressionContext.cs" />