EF Core自定义字符串比较方法无法被LINQ翻译的替代方案咨询

针对EF Core无法翻译自定义扩展方法的问题，提供两种可复用的替代方案，避免繁琐的内联判断：

方案1：封装表达式树的通用查询方法 #

直接构建LINQ表达式树，让EF Core能正确解析并转换为SQL。可封装为通用扩展方法，支持任意实体类型：

public enum StringComparisonType
{
    Equals,
    Contains,
    BeginsWith,
    EndsWith
}

public static class QueryableStringExtensions
{
    public static IQueryable<T> WhereStringComparison<T>(this IQueryable<T> query, 
        Expression<Func<T, string>> propertySelector, 
        string searchText, 
        StringComparisonType comparisonType)
    {
        var parameter = propertySelector.Parameters[0];
        var property = propertySelector.Body;
        var searchValue = Expression.Constant(searchText);

        Expression comparisonExpression = comparisonType switch
        {
            StringComparisonType.Equals => Expression.Call(property, nameof(string.Equals), Type.EmptyTypes, searchValue),
            StringComparisonType.BeginsWith => Expression.Call(property, nameof(string.StartsWith), Type.EmptyTypes, searchValue),
            StringComparisonType.Contains => Expression.Call(property, nameof(string.Contains), Type.EmptyTypes, searchValue),
            StringComparisonType.EndsWith => Expression.Call(property, nameof(string.EndsWith), Type.EmptyTypes, searchValue),
            _ => throw new NotImplementedException($"{nameof(StringComparisonType)} {comparisonType} not supported.")
        };

        var lambda = Expression.Lambda<Func<T, bool>>(comparisonExpression, parameter);
        return query.Where(lambda);
    }
}

使用方式简洁，和你最初的思路一致：

var searchText = "hello";
var comparison = StringComparisonType.BeginsWith;
var result = _context.Records.WhereStringComparison(r => r.Text, searchText, comparison).ToList();

方案2：注册EF Core自定义方法翻译（EF Core 3.0+支持） #

如果想保留原有的CompareTo扩展方法语法，可通过EF Core的自定义方法翻译功能，告知EF Core如何将该方法转换为SQL：

首先保留原扩展方法（用于内存执行场景）：

public static class StringExtensions
{
    public static bool CompareTo(this string inputText, string comparisonText, StringComparisonType comparisonType)
    {
        return comparisonType switch
        {
            StringComparisonType.Equals => inputText.Equals(comparisonText),
            StringComparisonType.BeginsWith => inputText.StartsWith(comparisonText),
            StringComparisonType.Contains => inputText.Contains(comparisonText),
            StringComparisonType.EndsWith => inputText.EndsWith(comparisonText),
            _ => throw new NotImplementedException($"{nameof(StringComparisonType)} {comparisonType} not supported.")
        };
    }
}

在DbContext的OnModelCreating中注册翻译逻辑：

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    var compareToMethod = typeof(StringExtensions).GetMethod(nameof(StringExtensions.CompareTo))!;
    modelBuilder.HasDbFunction(compareToMethod)
        .HasTranslation(args =>
        {
            var input = args[0];
            var searchText = args[1];
            var comparisonType = (StringComparisonType)((ConstantExpression)args[2]).Value!;

            return comparisonType switch
            {
                StringComparisonType.Equals => EF.Functions.Equals(input, searchText),
                StringComparisonType.BeginsWith => EF.Functions.Like(input, $"{searchText}%"),
                StringComparisonType.Contains => EF.Functions.Like(input, $"%{searchText}%"),
                StringComparisonType.EndsWith => EF.Functions.Like(input, $"%{searchText}"),
                _ => throw new NotImplementedException()
            };
        });
}

之后即可按原方式调用，EF Core会自动转换为对应SQL：

var searchText = "hello";
var comparison = StringComparisonType.BeginsWith;
var result = _context.Records.Where(r => r.Text.CompareTo(searchText, comparison)).ToList();

方案对比 #

• 方案1更轻量，无需修改DbContext，适合快速复用；
• 方案2保留原有调用语法，贴近最初设计，适合统一代码风格的场景。

内容的提问来源于stack exchange，提问作者devklick