将字符串规则映射到LINQ表达式，包括包含自己的授权方法的表达式

using System;
using System.Linq;
using System.Linq.Expressions;

public class Program
{
    public static void Main()
    {
        string rule = "Age > 18 && Name.StartsWith(\"J\")";

        // 创建参数表达式
        ParameterExpression parameter = Expression.Parameter(typeof(Person), "p");

        // 解析规则字符串并构建表达式树
        Expression expression = ParseRule(rule, parameter);

        // 创建Lambda表达式
        var lambda = Expression.Lambda<Func<Person, bool>>(expression, parameter);

        // 构建查询
        IQueryable<Person> query = GetPersons().AsQueryable();
        var result = query.Where(lambda).ToList();

        // 输出结果
        foreach (var person in result)
        {
            Console.WriteLine(person.Name);
        }
    }

    public static Expression ParseRule(string rule, ParameterExpression parameter)
    {
        // 解析规则字符串并构建表达式树的逻辑
        // 这里只是一个简单示例，实际应用中可能需要更复杂的逻辑

        // 分割规则字符串
        string[] parts = rule.Split(new[] { "&&", "||" }, StringSplitOptions.RemoveEmptyEntries);

        // 构建表达式树
        Expression expression = null;
        foreach (var part in parts)
        {
            Expression condition = ParseCondition(part, parameter);
            expression = expression == null ? condition : Expression.AndAlso(expression, condition);
        }

        return expression;
    }

    public static Expression ParseCondition(string condition, ParameterExpression parameter)
    {
        // 解析条件字符串并构建表达式树的逻辑
        // 这里只是一个简单示例，实际应用中可能需要更复杂的逻辑

        string[] parts = condition.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
        string property = parts[0];
        string op = parts[1];
        string value = parts[2].Trim('\"');

        Expression propertyExpression = Expression.Property(parameter, property);
        Expression valueExpression = Expression.Constant(value);

        switch (op)
        {
            case ">":
                return Expression.GreaterThan(propertyExpression, valueExpression);
            case "StartsWith":
                MethodInfo startsWithMethod = typeof(string).GetMethod("StartsWith", new[] { typeof(string) });
                return Expression.Call(propertyExpression, startsWithMethod, valueExpression);
            // 其他比较操作符的处理逻辑
            default:
                throw new NotSupportedException("Unsupported operator: " + op);
        }
    }

    public static IQueryable<Person> GetPersons()
    {
        // 返回一个包含Person对象的数据源
        // 实际应用中可能是从数据库查询或其他数据源获取数据

        return new[]
        {
            new Person { Name = "John", Age = 25 },
            new Person { Name = "Jane", Age = 20 },
            new Person { Name = "Jack", Age = 30 }
        }.AsQueryable();
    }

    public class Person
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
}