如何仅用Contains、StartsWith、EndsWith实现LINQ to SQL通配符搜索？

当然有可行的实现方式！核心思路是把你定义的通配符规则（?=任意单个字符，*=任意多个字符）转换成LINQ to SQL能识别的Contains/StartsWith/EndsWith方法组合——毕竟这三个方法最终会被翻译成对应的SQL LIKE语句，完全能满足需求。

下面分场景拆解实现逻辑，再给你一个可复用的辅助方法：

一、先理清楚通配符的对应逻辑 #

先把不同的通配符模式映射到LINQ方法：

• 无通配符：直接用Equals（精准匹配）
• prefix*：对应StartsWith("prefix")（前缀匹配）
• *suffix：对应EndsWith("suffix")（后缀匹配）
• *middle*：对应Contains("middle")（包含匹配）
• prefix*suffix：StartsWith("prefix") && EndsWith("suffix")（前后缀同时匹配）
• 包含?的模式：需要结合字符串长度约束和Substring定位匹配（因为?代表单个任意字符，必须固定字符串的长度或特定位置的字符）

二、处理带?的复杂模式 #

比如这些场景：

• a?c：字符串长度必须为3，且StartsWith("a") && EndsWith("c")
• a??c：字符串长度必须为4，且StartsWith("a") && EndsWith("c")
• a?*c：字符串长度至少为3，且StartsWith("a") && EndsWith("c")
• x?y*：开头是x，第三个字符是y，后面任意 → StartsWith("x") && Substring(2,1) == "y" && Length >=3

三、可复用的辅助方法实现 #

我们可以写一个通用方法，自动把通配符模式转换成LINQ表达式，这样不用每次手动拼接条件：

using System.Linq.Expressions;

public static class WildcardSearchHelper
{
    public static Expression<Func<T, bool>> BuildWildcardPredicate<T>(string propertyName, string pattern)
    {
        var parameter = Expression.Parameter(typeof(T), "entity");
        var property = Expression.Property(parameter, propertyName);
        Expression filter = Expression.Constant(true);

        // 预处理：把连续的*替换成单个*，避免重复处理
        var cleanedPattern = string.Join("*", pattern.Split(new[] { '*' }, StringSplitOptions.RemoveEmptyEntries));
        bool startsWithWildcard = cleanedPattern.StartsWith("*");
        bool endsWithWildcard = cleanedPattern.EndsWith("*");

        // 去掉首尾的*，提取中间需要匹配的部分
        var corePattern = cleanedPattern.Trim('*');

        // 处理全*的情况（匹配所有）
        if (string.IsNullOrEmpty(corePattern))
        {
            return Expression.Lambda<Func<T, bool>>(filter, parameter);
        }

        // 处理前缀匹配（如果开头没有*）
        if (!startsWithWildcard)
        {
            var prefix = corePattern.Split(new[] { '*', '?' }, StringSplitOptions.None)[0];
            if (!string.IsNullOrEmpty(prefix))
            {
                var startsWithMethod = typeof(string).GetMethod("StartsWith", new[] { typeof(string) });
                filter = Expression.AndAlso(filter, Expression.Call(property, startsWithMethod, Expression.Constant(prefix)));
            }
        }

        // 处理后缀匹配（如果结尾没有*）
        if (!endsWithWildcard)
        {
            var suffix = corePattern.Split(new[] { '*', '?' }, StringSplitOptions.None).Last();
            if (!string.IsNullOrEmpty(suffix))
            {
                var endsWithMethod = typeof(string).GetMethod("EndsWith", new[] { typeof(string) });
                filter = Expression.AndAlso(filter, Expression.Call(property, endsWithMethod, Expression.Constant(suffix)));
            }
        }

        // 处理?的情况：计算最小长度，定位固定字符的位置
        var fixedSegments = corePattern.Split(new[] { '?' }, StringSplitOptions.RemoveEmptyEntries);
        int currentPosition = startsWithWildcard ? 0 : fixedSegments[0].Length;
        int minRequiredLength = currentPosition;

        foreach (var segment in fixedSegments.Skip(1))
        {
            // 每个?占用1个字符，加上当前段的长度
            minRequiredLength += 1 + segment.Length;
            // 检查当前段是否在指定位置出现
            var substringMethod = typeof(string).GetMethod("Substring", new[] { typeof(int), typeof(int) });
            var substringExpr = Expression.Call(
                property, 
                substringMethod, 
                Expression.Constant(currentPosition + 1), 
                Expression.Constant(segment.Length)
            );
            filter = Expression.AndAlso(filter, Expression.Equal(substringExpr, Expression.Constant(segment)));
            currentPosition += 1 + segment.Length;
        }

        // 添加最小长度约束（确保有足够的字符容纳?和固定段）
        if (minRequiredLength > 0)
        {
            var lengthProp = typeof(string).GetProperty("Length");
            var lengthExpr = Expression.Property(property, lengthProp);
            filter = Expression.AndAlso(
                filter, 
                Expression.GreaterThanOrEqual(lengthExpr, Expression.Constant(minRequiredLength + (endsWithWildcard ? 0 : 0)))
            );
        }

        return Expression.Lambda<Func<T, bool>>(filter, parameter);
    }
}

四、使用示例 #

假设你有一个Product实体，要搜索ProductName属性：

// 示例1：匹配以"App"开头，中间任意单个字符，后面任意的产品名
string searchPattern = "App?*";
var predicate = WildcardSearchHelper.BuildWildcardPredicate<Product>("ProductName", searchPattern);

using (var db = new YourDataContext())
{
    var matchingProducts = db.Products.Where(predicate).ToList();
}

注意事项 #

• 这个方法支持混合*和?的复杂模式，比如a?*b?c
• LINQ to SQL会自动把这些表达式翻译成高效的SQL语句，只要你的字段有合适的索引，性能不会比直接用LIKE差
• 如果输入的模式有特殊字符（比如\或%），记得先做转义处理（不过LINQ to SQL会自动处理字符串参数的转义）

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