/ /

MongoDB Search

Overview

在本指南中，您可以了解如何使用 Search 生成器，通过 MongoDB .NET/C# 驱动程序构建一个聚合管道阶段。

要了解有关 $search 管道阶段的更多信息，请参阅 $search。

注意

适用于Atlas for MongoDB v4.2 及更高版本

$search聚合管道操作符可用于在运行MongoDB v 或更高版本的MongoDB4.2 Atlas集群上托管的集合，这些集群由MongoDB Search索引覆盖。要学习；了解有关此操作符所需设置和功能的更多信息，请参阅MongoDB Search 文档。

本指南中的示例使用名为 guitars 的集合中的以下文档：

{ "_id": 1, "make": "Fender", "description": "Classic guitars known for their versatility.", "establishedYear": 1946, "in_stock": true, "rating": 9 }
{ "_id": 2, "make": "Gibson", "description": "Classic guitars known for their rich, full tones.", "establishedYear": 1902, "in_stock": true, "rating": 8 }
{ "_id": 3, "make": "PRS", "description": "High-end guitars known for their quality.", "establishedYear": 1985, "in_stock": true, "rating": 9 }
{ "_id": 4, "make": "Kiesel", "description": "Quality guitars made only for custom orders.", "establishedYear": 2015, "in_stock": false }
{ "_id": 5, "make": "Ibanez", "description": "Well-crafted guitars used by many professional guitarists.", "establishedYear": 1957, "in_stock": true, "rating": 7 }
{ "_id": 6, "make": "Strandberg", "description": "Modern guitars known for their headless models.", "establishedYear": 1982, "in_stock": false }

以下 Guitar 类对此集合中的文档进行建模。

public class Guitar
{
    public int Id { get; set; }
    public string Make { get; set; }
    public List<string> Models { get; set; }
    public int EstablishedYear { get; set; }
    [BsonElement("in_stock")]
    public bool InStock { get; set; }
    public int? Rating { get; set; }
}

注意

guitars 集合中的文档使用驼峰命名约定。本指南中的示例使用 ConventionPack 将集合中的字段反序列化为 Pascal 语句，然后映射到 Guitar 类中的属性。

如需了解有关自定义序列化的更多信息，请参阅自定义序列化。

创建MongoDB搜索索引

在对Atlas集合执行搜索之前，必须先在该集合上创建MongoDB Search索引。 MongoDB搜索索引是一种以可搜索格式对数据进行分类的数据结构。

要学习；了解如何创建MongoDB搜索索引，请参阅创建MongoDB搜索索引指南。

MongoDB搜索操作符

Search类包含可用于执行$search操作的方法。有关可用$search操作符的完整列表，请参阅 Atlas操作符和收集器指南。

自动完成(Autocomplete)

使用 Autocomplete() 方法，搜索包含不完整输入字符串中的字符序列的单词或短语。

以下示例对以字符串 "Gib" 开头的文本的 make 字段执行自动完成查询。

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Autocomplete(g => g.Make, "Gib"), indexName: "guitarmakes")
    .ToList();

注意

自动完成查询的索引

您必须创建支持自动完成的MongoDB搜索索引，才能成功执行自动完成查询。要学习；了解更多信息，请参阅Atlas文档中的如何对字段进行索引以支持自动完成。

创建MongoDB Search索引后，必须将索引名称传递给 Autocomplete() 方法，如前面的代码所示。

此搜索将返回如下文档：

{ "_id" : 2, "make" : "Gibson", "description" : "Classic guitars known for their rich, full tones.", "establishedYear" : 1902, "in_stock" : true, "rating" : 8 }

要了解有关 autocomplete 操作符的更多信息，请参阅 autocomplete Atlas 指南。

多个子句

使用 Compound() 方法将两个或更多操作符组合到单次搜索中。

以下示例在 guitars 集合中搜索符合以下所有条件的任何文档：

文档上存在 rating 字段
in_stock 字段不是 false
establishedYear 字段的值大于 1940

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Compound()
        .Must(Builders<Guitar>.Search.Exists(g => g.Rating))
        .MustNot(Builders<Guitar>.Search.Equals(g => g.InStock, false))
        .Must(Builders<Guitar>.Search.Range(g => g.EstablishedYear, SearchRangeBuilder.Gt(1940))))
    .ToList();

