Convariant search results
version 5.x
NEST 直接支持返回协变结果集合。这意味着，可以将搜索结果的类型指定为一个接口或者基类，但是其真实类型仍然是接口或基类的一个子类型。
让我们来看一个例子，假设我们想要搜索的多个类型都实现了 ISearchResult 接口
public interface ISearchResult
{
string Name { get; set; }
}public abstract class BaseX : ISearchResult
{
public string Name { get; set; }
}
针对 ISearchResult ，我们提供了三种实现，分别叫 A, B 和 C
public class A : BaseX
{
public int PropertyOnA { get; set; }
}public class B : BaseX
{
public int PropertyOnB { get; set; }
}public class C : BaseX
{
public int PropertyOnC { get; set; }
}
使用 Types
要想搜索多个类型，最直接的方式是，先将响应的类型指定为接口或者基类，然后使用 .Type() 传递我们想搜索的实际类型
var result = this._client.Search<ISearchResult>(s => s
.Type(Types.Type(typeof(A), typeof(B), typeof(C)))
.Size(100)
);
NEST 会把这份逻辑代码转化为 /index/a,b,c/_search ，有 "_type" : "a" 的命中结果会被序列化为 A 类型的对象，以此类推。
在这里，我们假设所有的响应都是有效的，并且我们将接收到预期的 100 份文档。记住， result.Document 是一个 IReadOnlyCollection<ISearchResult> 类型的对象
result.ShouldBeValid();
result.Documents.Count.Should().Be(100);
为了证明返回的结果集合是协变的，我们根据它们的真实类型过滤文档，并断言这些子集是我们期望的大小
var aDocuments = result.Documents.OfType<A>();
var bDocuments = result.Documents.OfType<B>();
var cDocuments = result.Documents.OfType<C>();aDocuments.Count().Should().Be(25);
bDocuments.Count().Should().Be(25);
cDocuments.Count().Should().Be(50);
另外，假设只存在于子类本身的属性会被正确填充
aDocuments.Should().OnlyContain(a => a.PropertyOnA > 0);
bDocuments.Should().OnlyContain(a => a.PropertyOnB > 0);
cDocuments.Should().OnlyContain(a => a.PropertyOnC > 0);
使用 ConcreteTypeSelector
一个相对较低级别的方式是，自己检查命中结果，并确定要反序列化的 CLR 类型
var result = this._client.Search<ISearchResult>(s => s
.ConcreteTypeSelector((d, h) => h.Type == "a" ? typeof(A) : h.Type == "b" ? typeof(B) : typeof(C))
.Size(100)
);
对于每一个命中结果，我们会调用传递给 ConcreteTypeSelector 的委托
d表示_source公开为一个dynamic类型- 带有类型的
h代表着对命中结果的封装（例如：Hit<dynamic>）
我们假设响应是有效的，并且接收到了预期的 100 份文档。记住， result.Document 是一个 IReadOnlyCollection<ISearchResult> 类型的对象
result.ShouldBeValid();
result.Documents.Count.Should().Be(100);
为了证明返回的结果集合是协变的，我们根据它们的真实类型过滤文档，并断言这些子集是我们期望的大小
var aDocuments = result.Documents.OfType<A>();
var bDocuments = result.Documents.OfType<B>();
var cDocuments = result.Documents.OfType<C>();aDocuments.Count().Should().Be(25);
bDocuments.Count().Should().Be(25);
cDocuments.Count().Should().Be(50);
另外，假设只存在于子类本身的属性会被正确填充
aDocuments.Should().OnlyContain(a => a.PropertyOnA > 0);
bDocuments.Should().OnlyContain(a => a.PropertyOnB > 0);
cDocuments.Should().OnlyContain(a => a.PropertyOnC > 0);
使用 CovariantTypes
Scroll API 是上一个搜索示例的延伸，我们不再使用 Types() 。你可以使用 .CovariantTypes() 来指示类型。
var result = this._client.Scroll<ISearchResult>(TimeSpan.FromMinutes(60), "scrollId", s => s
.CovariantTypes(Types.Type(typeof(A), typeof(B), typeof(C)))
);
NEST 会把这份逻辑代码转化为 /index/a,b,c/_search ，有 "_type" : "a" 的命中结果会被序列化为 A 类型的对象，以此类推。
后续的验证过程同上（也许你已经发现前面的两节内容里存在者相同的步骤）
相对较低级别的 concrete type selector 也可以用在 scroll 中
var result = this._client.Scroll<ISearchResult>(TimeSpan.FromMinutes(1), "scrollid", s => s
.ConcreteTypeSelector((d, h) => h.Type == "a" ? typeof(A) : h.Type == "b" ? typeof(B) : typeof(C))
);
重复验证工作
协变不仅仅在接口方式中工作，下面便是子类型协变的示例：
var result = this._client.Search<BaseX>(s => s
.Type(Types.Type(typeof(A), typeof(B), typeof(C)))
.Size(100)
);
result.ShouldBeValid();
result.Documents.Count.Should().Be(100);var aDocuments = result.Documents.OfType<A>();
var bDocuments = result.Documents.OfType<B>();
var cDocuments = result.Documents.OfType<C>();aDocuments.Count().Should().Be(25);
bDocuments.Count().Should().Be(25);
cDocuments.Count().Should().Be(50);aDocuments.Should().OnlyContain(a => a.PropertyOnA > 0);
bDocuments.Should().OnlyContain(a => a.PropertyOnB > 0);
cDocuments.Should().OnlyContain(a => a.PropertyOnC > 0);
