222

static IEnumerable<MethodInfo> GetExtensionMethods(Assembly assembly, Type extendedType)
 {
     var query = from type in assembly.GetTypes()
                 where !type.IsGenericType && !type.IsNested
                 from method in type.GetMethods(BindingFlags.Static
                     | BindingFlags.Public | BindingFlags.NonPublic)
                 where method.IsDefined(typeof(System.Runtime.CompilerServices.ExtensionAttribute), false)
                 where method.GetParameters()[0].ParameterType == extendedType
                 select method;
     return query;
 } public static Expression<Func<T, bool>>  IsGreaterThan<T>( string propertyName, byte[] values) where T : class
 {
     if(values == null || !values.Any())
     {
         throw new ArgumentException("The values collection must not be null or empty.", nameof(values));
     }
 
     // 获取泛型类型 T 的 PropertyInfo  
     var propertyInfo = typeof(T).GetProperty(propertyName);
     if (propertyInfo == null)
     {
         throw new ArgumentException($"Property '{propertyName}' not found on type '{typeof(T).Name}'.", nameof(propertyName));
     }
 
     // 创建参数表达式，表示 T 类型的实例  
     var parameter = Expression.Parameter(typeof(T), "entity");
 
     // 创建属性访问表达式，表示访问 T 类型的 propertyName 属性  
     var propertyAccess = Expression.Property(parameter, propertyInfo);
 
     // 将 values 集合转换为 Expression 常量数组  
     var constantExpression = Expression.NewArrayInit(typeof(byte), values.Select(v => (Expression)Expression.Constant(v, typeof(byte))));
 
     // 创建 Contains 方法调用表达式，注意这里我们假设 TValue 是可比较的，并且支持 Contains 方法  
     // 实际上，在 LINQ to Entities 中，我们需要使用 DbSet.Contains 或者手动映射到 SQL 的 IN 子句  
     // 这里我们使用一个假设的 Contains 方法作为演示，实际中需要替换为合适的实现  \\
     Assembly assembly = Assembly.GetExecutingAssembly();
     var dd = typeof(byte[]).GetMethods().ToList();
    
     var containsMethod = GetExtensionMethods(assembly, typeof(byte[]))
 
         .Single(m => m.Name == "Compare" && m.GetParameters().Length == 2)
         ;
 
     var containsExpression = Expression.Call(
         null, // 对于静态方法，第一个参数是 null  
         containsMethod,
         constantExpression, // 数组参数  
         propertyAccess // 要检查是否包含的属性值  
     );
 
     // 注意：上面的 ContainsExpression 在 EF Core 中不会直接工作，因为它引用的是 Enumerable.Contains  
     // 而不是 EF Core 能够转换为 SQL IN 子句的表达式。因此，在实际应用中，你可能需要手动构建 Expression.Call  
     // 调用数据库上下文中的某个 DbSet 的 Contains 方法，或者使用其他方法将表达式转换为 SQL IN 子句。  
 
     // 创建一个 lambda 表达式  
     var lambda = Expression.Lambda<Func<T, int>>(containsExpression, parameter);
 
 
     var parameter2 = lambda.Parameters[0]; // 获取原始lambda的参数  
     var body = Expression.LessThan(lambda.Body, Expression.Constant(0)); // 创建新的body，检查是否大于10  
     Expression<Func<T, bool>> newLambda = Expression.Lambda<Func<T, bool>>(body, parameter2);
     // 返回 lambda 表达式，但请注意，它可能不会在 EF Core 中直接工作，除非你进一步处理它  
     return newLambda;
 }

public static Expression<Func<T, bool>> BuildInExpression<T, TValue>(string propertyName, IEnumerable<TValue> values)
  {
      if (values == null || !values.Any())
      {
          throw new ArgumentException("The values collection must not be null or empty.", nameof(values));
      }
 
      // 获取泛型类型 T 的 PropertyInfo  
      var propertyInfo = typeof(T).GetProperty(propertyName);
      if (propertyInfo == null)
      {
          throw new ArgumentException($"Property '{propertyName}' not found on type '{typeof(T).Name}'.", nameof(propertyName));
      }
 
      // 创建参数表达式，表示 T 类型的实例  
      var parameter = Expression.Parameter(typeof(T), "entity");
 
      // 创建属性访问表达式，表示访问 T 类型的 propertyName 属性  
      var propertyAccess = Expression.Property(parameter, propertyInfo);
 
      // 将 values 集合转换为 Expression 常量数组  
      var constantExpression = Expression.NewArrayInit(typeof(TValue), values.Select(v => (Expression)Expression.Constant(v, typeof(TValue))));
 
      // 创建 Contains 方法调用表达式，注意这里我们假设 TValue 是可比较的，并且支持 Contains 方法  
      // 实际上，在 LINQ to Entities 中，我们需要使用 DbSet.Contains 或者手动映射到 SQL 的 IN 子句  
      // 这里我们使用一个假设的 Contains 方法作为演示，实际中需要替换为合适的实现  
      var containsMethod = typeof(Enumerable).GetMethods()
          .Single(m => m.Name == "Contains" && m.GetParameters().Length == 2)
          .MakeGenericMethod(typeof(TValue));
 
      var containsExpression = Expression.Call(
          null, // 对于静态方法，第一个参数是 null  
          containsMethod,
          constantExpression, // 数组参数  
          propertyAccess // 要检查是否包含的属性值  
      );
 
      // 注意：上面的 ContainsExpression 在 EF Core 中不会直接工作，因为它引用的是 Enumerable.Contains  
      // 而不是 EF Core 能够转换为 SQL IN 子句的表达式。因此，在实际应用中，你可能需要手动构建 Expression.Call  
      // 调用数据库上下文中的某个 DbSet 的 Contains 方法，或者使用其他方法将表达式转换为 SQL IN 子句。  
 
      // 创建一个 lambda 表达式  
      var lambda = Expression.Lambda<Func<T, bool>>(containsExpression, parameter);
 
      // 返回 lambda 表达式，但请注意，它可能不会在 EF Core 中直接工作，除非你进一步处理它  
      return lambda;
  }