搜索会返回以下文档：

{ "_id" : 1, "make" : "Fender", "description" : "...", "establishedYear" : 1946, "in_stock" : true, "rating" : 9 }
{ "_id" : 3, "make" : "PRS", "description" : "...", "establishedYear" : 1985, "in_stock" : true, "rating" : 9 }
{ "_id" : 5, "make" : "Ibanez", "description" : "...", "establishedYear" : 1957, "in_stock" : true, "rating" : 7 }

要了解有关 compound 操作符的更多信息，请参阅 compound Atlas 指南。

嵌入式文档

使用 EmbeddedDocument() 方法对字段的数组值中的文档执行搜索操作。

注意

要对嵌入式文档进行Atlas Search ，您必须在数组字段上创建 embeddedDocument 索引。

要了解如何定义 embeddedDocument 索引，请参阅 Atlas 文档中的为 embeddedDocument 类型定义索引。

假设 guitars 集合中的某些文档添加了一个 productDetails 字段，该字段包含一组产品详情对象：

{ "_id": 1, "make": "Fender", "description": "...", "establishedYear": 1946, "in_stock": true, "rating": 9, "productDetails": [{"product_id": 1234, "serial": "YZ5678"}] }
{ "_id": 2, "make": "Gibson", "description": "...", "establishedYear": 1902, "in_stock": true, "rating": 8 }
{ "_id": 3, "make": "PRS", "description": "...", "establishedYear": 1985, "in_stock": true, "rating": 9, "productDetails": [{"product_id": 9870, "serial": "AB5555"}] }
{ "_id": 4, "make": "Kiesel", "description": "...", "establishedYear": 2015, "in_stock": false }
{ "_id": 5, "make": "Ibanez", "description": "...", "establishedYear": 1957, "in_stock": true, "rating": 7, "productDetails": [{"product_id": 5432, "serial": "ZZ1234"}] }
{ "_id": 6, "make": "Strandberg", "description": "...", "establishedYear": 1982, "in_stock": false }

在 productDetails字段上创建 embeddedDocument索引后，您可以对该字段中的文档执行MongoDB Search 操作。以下示例对 productDetails大量字段执行文本搜索，并返回 serial字段值为 "YZ5678" 的所有文档：

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.EmbeddedDocument(
        g => g.ProductDetails,
        Builders<ProductDetails>.Search.Text(p => p.Serial, "YZ5678")
    )).ToList();
return result;

此搜索将返回如下文档：

{ "_id" : 1, "make" : "Fender", "description" : "Classic guitars known for their versatility.", "establishedYear" : 1946, "in_stock" : true, "rating" : 9, "productDetails" : [{ "product_id" : 1234, "serial" : "YZ5678" }] }

要了解有关 embeddedDocument 操作符的更多信息，请参阅 embeddedDocument Atlas 指南。

Equals

使用 Equals() 方法检查字段是否与指定值匹配。

如下示例会在 guitars 集合中搜索 in_stock（有存货）字段值为 true 的任何文档。

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Equals(g => g.InStock, true))
    .ToList();

搜索会返回以下文档：

{ "_id" : 1, "make" : "Fender", "description" : "...", "establishedYear" : 1946, "in_stock" : true, "rating" : 9 }
{ "_id" : 2, "make" : "Gibson", "description" : "...", "establishedYear" : 1902, "in_stock" : true, "rating" : 8 }
{ "_id" : 3, "make" : "PRS", "description" : "...", "establishedYear" : 1985, "in_stock" : true, "rating" : 9 }
{ "_id" : 5, "make" : "Ibanez", "description" : "...", "establishedYear" : 1957, "in_stock" : true, "rating" : 7 }

要了解有关 equals 操作符的更多信息，请参阅 equals Atlas 指南。

Exists

使用 Exists() 方法搜索其中存在指定索引字段名称的文档。如果指定的字段存在但没有为期创建索引，此文档不会包含在结果集内。

