- 增加 ExpressionCallAttribute 特性，实现表达式函数自定义解析；

Author: 28810

FreeSql.Tests/FreeSql.Tests/UnitTest2.cs

@@ -10,6 +10,7 @@
 using System.Linq.Expressions;
 using System.Threading.Tasks;
 using System.ComponentModel.DataAnnotations;
+using System.Threading;
 
 namespace FreeSql.Tests
 {
@@ -167,6 +168,34 @@ public class UserLike
         [Fact]
         public void Test02()
         {
+            g.mysql.Aop.ParseExpression = (s, e) =>
+            {
+                if (e.Expression.NodeType == ExpressionType.Call)
+                {
+                    var callExp = e.Expression as MethodCallExpression;
+                    if (callExp.Object?.Type == typeof(DateTime) &&
+                        callExp.Method.Name == "ToString" &&
+                        callExp.Arguments.Count == 1 &&
+                        callExp.Arguments[0].Type == typeof(string) &&
+                        callExp.Arguments[0].NodeType == ExpressionType.Constant)
+                    {
+                        var format = (callExp.Arguments[0] as ConstantExpression)?.Value?.ToString();
+
+                        if (string.IsNullOrEmpty(format) == false)
+                        {
+                            var tmp = e.FreeParse(callExp.Object);
+
+                            switch (format)
+                            {
+                                case "yyyy-MM-dd HH:mm":
+                                    tmp = $"date_format({tmp}, '%Y-%m-%d %H:%i')";
+                                    break;
+                            }
+                            e.Result = tmp;
+                        }
+                    }
+                }
+            };
 
 
             var dbs = g.sqlserver.DbFirst.GetDatabases();
@@ -233,6 +262,21 @@ public void Test02()
                 .IncludeMany(m => m.Permissions.Where(p => p.SysModuleId == m.Id),
                     then => then.LeftJoin(p => p.Button.Id == p.SysModuleButtonId))
                 .ToList();
+
+
+            var sql = g.sqlite.Select<SysModule>()
+                .ToSql(a => a.CreateTime.FormatDateTime("yyyy-MM-dd"));
+        }
+    }
+
+    [ExpressionCall]
+    public static class DbFunc
+    {
+        static ThreadLocal<ExpressionCallContext> context = new ThreadLocal<ExpressionCallContext>();
+
+        public static string FormatDateTime(this DateTime that, string arg1)
+        {
+            return $"date_format({context.Value.Values["arg1"]})";
         }
     }
 }

FreeSql/DataAnnotations/ExpressionCallAttribute.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace FreeSql.DataAnnotations
+{
+    /// <summary>
+    /// 自定义表达式函数解析<para></para>
+    /// 注意：请使用静态扩展类
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class)]
+    public class ExpressionCallAttribute : Attribute
+    {
+    }
+
+    public class ExpressionCallContext
+    {
+        /// <summary>
+        /// 数据库类型，可用于适配多种数据库环境
+        /// </summary>
+        public DataType DataType { get; set; }
+
+        /// <summary>
+        /// 已解析的表达式中参数内容
+        /// </summary>
+        public Dictionary<string, string> Values { get; } = new Dictionary<string, string>();
+    }
+}

FreeSql/Extensions/FreeSqlGlobalExtensions.cs

@@ -44,6 +44,16 @@ public static partial class FreeSqlGlobalExtensions
     public static bool IsArrayOrList(this Type that) => that == null ? false : (that.IsArray || typeof(IList).IsAssignableFrom(that));
     public static Type NullableTypeOrThis(this Type that) => that?.IsNullableType() == true ? that.GetGenericArguments().First() : that;
     internal static string NotNullAndConcat(this string that, params object[] args) => string.IsNullOrEmpty(that) ? null : string.Concat(new object[] { that }.Concat(args));
+    static ConcurrentDictionary<Type, ParameterInfo[]> _dicGetDefaultValueFirstConstructorsParameters = new ConcurrentDictionary<Type, ParameterInfo[]>();
+    public static object CreateInstanceGetDefaultValue(this Type that)
+    {
+        if (that == null) return null;
+        if (that == typeof(string)) return default(string);
+        if (that.IsArray) return Array.CreateInstance(that, 0);
+        var ctorParms = _dicGetDefaultValueFirstConstructorsParameters.GetOrAdd(that, tp => tp.GetConstructors().FirstOrDefault()?.GetParameters());
+        if (ctorParms == null || ctorParms.Any() == false) return Activator.CreateInstance(that, null);
+        return Activator.CreateInstance(that, ctorParms.Select(a => Activator.CreateInstance(a.ParameterType, null)).ToArray());
+    }
 
     static ConcurrentDictionary<Type, Dictionary<string, PropertyInfo>> _dicGetPropertiesDictIgnoreCase = new ConcurrentDictionary<Type, Dictionary<string, PropertyInfo>>();
     public static Dictionary<string, PropertyInfo> GetPropertiesDictIgnoreCase(this Type that) => that == null ? null : _dicGetPropertiesDictIgnoreCase.GetOrAdd(that, tp =>