多表多字段高效全局搜索实现方案咨询

我正在为一个包含40-50张（持续新增）数据表的应用构建全局搜索功能，每张表有5-20个字段。搜索需求示例：输入"viva"时，需匹配Vehicle的Model字段值为"viva"、VehicleInsurance的InsuranceCompany字段值包含"aviva"等结果。

现有硬编码方式需要逐个编写每个表的查询（如下示例），但表和字段数量庞大且持续增加，维护成本极高：

var vehicles = _dbContext.Vehicles.Where(v => v.RegistrationNumber.Contains(searchText) ||
                               v.Make.Contains(searchText) ||
                               ...And so on);
var insurances = _dbContext.VehicleInsurances.Where(v => v.InsuranceCompany.Contains(searchText) ||
                                                         v.PolicyNumber.Contains(searchText) ||
                                                         ...And so on);
// 所有其他表的查询以此类推

期望返回统一结构的搜索结果：

public class SearchResponse
{
    public string ResultText {get;set;} // 返回匹配字段的完整值
    public string ResultId {get;set;} // 实体继承自BaseDataEntity的ID
}

以下是兼顾编码效率（无需硬编码每个表/字段）和数据库性能的实现方案：

方案一：EF Core动态表达式树构建查询 #

实现思路 #

通过反射遍历所有继承BaseDataEntity的实体类型，再遍历每个实体的字符串类型字段，动态构建Where条件表达式，最终统一执行查询并映射为SearchResponse。

代码示例 #

public class GlobalSearchService
{
    private readonly AppDbContext _dbContext;
    private readonly IEnumerable<Type> _entityTypes;

    public GlobalSearchService(AppDbContext dbContext)
    {
        _dbContext = dbContext;
        // 获取所有继承BaseDataEntity的实体类型（排除抽象类）
        _entityTypes = Assembly.GetExecutingAssembly().GetTypes()
            .Where(t => typeof(BaseDataEntity).IsAssignableFrom(t) && !t.IsAbstract);
    }

    public async Task<List<SearchResponse>> SearchAsync(string searchText)
    {
        var results = new List<SearchResponse>();
        var containsMethod = typeof(string).GetMethod("Contains", new[] { typeof(string) });

        foreach (var entityType in _entityTypes)
        {
            // 获取对应DbSet
            var dbSetProp = _dbContext.GetType().GetProperty($"{entityType.Name}s");
            if (dbSetProp == null) continue;
            var dbSet = dbSetProp.GetValue(_dbContext) as IQueryable;
            if (dbSet == null) continue;

            // 构建查询参数表达式
            var parameter = Expression.Parameter(entityType, "entity");
            var searchTextConst = Expression.Constant(searchText);
            var conditions = new List<Expression>();

            // 遍历所有可空/非空字符串字段，构建匹配条件
            foreach (var prop in entityType.GetProperties()
                .Where(p => p.PropertyType == typeof(string) || p.PropertyType == typeof(string?)))
            {
                var propAccess = Expression.Property(parameter, prop.Name);
                // 加入空值检查，避免空引用异常
                var nullCheck = Expression.NotEqual(propAccess, Expression.Constant(null));
                var containsExpr = Expression.Call(propAccess, containsMethod, searchTextConst);
                conditions.Add(Expression.AndAlso(nullCheck, containsExpr));
            }

            if (!conditions.Any()) continue;

            // 组合所有OR条件
            var whereBody = conditions.Aggregate(Expression.OrElse);
            var whereLambda = Expression.Lambda(whereBody, parameter);

            // 获取实体ID属性（BaseDataEntity的Id）
            var idProp = entityType.GetProperty("Id");
            if (idProp == null) continue;

            // 构建选择表达式，映射为SearchResponse
            var selectBody = Expression.MemberInit(
                Expression.New(typeof(SearchResponse)),
                Expression.Bind(
                    typeof(SearchResponse).GetProperty("ResultId"),
                    Expression.Convert(Expression.Property(parameter, idProp), typeof(string))
                ),
                // 取第一个匹配的字段值作为ResultText
                Expression.Bind(
                    typeof(SearchResponse).GetProperty("ResultText"),
                    Expression.Property(parameter, ((MemberExpression)((BinaryExpression)conditions.First()).Left).Member)
                )
            );
            var selectLambda = Expression.Lambda(selectBody, parameter);

            // 动态执行查询
            var query = dbSet.Provider.CreateQuery(
                Expression.Call(
                    typeof(Queryable), "Where", new[] { entityType },
                    dbSet.Expression,
                    whereLambda
                )
            );
            var selectQuery = query.Provider.CreateQuery(
                Expression.Call(
                    typeof(Queryable), "Select", new[] { entityType, typeof(SearchResponse) },
                    query.Expression,
                    selectLambda
                )
            );

            var entityResults = await selectQuery.Cast<SearchResponse>().ToListAsync();
            results.AddRange(entityResults);
        }
        return results;
    }
}