如下示例会在 guitars 集合中搜索存在 rating 字段的任何文档。

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Exists(g => g.Rating))
    .ToList();

搜索会返回以下文档：

{ "_id" : 1, "make" : "Fender", "description" : "...", "establishedYear" : 1946, "in_stock" : true, "rating" : 9 }
{ "_id" : 2, "make" : "Gibson", "description" : "...", "establishedYear" : 1902, "in_stock" : true, "rating" : 8 }
{ "_id" : 3, "make" : "PRS", "description" : "...", "establishedYear" : 1985, "in_stock" : true, "rating" : 9 }
{ "_id" : 5, "make" : "Ibanez", "description" : "...", "establishedYear" : 1957, "in_stock" : true, "rating" : 7 }

要了解有关 exists 操作符的更多信息，请参阅exists Atlas 指南。

GeoShape

使用 GeoShape() 方法搜索与给定的几何图形相关的文档。当指定要搜索的坐标时，必须首先指定经度，然后指定纬度。经度值可以介于 -180 到 180（含）之间。纬度值可以介于 -90 到 90（含）之间。

注意

MongoDB Search 不支持以下内容：

非默认坐标参考系 (CRS)
平面 XY 坐标系（二维）
坐标对点符号 (pointFieldName: [12, 34])

考虑到 guitars 集合中的某些文档已添加 in_stock_location 字段。现在，集合中的变更文档如下所示：

{ "_id": 1, "make": "Fender", "description": "...", "establishedYear": 1946, "in_stock": true, "in_stock_location":  { "type": "Point", "coordinates": [ -73.93615, 40.69791 ]}, "rating": 9 }
{ "_id": 2, "make": "Gibson", "description": "...", "establishedYear": 1902, "in_stock": true, "in_stock_location":  { "type": "Point", "coordinates": [ 47.6062, 122.321 ]}, "rating": 8 }

以下示例搜索 in_stock_location 字段中的坐标与指定多边形相交的所有文档：

GeoJsonPolygon<GeoJson2DGeographicCoordinates> searchArea = new(new(new(new GeoJson2DGeographicCoordinates[]
{
     new(-72.93615, 41.69791),
     new(-72.93615, 40.59791),
     new(-74.93615, 40.59791),
     new(-74.93615, 41.69791),
     new(-72.93615, 41.69791),
})));
var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.GeoShape(g => g.InStockLocation, GeoShapeRelation.Intersects, searchArea))
    .ToList();

此搜索将返回如下文档：

{ "_id" : 1, "make" : "Fender", "description" : "...", "establishedYear" : 1946, "in_stock" : true, "in_stock_location" : { "type" : "Point", "coordinates" : ["-73.93615", "40.69791"] }, "rating" : 9 }

要了解有关 geoShape 操作符的更多信息，请参阅 geoShape Atlas 指南。

GeoWithin

使用 GeoWithin() 方法搜索指定 GeoJSON 字段坐标在给定几何范围内的文档。您可以搜索以下范围内的点：

圆形
边界框
多边形

指定要搜索的坐标时，必须首先指定经度，然后指定纬度。经度值可以介于 -180 到 180 （含）之间。纬度值可以介于 -90 到 90（含）之间。

注意

MongoDB Search 不支持以下内容：

非默认坐标参考系 (CRS)
平面 XY 坐标系（二维）
坐标对点符号 (pointFieldName: [12, 34])

考虑到 guitars 集合中的某些文档已添加 in_stock_location 字段。现在，集合中的变更文档如下所示：

{ "_id": 1, "make": "Fender", "description": "...", "establishedYear": 1946, "in_stock": true, "in_stock_location":  { "type": "Point", "coordinates": [ -73.93615, 40.69791 ]}, "rating": 9 }
{ "_id": 2, "make": "Gibson", "description": "...", "establishedYear": 1902, "in_stock": true, "in_stock_location":  { "type": "Point", "coordinates": [ 47.6062, 122.321 ]}, "rating": 8 }

以下示例会搜索 in_stock_location 字段中的坐标位于指定多边形内的所有文档：

