Root / src / Dpz.Core.Entity.Base / ExpressTreeQuery / ComparisonStrategy / BasicComparison.cs
using System.Collections;
using System.Linq.Expressions;

namespace Dpz.Core.Entity.Base.ExpressTreeQuery.ComparisonStrategy;

public class EqualComparison : IComparisonStrategy
{
    public Expression BuildExpression(Expression memberExpression, object? value)
    {
        return Expression.Equal(memberExpression, Expression.Constant(value));
    }
}

public class NotEqualComparison : IComparisonStrategy
{
    public Expression BuildExpression(Expression memberExpression, object? value)
    {
        return Expression.NotEqual(memberExpression, Expression.Constant(value));
    }
}

public class GreaterThanComparison : IComparisonStrategy
{
    public Expression BuildExpression(Expression memberExpression, object? value)
    {
        return Expression.GreaterThan(memberExpression, Expression.Constant(value));
    }
}

public class ContainsComparison : IComparisonStrategy
{
    public Expression BuildExpression(Expression memberExpression, object? value)
    {
        if (value is string stringValue)
        {
            var containsMethod = typeof(string).GetMethod("Contains", [typeof(string)]);
            if (containsMethod != null)
            {
                return Expression.Call(
                    memberExpression,
                    containsMethod,
                    Expression.Constant(stringValue)
                );
            }
        }

        if (value is IEnumerable enumerable)
        {
            var containsMethod = typeof(Enumerable)
                .GetMethods()
                .FirstOrDefault(m => m.Name == "Contains" && m.GetParameters().Length == 2)
                ?.MakeGenericMethod(memberExpression.Type);
            if (containsMethod != null)
            {
                return Expression.Call(
                    containsMethod,
                    Expression.Constant(enumerable),
                    memberExpression
                );
            }
        }

        return Expression.Constant(false);
    }
}
⚠⚠    以下内容为AI分析的结果，请根据实际情况进行判断。

Expression Tree Comparison Strategies 解释

这段代码实现了一系列用于构建表达式树(Expression Tree)的比较策略，主要用于在运行时动态构建LINQ查询条件。以下是详细解释：

核心接口

所有比较策略都实现了IComparisonStrategy接口，该接口定义了一个方法：

Expression BuildExpression(Expression memberExpression, object? value)

各比较策略实现

1. EqualComparison (等于比较)

public Expression BuildExpression(Expression memberExpression, object? value)
{
    return Expression.Equal(memberExpression, Expression.Constant(value));
}
  • 功能：构建一个等于比较的表达式
  • 示例：x => x.Property == value
  • 使用Expression.Equal创建等于表达式

2. NotEqualComparison (不等于比较)

public Expression BuildExpression(Expression memberExpression, object? value)
{
    return Expression.NotEqual(memberExpression, Expression.Constant(value));
}
  • 功能：构建一个不等于比较的表达式
  • 示例：x => x.Property != value
  • 使用Expression.NotEqual创建不等于表达式

3. GreaterThanComparison (大于比较)

public Expression BuildExpression(Expression memberExpression, object? value)
{
    return Expression.GreaterThan(memberExpression, Expression.Constant(value));
}
  • 功能：构建一个大于比较的表达式
  • 示例：x => x.Property > value
  • 使用Expression.GreaterThan创建大于表达式

4. ContainsComparison (包含比较)

public Expression BuildExpression(Expression memberExpression, object? value)
{
    // 字符串包含处理
    if (value is string stringValue)
    {
        var containsMethod = typeof(string).GetMethod("Contains", [typeof(string)]);
        if (containsMethod != null)
        {
            return Expression.Call(
                memberExpression,
                containsMethod,
                Expression.Constant(stringValue)
            );
        }
    }

    // 集合包含处理
    if (value is IEnumerable enumerable)
    {
        var containsMethod = typeof(Enumerable)
            .GetMethods()
            .FirstOrDefault(m => m.Name == "Contains" && m.GetParameters().Length == 2)
            ?.MakeGenericMethod(memberExpression.Type);
        if (containsMethod != null)
        {
            return Expression.Call(
                containsMethod,
                Expression.Constant(enumerable),
                memberExpression
            );
        }
    }

    // 默认返回false
    return Expression.Constant(false);
}
  • 功能：构建一个包含比较的表达式，支持两种场景：
    1. 字符串包含：检查字符串属性是否包含特定子串
      • 示例：x => x.Property.Contains("substring")
    2. 集合包含：检查集合是否包含特定元素
      • 示例：x => enumerable.Contains(x.Property)
  • 如果value不是字符串或集合，则返回false常量表达式

应用场景

这些策略类通常用于：

  • 动态构建LINQ查询条件
  • 实现通用查询过滤器
  • ORM框架中的条件构造
  • 动态API查询构建

通过组合这些策略，可以灵活地构建各种复杂的查询条件，而无需硬编码查询逻辑。