优缺点 #

• 编码效率：新增实体时无需修改搜索逻辑，自动识别继承BaseDataEntity的实体和字符串字段。
• 性能：依赖数据库LIKE查询，%xxx%模糊匹配无法利用普通索引，适合中小数据量场景。

方案二：数据库全文索引 + EF Core动态查询 #

实现思路 #

利用数据库原生全文索引功能（如SQL Server全文索引、PostgreSQL tsvector），为搜索字段创建全文索引，再结合动态表达式树生成全文查询，性能远优于普通LIKE。

步骤 #

1. 数据库配置（以SQL Server为例）：

-- 创建全文目录
CREATE FULLTEXT CATALOG GlobalSearchCatalog AS DEFAULT;

-- 为Vehicle表创建全文索引
CREATE FULLTEXT INDEX ON Vehicles (RegistrationNumber, VINNumber, Make, Model) 
KEY INDEX PK_Vehicles;

-- 其他表同理创建全文索引

2. 动态查询改造：将方案一中的Contains方法替换为EF Core的全文查询函数EF.Functions.Contains：

// 替换方案一中的containsExpr生成逻辑
var containsExpr = Expression.Call(
    typeof(EF.Functions), "Contains", null,
    propAccess,
    searchTextConst
);

优缺点 #

• 编码效率：新增实体时只需配置全文索引（可通过EF迁移自动生成），搜索逻辑无需修改。
• 性能：全文索引支持高效模糊匹配、分词查询，适合中大型数据量场景。

方案三：引入专用搜索引擎（如Elasticsearch） #

实现思路 #

将所有实体数据同步到Elasticsearch，利用其专为全文搜索优化的能力实现全局搜索。通过定时任务或CDC机制保持数据同步，搜索时直接查询Elasticsearch。

代码示例（简化） #

public class ElasticSearchService
{
    private readonly ElasticClient _client;

    public ElasticSearchService()
    {
        _client = new ElasticClient(new Uri("http://localhost:9200"));
    }

    public async Task<List<SearchResponse>> SearchAsync(string searchText)
    {
        var response = await _client.SearchAsync<BaseDataEntity>(s => s
            .Index("global_search_index")
            .Query(q => q
                .MultiMatch(m => m
                    .Fields(f => f
                        .Field("registrationNumber")
                        .Field("make")
                        .Field("model")
                        .Field("insuranceCompany")
                        // 其他字段自动映射
                    )
                    .Query(searchText)
                )
            )
        );

        return response.Documents.Select(doc => new SearchResponse
        {
            ResultId = doc.Id.ToString(),
            // 从匹配字段中提取结果文本，可结合Elasticsearch的高亮功能优化
            ResultText = doc.GetType().GetProperties()
                .First(p => p.PropertyType == typeof(string) && ((string)p.GetValue(doc) ?? "").Contains(searchText))
                .GetValue(doc)?.ToString() ?? ""
        }).ToList();
    }
}

优缺点 #

• 编码效率：新增实体只需配置Elasticsearch映射，同步逻辑可通过泛型自动适配。
• 性能：支持海量数据快速查询、分词、权重排序等高级功能，适合大数据量或复杂搜索需求场景。

方案选择建议 #

• 中小数据量、快速落地：方案一+方案二（动态表达式树+数据库全文索引）
• 大数据量、复杂搜索需求：方案三（Elasticsearch）

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