GeoJsonPolygon<GeoJson2DGeographicCoordinates> searchArea = new(new(new(new GeoJson2DGeographicCoordinates[]
{
     new(-74.3994140625, 40.5305017757),
     new(-74.7290039063, 40.5805846641),
     new(-74.7729492188, 40.9467136651),
     new(-74.0698242188, 41.1290213475),
     new(-73.65234375, 40.9964840144),
     new(-72.6416015625, 40.9467136651),
     new(-72.3559570313, 40.7971774152),
     new(-74.3994140625, 40.5305017757),
})));
var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.GeoWithin(g => g.InStockLocation, searchArea))
    .ToList();

此搜索将返回如下文档：

{ "_id" : 1, "make" : "Fender", "description" : "Classic guitars known for their versatility.", "establishedYear" : 1946, "in_stock" : true, "in_stock_location" : { "type" : "Point", "coordinates" : ["-73.93615", "40.69791"] }, "rating" : 9 }

要了解有关 geoWithin 操作符的更多信息，请参阅 geoWithin Atlas 指南。

Near

使用 Near() 方法搜索指定的字段接近给定值的文档。您可以对以下对象执行搜索：

数字字段
日期字段
地理点

以下示例会在 guitars 集合中搜索 rating 字段的值接近 9 的文档。根据该值与数字 9 的接近程度按顺序返回文档。

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Near(g => g.Rating, 9, 1))
    .ToList();

搜索会返回以下文档：

{ "_id" : 1, "make" : "Fender", "description" : "...", "establishedYear" : 1946, "in_stock" : true, "rating" : 9 }
{ "_id" : 3, "make" : "PRS", "description" : "...", "establishedYear" : 1985, "in_stock" : true, "rating" : 9 }
{ "_id" : 2, "make" : "Gibson", "description" : "...", "establishedYear" : 1902, "in_stock" : true, "rating" : 8 }
{ "_id" : 5, "make" : "Ibanez", "description" : "...", "establishedYear" : 1957, "in_stock" : true, "rating" : 7 }

要了解有关 near 操作符的更多信息，请参阅 near Atlas 指南。

短语

使用 Phrase() 方法搜索指定字段包含输入字符串的文档。

如下示例将在 guitars 集合中搜索 description（说明）字段包含短语“classic guitars”的文档。

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Phrase(g => g.Description, "classic guitars"))
    .ToList();

搜索会返回以下文档：

{ "_id" : 1, "make" : "Fender", "description" : "Classic guitars known for their versatility.", "establishedYear" : 1946, "in_stock" : true, "rating" : 9 }
{ "_id" : 2, "make" : "Gibson", "description" : "Classic guitars known for their rich, full tones.", "establishedYear" : 1902, "in_stock" : true, "rating" : 8 }

您还可以按以下方式搜索与多个单独短语匹配的文档：

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Phrase(g => g.Description, new List<string>() { "classic guitars", "quality guitars" }))
    .ToList();

此搜索将返回以下文档：

{ "_id" : 1, "make" : "Fender", "description" : "Classic guitars known for their versatility.", "establishedYear" : 1946, "in_stock" : true, "rating" : 9 }
{ "_id" : 4, "make" : "Kiesel", "description" : "Quality guitars made only for custom orders.", "establishedYear" : 2015, "in_stock" : false, "rating" : null }
{ "_id" : 2, "make" : "Gibson", "description" : "Classic guitars known for their rich, full tones.", "establishedYear" : 1902, "in_stock" : true, "rating" : 8 }

要了解有关 phrase 操作符的更多信息，请参阅短语 Atlas 指南。

QueryString

使用 QueryString() 方法，将一个字符串与以下操作符和分隔符结合使用以搜索文档：

AND
OR
NOT
()

以下示例会在 guitars 集合中搜索 description 字段的值与以下每个条件匹配的文档：

包含字符串“classic”或字符串“quality”
不包含字符串“自定义”

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.QueryString(g => g.Description, "(classic OR quality) AND NOT custom"))
    .ToList();

搜索会返回以下文档：

