elasticsearch 如何使用Nest ElasticSearch在多个索引内搜索？

我有两个具有以下映射的索引（我将简化它们的映射）：

1） AccountType映射：

 elasticClient.CreateIndex("account", i => i
                .Settings(s => s
                          .NumberOfShards(2)
                          .NumberOfReplicas(0)
                          )
                          .Mappings(m => m
                                    .Map<AccountType>(map => map
                                               .AutoMap()
                                               .Properties(p => p
                                                    .Text(c => c
                                                           .Name(n => n.Name)
                                                           .Analyzer("standard")
                                                    )
                                                    .Text(c => c
                                                           .Name(n => n.Description)
                                                           .Analyzer("standard")
                                                    )
                                                )
                                    )
                            )
                          );

 elasticClient.CreateIndex("proudct", i => i
                .Settings(s => s
                          .NumberOfShards(2)
                          .NumberOfReplicas(0)
                          )
                          .Mappings(m => m
                                    .Map<ProductType>(map => map
                                               .AutoMap()
                                               .Properties(p => p
                                                    .Text(c => c
                                                           .Name(n => n.Title)
                                                           .Analyzer("standard")
                                                    )
                                                    .Text(c => c
                                                           .Name(n => n.Description)
                                                           .Analyzer("standard")
                                                    )
                                                )
                                    )
                            )
                          );

elasticClient.CreateIndex（“account”，i=>i
.Settings（s=>s
.NumberOfShard（2）
.numberofreplications（0）
)
.Mappings（m=>m
.Map（Map=>Map
.AutoMap（）
.Properties（p=>p
.Text（c=>c
.Name（n=>n.Name）
.分析仪（“标准”）
)
.Text（c=>c
.Name（n=>n.Description）
.分析仪（“标准”）
)
)
)
)
);

2） ProductType映射：

 elasticClient.CreateIndex("account", i => i
                .Settings(s => s
                          .NumberOfShards(2)
                          .NumberOfReplicas(0)
                          )
                          .Mappings(m => m
                                    .Map<AccountType>(map => map
                                               .AutoMap()
                                               .Properties(p => p
                                                    .Text(c => c
                                                           .Name(n => n.Name)
                                                           .Analyzer("standard")
                                                    )
                                                    .Text(c => c
                                                           .Name(n => n.Description)
                                                           .Analyzer("standard")
                                                    )
                                                )
                                    )
                            )
                          );

 elasticClient.CreateIndex("proudct", i => i
                .Settings(s => s
                          .NumberOfShards(2)
                          .NumberOfReplicas(0)
                          )
                          .Mappings(m => m
                                    .Map<ProductType>(map => map
                                               .AutoMap()
                                               .Properties(p => p
                                                    .Text(c => c
                                                           .Name(n => n.Title)
                                                           .Analyzer("standard")
                                                    )
                                                    .Text(c => c
                                                           .Name(n => n.Description)
                                                           .Analyzer("standard")
                                                    )
                                                )
                                    )
                            )
                          );

elasticClient.CreateIndex（“product”，i=>i
.Settings（s=>s
.NumberOfShard（2）
.numberofreplications（0）
)
.Mappings（m=>m
.Map（Map=>Map
.AutoMap（）
.Properties（p=>p
.Text（c=>c
.Name（n=>n.Title）
.分析仪（“标准”）
)
.Text（c=>c
.Name（n=>n.Description）
.分析仪（“标准”）
)
)
)
)
);

现在我有几件事需要弄清楚：

1） 首先，在我的例子中，有一个索引是account，并将产品作为嵌套对象，这是一个好主意吗？但是在这里，每次我想要更新/添加新产品时，我都必须重新索引（更新）整个account文档

2） 我的第二个问题是：我希望有搜索功能，因此如果用户通过在文本框中键入来搜索，我希望获得帐户和产品的最佳匹配（在这里，我将搜索产品的标题和说明，再加上帐户的名称和说明，然后获得最佳匹配）：

因此，这里如何使用Nest ElasticSeach搜索多个索引，或者如果不可能，从每个索引中获得最佳匹配是否是一个好主意，然后根据分数从两个结果中获得最佳匹配

附言： 以下是搜索内部产品索引的示例：

        var result = elasticClient.Search<ProductType>(s => s
                                            .Size(10)
                                            .Query(q => q
                                              .MultiMatch(m => m
                                                .Fields(f => f.Field(p => p.Title, 1.5).Field(p => p.Description, 0.8))
                                                .Operator(Operator.Or)
                                                .Query(query)
                                              )
                                            )
                                          );

var result=elasticClient.Search（s=>s
.尺寸（10）
.Query（q=>q
.MultiMatch（m=>m
.Fields（f=>f.Field（p=>p.Title，1.5）.Field（p=>p.Description，0.8））
.操作员（操作员或）
.Query（查询）
)
)
);

1） 首先，在我的例子中，有一个索引是account，并将产品作为嵌套对象，这是一个好主意吗？但是在这里，每次我想要更新/添加新产品时，我都必须重新索引（更新）整个account文档

通常建议每个索引有一个类型，并且。如果产品在帐户上表示为嵌套对象，则向帐户添加新产品将需要更新整个文档（在应用程序代码中或Elasticsearch中）

2） 我的第二个问题是：我希望有搜索功能，因此如果用户通过在文本框中键入来搜索，我希望获得帐户和产品的最佳匹配（在这里，我将搜索产品的标题和说明，再加上帐户的名称和说明，然后获得最佳匹配）：

您可以搜索多个索引，签出；它显示了一个从一个索引返回多个不同类型的示例（此示例将更新为6.0！），但是可以跨多个索引执行此操作。下面是一个例子：

private static void Main（）
{
var设置=新连接设置（新Uri（“http://localhost:9200"))
.InferMappingFor可以更简洁地组合查询。
Bro你是Nest elasticsearch的大师。每次我问问题，我都能从你那里得到准确的答案。非常感谢你的回答太详细了。很抱歉我的英语不好。似乎“like a hell”的意思不好。我不认为它不好，但不认为它翻译正确：）