{ "_id" : 1, "make" : "Fender", "description" : "Classic guitars known for their versatility.", "establishedYear" : 1946, "in_stock" : true, "rating" : 9 }
{ "_id" : 3, "make" : "PRS", "description" : "High-end guitars known for their quality.", "establishedYear" : 1985, "in_stock" : true, "rating" : 9 }
{ "_id" : 2, "make" : "Gibson", "description" : "Classic guitars known for their rich, full tones.", "establishedYear" : 1902, "in_stock" : true, "rating" : 8 }

要了解有关 queryString 操作符的更多信息，请参阅 queryString Atlas 指南。

范围

使用 Range() 方法搜索指定字段的值处于给定数字或日期范围内的文档。

以下示例会在 guitars 集合中搜索 establishedYear 值大于 1980 且小于 2020 的所有文档。

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Range(g => g.EstablishedYear, SearchRangeBuilder.Gt(1980).Lt(2020)))
    .ToList();

此搜索将返回以下结果：

{ "_id" : 3, "make" : "PRS", "description" : "High-end guitars known for their quality.", "establishedYear" : 1985, "in_stock" : true, "rating" : 9 }
{ "_id" : 4, "make" : "Kiesel", "description" : "Quality guitars made only for custom orders.", "establishedYear" : 2015, "in_stock" : false, "rating" : null }
{ "_id" : 6, "make" : "Strandberg", "description" : "Modern guitars known for their headless models.", "establishedYear" : 1982, "in_stock" : false, "rating" : null }

如要搜索指定字段的值在字符串范围内的文档，您必须首先在该字段上创建令牌索引。创建索引后，您可以根据字符串范围搜索文档，如下例所示：

// Performs MongoDB Search queries by using the C# driver 
using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
using MongoDB.Bson.Serialization.Conventions;
using MongoDB.Driver;
using MongoDB.Driver.GeoJsonObjectModel;
using MongoDB.Driver.Search;
public class AtlasSearchExamples
{
    private static IMongoCollection<Guitar> guitarsCollection;
    private static string _mongoConnectionString = "<connection string>";
    public static void Main(string[] args)
    {
        Setup();
        var results = AutocompleteSearch();
        foreach (var g in results)
        {
            Console.WriteLine(g.ToBsonDocument());
        }
    }
    public static List<Guitar> AutocompleteSearch()
    {
        // Finds documents with a "make" value that contains the string fragment "Gib"
        // start-autocomplete-search
        var result = guitarsCollection.Aggregate()
            .Search(Builders<Guitar>.Search.Autocomplete(g => g.Make, "Gib"), indexName: "guitarmakes")
            .ToList();
        // end-autocomplete-search
        return result;
    }
    public static List<Guitar> CompoundSearch()
    {
        // Find documents that meet multiple search criteria by using the
        // Compound() search function
        // start-compound-search
        var result = guitarsCollection.Aggregate()
            .Search(Builders<Guitar>.Search.Compound()
                .Must(Builders<Guitar>.Search.Exists(g => g.Rating))
                .MustNot(Builders<Guitar>.Search.Equals(g => g.InStock, false))
                .Must(Builders<Guitar>.Search.Range(g => g.EstablishedYear, SearchRangeBuilder.Gt(1940))))
            .ToList();
        // end-compound-search
        return result;
    }
    public static List<Guitar> EmbeddedDocumentSearch()
    {
        // start-embedded-search
        var result = guitarsCollection.Aggregate()
            .Search(Builders<Guitar>.Search.EmbeddedDocument(
                g => g.ProductDetails,
                Builders<ProductDetails>.Search.Text(p => p.Serial, "YZ5678")
            )).ToList();
        return result;
        // end-embedded-search
    }
    public static List<Guitar> EqualsSearch()
    {
        // start-equals-search
        var result = guitarsCollection.Aggregate()
            .Search(Builders<Guitar>.Search.Equals(g => g.InStock, true))
            .ToList();
        // end-equals-search
        return result;
    }
    public static List<Guitar> ExistsSearch()
    {
        // start-exists-search
        var result = guitarsCollection.Aggregate()
            .Search(Builders<Guitar>.Search.Exists(g => g.Rating))
            .ToList();
        // end-exists-search
        return result;
    }
    public static List<Guitar> GeoShapeSearch()
    {
        // start-geoshape-search
        GeoJsonPolygon<GeoJson2DGeographicCoordinates> searchArea = new(new(new(new GeoJson2DGeographicCoordinates[]
        {
             new(-72.93615, 41.69791),
             new(-72.93615, 40.59791),
             new(-74.93615, 40.59791),
             new(-74.93615, 41.69791),
             new(-72.93615, 41.69791),
        })));
        var result = guitarsCollection.Aggregate()
            .Search(Builders<Guitar>.Search.GeoShape(g => g.InStockLocation, GeoShapeRelation.Intersects, searchArea))
            .ToList();
        // end-geoshape-search
        return result;
    }
    public static List<Guitar> GeoWithinSearch()
    {
        // start-geowithin-search
        GeoJsonPolygon<GeoJson2DGeographicCoordinates> searchArea = new(new(new(new GeoJson2DGeographicCoordinates[]
        {
             new(-74.3994140625, 40.5305017757),
             new(-74.7290039063, 40.5805846641),
             new(-74.7729492188, 40.9467136651),
             new(-74.0698242188, 41.1290213475),
             new(-73.65234375, 40.9964840144),
             new(-72.6416015625, 40.9467136651),
             new(-72.3559570313, 40.7971774152),
             new(-74.3994140625, 40.5305017757),
        })));
        var result = guitarsCollection.Aggregate()
            .Search(Builders<Guitar>.Search.GeoWithin(g => g.InStockLocation, searchArea))
            .ToList();
        // end-geowithin-search
        return result;
    }
    public static List<Guitar> InSearch()
    {
        // start-in-search
        var result = guitarsCollection.Aggregate()
            .Search(Builders<Guitar>.Search.In(g => g.Make, ["Fender", "Gibson"]))
            .ToList();
        // end-in-search
        return result;
    }
    public static List<Guitar> MoreLikeThisSearch()
    {
        // start-morelikethis-search
        var searchDocument = new GuitarSearch()
        {
            Description = "high quality",
        };
        var result = guitarsCollection.Aggregate()
            .Search(Builders<Guitar>.Search.MoreLikeThis(searchDocument))
            .ToList();
        // end-morelikethis-search
        return result;
    }
    public static List<Guitar> NearSearch()
    {
        // start-near-search
        var result = guitarsCollection.Aggregate()
            .Search(Builders<Guitar>.Search.Near(g => g.Rating, 9, 1))
            .ToList();
        // end-near-search
        return result;
    }
    public static List<Guitar> PhraseSearch()
    {
        // start-phrase-search
        var result = guitarsCollection.Aggregate()
            .Search(Builders<Guitar>.Search.Phrase(g => g.Description, "classic guitars"))
            .ToList();
        // end-phrase-search
        return result;
    }
    public static List<Guitar> PhraseMultipleSearch()
    {
        // start-multiphrase-search
        var result = guitarsCollection.Aggregate()
            .Search(Builders<Guitar>.Search.Phrase(g => g.Description, new List<string>() { "classic guitars", "quality guitars" }))
            .ToList();
        // end-multiphrase-search
        return result;
    }
    public static List<Guitar> QueryStringSearch()
    {
        // start-querystring-search
        var result = guitarsCollection.Aggregate()
            .Search(Builders<Guitar>.Search.QueryString(g => g.Description, "(classic OR quality) AND NOT custom"))
            .ToList();
        // end-querystring-search
        return result;
    }
    public static List<Guitar> RangeSearch()
    {
        // start-range-search
        var result = guitarsCollection.Aggregate()
            .Search(Builders<Guitar>.Search.Range(g => g.EstablishedYear, SearchRangeBuilder.Gt(1980).Lt(2020)))
            .ToList();
        // end-range-search
        return result;
    }
    public static List<Guitar> RegexSearch()
    {
        // start-regex-search
        var regex = "[A-Za-z]{6}";
        var result = guitarsCollection.Aggregate()
            .Search(Builders<Guitar>.Search.Regex(g => g.Make, regex))
            .ToList();
        // end-regex-search
        return result;
    }
    public static List<Guitar> SpanSearch()
    {
        // start-span-search
        var searchTerms = new[]
        {
             Builders<Guitar>.SearchSpan.Term(g => g.Description, "guitars"),
             Builders<Guitar>.SearchSpan.Term(g => g.Description, "quality")
         };
        var result = guitarsCollection.Aggregate()
            .Search(Builders<Guitar>.Search.Span(Builders<Guitar>.SearchSpan.Near(searchTerms, 1)))
            .ToList();
        // end-span-search
        return result;
    }
    public static List<Guitar> TextSearch()
    {
        // start-text-search
        var result = guitarsCollection.Aggregate()
            .Search(Builders<Guitar>.Search.Text(g => g.Description, "used by professional"))
            .ToList();
        // end-text-search
        return result;
    }
    public static List<Guitar> WildcardSearch()
    {
        // start-wildcard-search
        var result = guitarsCollection.Aggregate()
            .Search(Builders<Guitar>.Search.Wildcard(g => g.Make, "Strand*"))
            .ToList();
        // end-wildcard-search
        return result;
    }
    private static void Setup()
    {
        // This allows automapping of the camelCase database fields to our models. 
        var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
        ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);
        // Establish the connection to MongoDB and get the restaurants database
        var mongoClient = new MongoClient(_mongoConnectionString);
        var restaurantsDatabase = mongoClient.GetDatabase("sample_guitars");
        guitarsCollection = restaurantsDatabase.GetCollection<Guitar>("guitars");
    }
}
public class GuitarSearch
{
    public string Description { get; set; }
}
public class Guitar
{
    public int Id { get; set; }
    public string Make { get; set; }
    public string Description { get; set; }
    public int EstablishedYear { get; set; }
    [BsonElement("in_stock")]
    public bool InStock { get; set; }
    [BsonElement("in_stock_location")]
    public Location InStockLocation { get; set; }
    public int? Rating { get; set; }
}
public class Location
{
    public string Type { get; set; }
    public List<decimal> Coordinates { get; set; }
}

前面的示例搜索 make字段的字符串值大于或等于 "Fender" 且小于或等于 "Kiesel" 的任何文档。驾驶员按字典顺序比较字符串值。

此搜索将返回以下结果：

{ "_id" : 1, "make" : "Fender", "description" : "Classic guitars known for their versatility.", "establishedYear" : 1946, "in_stock" : true, "rating" : 9 }
{ "_id" : 2, "make" : "Gibson", "description" : "Classic guitars known for their rich, full tones.", "establishedYear" : 1902, "in_stock" : true, "rating" : 8 }
{ "_id" : 4, "make" : "Kiesel", "description" : "Quality guitars made only for custom orders.", "establishedYear" : 2015, "in_stock" : false, "rating" : null }
{ "_id" : 5, "make" : "Ibanez", "description" : "Well-crafted guitars used by many professional guitarists.", "establishedYear" : 1957, "in_stock" : true, "rating" : 7 }

要了解有关 range 操作符的更多信息，请参阅 range Atlas 指南。

正则表达式(Regex)

使用 Regex() 方法使用正则表达式搜索文档。

以下示例会在 guitars 集合中搜索 make 字段的值恰好包含六个字母的文档。

var regex = "[A-Za-z]{6}";
var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Regex(g => g.Make, regex))
    .ToList();

此搜索将返回以下结果：

{ "_id" : 1, "make" : "Fender", "description" : "Classic guitars known for their versatility.", "establishedYear" : 1946, "in_stock" : true, "rating" : 9 }
{ "_id" : 2, "make" : "Gibson", "description" : "Classic guitars known for their rich, full tones.", "establishedYear" : 1902, "in_stock" : true, "rating" : 8 }
{ "_id" : 4, "make" : "Kiesel", "description" : "Quality guitars made only for custom orders.", "establishedYear" : 2015, "in_stock" : false, "rating" : null }
{ "_id" : 5, "make" : "Ibanez", "description" : "Well-crafted guitars used by many professional guitarists.", "establishedYear" : 1957, "in_stock" : true, "rating" : 7 }

注意

默认情况下，regex 操作符不能在分析字段上运行。您可以通过将 allowAnalyzedField 选项设置为 true，支持在分析字段上执行该操作符，如下所示：

var result = guitarsCollection.Aggregate()
 .Search(Builders<Guitar>.Search.Regex(g => g.Make, regex, true))
 .ToList();

将 allowAnalyzedField 选项设置为 true 可能会导致意外的搜索结果。要了解详情，请参阅 regex 行为。

要了解有关 regex 操作符的更多信息，请参阅 regex Atlas 指南。

span

使用 Span() 方法，搜索字段区域内的文本搜索匹配项。您可以使用该方法，按照指定的精度查找相似的字符串。

注意

span 操作符比其他操作符的计算量更大，因为查询必须跟踪位置信息。

如下示例将在 guitars 集合中搜索 description（说明）字段的值包含彼此相邻的字符串“guitars”和“quality”的文档。

var searchTerms = new[]
{
     Builders<Guitar>.SearchSpan.Term(g => g.Description, "guitars"),
     Builders<Guitar>.SearchSpan.Term(g => g.Description, "quality")
 };
var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Span(Builders<Guitar>.SearchSpan.Near(searchTerms, 1)))
    .ToList();

此搜索将返回如下文档：

{ "_id" : 4, "make" : "Kiesel", "description" : "Quality guitars made only for custom orders.", "establishedYear" : 2015, "in_stock" : false, "rating" : null }

虽然带有 _id: 3 的文档包含字符串“guitars”和“quality”，但它们由多个单词分隔，搜索结果忽略了该文档。

要了解有关 span 操作员的更多信息，请参阅 span Atlas 指南。

Text

使用 Text() 方法在文档搜索给定的字符串或字符串大量。如果给定字符串中有多个词， MongoDB Search 还会分别为字符串中的每个术语查找匹配项。

以下示例会在 guitars 集合中搜索 description 字段的值包含字符串“used by professionals”（专业人员使用）的文档。

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Text(g => g.Description, "used by professional"))
    .ToList();

此搜索将返回如下文档：

{ "_id" : 5, "make" : "Ibanez", "description" : "Well-crafted guitars used by many professional guitarists.", "establishedYear" : 1957, "in_stock" : true, "rating" : 7 }

提示

如果您的搜索字符串包含多个术语，此方法还会分别查找字符串中的每个术语的匹配项。

要了解有关 text 操作符的更多信息，请参阅 text Atlas 指南。

通配符

使用 Wildcard() 方法在搜索字符串中使用可以匹配任何字符的特殊字符来搜索文档。您可以在搜索中使用以下字符：

字符	说明
`?`	匹配任意单个字符。
`*`	匹配 0 个或更多字符。
`\`	转义字符

以下示例会搜索 make 字段的值包含字符串“Strand”，后跟任何其他字符的文档。

var result = guitarsCollection.Aggregate()
    .Search(Builders<Guitar>.Search.Wildcard(g => g.Make, "Strand*"))
    .ToList();

此搜索将返回如下文档：

{ "_id" : 6, "make" : "Strandberg", "description" : "Modern guitars known for their headless models.", "establishedYear" : 1982, "in_stock" : false, "rating" : null }

注意

默认情况下，wildcard 操作符不能在分析字段上运行。您可以通过将 allowAnalyzedField 选项设置为 true，支持在分析字段上执行该操作符，如下所示：

var result =  guitarsCollection.Aggregate()
 .Search(Builders<Guitar>.Search.Wildcard(g => g.Make, "Strand*", true))
 .ToList();

将 allowAnalyzedField 选项设置为 true，可能会导致意外的搜索结果。要了了解详情，请参阅 wildcard 行为。

要了解有关 wildcard 操作符的更多信息，请参阅 wildcard Atlas 指南。

后退

运行数据库命令

来年

MongoDB Vector Search

MongoDB Search

Overview

注意

适用于Atlas for MongoDB v4.2 及更高版本

注意

创建MongoDB搜索索引

MongoDB搜索操作符

自动完成(Autocomplete)

注意

自动完成查询的索引

多个子句

嵌入式文档

注意

Equals

Exists

GeoShape

注意

GeoWithin

注意

登录

更多类似内容

Near

短语

QueryString

范围

正则表达式(Regex)

注意

span

注意

Text

提示

通配符

注意