MongoDB操作-查

同步查询一条数据

查询数据时，可以按照整行进行查询，也可以只查询某行的一个或几个字段（属性）.

当我们查询整行时，直接使用FilterDefinition设置好ObjectId条件即可查询整行。

当我们查询一个或几个字段（属性）时，需要设置filter的同时，添加ProjectionDefinition，指定好需要查询的字段（属性）

/// <summary>
/// 同步查询数据
/// </summary>
/// <typeparam name="T">实体类</typeparam>
/// <param name="collName">表名</param>
/// <param name="objectId">当前行的id</param>
/// <param name="fields">需要查询的字段或属性名</param>
/// <returns>查询的结果</returns>
public T FindOne<T>(string collName,string objectId, string[]? fields = null) where T : class, new()
{
    try
    {
        var collection = m_Database?.GetCollection<T>(collName);
        FilterDefinition<T> filter = Builders<T>.Filter.Eq("_id",new ObjectId(objectId));
        //不指定查询某个字段（属性）
        if(fields == null || fields.Length == 0)
        {
            return collection.Find(filter).FirstOrDefault<T>();
        }
        //指定查询某个字段（属性）
        var fieldList = new List<ProjectionDefinition<T>>();
        foreach (string field in fields)
        {
            fieldList.Add(Builders<T>.Projection.Include(field));
        }
        var projection = Builders<T>.Projection.Combine(fieldList);
        fieldList?.Clear();
        return collection.Find(filter).Project<T>(projection).FirstOrDefault<T>();
    }
    catch (Exception ex)
    {
        Debug.LogError("根据id查询数据出错：" + ex);
        throw;
    }
}

异步查询一条数据

异步查询数据，将同步查询的FirstOrDefault改为FirstOrDefaultAsync即可。

/// <summary>
/// 异步查询数据
/// </summary>
/// <typeparam name="T">实体类</typeparam>
/// <param name="collName">表名</param>
/// <param name="objectId">当前行的id</param>
/// <param name="fields">需要查询的字段或属性名</param>
/// <returns>查询的结果</returns>
public async Task<T> FindOneAsync<T>(string collName, string objectId, string[]? fields = null) where T : class, new()
{
    try
    {
        var collection = m_Database?.GetCollection<T>(collName);
        FilterDefinition<T> filter = Builders<T>.Filter.Eq("_id", new ObjectId(objectId));
        //不指定查询某个字段（属性）
        if (fields == null || fields.Length == 0)
        {
            return await collection.Find(filter).FirstOrDefaultAsync<T>();//
        }
        //指定查询某个字段（属性）
        var fieldList = new List<ProjectionDefinition<T>>();
        foreach (string field in fields)
        {
            fieldList.Add(Builders<T>.Projection.Include(field));
        }
        var projection = Builders<T>.Projection.Combine(fieldList);
        fieldList?.Clear();
        return await collection.Find(filter).Project<T>(projection).FirstOrDefaultAsync<T>();//
    }
    catch (Exception ex)
    {
        Debug.LogError("根据id查询数据出错：" + ex);
        throw;
    }
}

同步批量查询数据

批量查询数据，我们需要将FilterDefinition作为参数，这个参数指定了批量查询的条件。我们还增加了SortDefinition参数，指定了排序条件。

/// <summary>
/// 同步批量查询数据
/// </summary>
/// <typeparam name="T">实体类</typeparam>
/// <param name="collName">表名</param>
/// <param name="filter">查询条件</param>
/// <param name="fields">需要查询的字段或属性名</param>
/// <param name="sort">排序规则</param>
/// <returns>查询的结果</returns>
public List<T> FindMany<T>(string collName, FilterDefinition<T> filter, string[]? fields = null, SortDefinition<T>? sort = null) where T : class, new()
{
    try
    {
        var collection = m_Database?.GetCollection<T>(collName);
        if (fields == null || fields.Length == 0)
        {
            if(sort == null) return collection.Find(filter).ToList();
            //进行排序
            return collection.Find(filter).Sort(sort).ToList();
        }
        //指定查询某个字段（属性）
        var fieldList = new List<ProjectionDefinition<T>>();
        foreach (string field in fields)
        {
            fieldList.Add(Builders<T>.Projection.Include(field));
        }
        var projection = Builders<T>.Projection.Combine(fieldList);
        fieldList?.Clear();

        if(sort == null) return collection.Find(filter).Project<T>(projection).ToList();
        return collection.Find(filter).Sort(sort).Project<T>(projection).ToList();
    }
    catch (Exception ex)
    {
        Debug.LogError("批量查询数据出错：" + ex);
        throw;
    }
}

异步批量查询数据

将ToList改为ToListAsync即可

/// <summary>
/// 异步批量查询数据
/// </summary>
/// <typeparam name="T">实体类</typeparam>
/// <param name="collName">表名</param>
/// <param name="filter">查询条件</param>
/// <param name="fields">需要查询的字段或属性名</param>
/// <param name="sort">排序规则</param>
/// <returns>查询的结果</returns>
public async Task<List<T>> FindManyAsync<T>(string collName, FilterDefinition<T> filter, string[]? fields = null, SortDefinition<T>? sort = null) where T : class, new()
{
    try
    {
        var collection = m_Database?.GetCollection<T>(collName);
        if (fields == null || fields.Length == 0)
        {
            if (sort == null) return await collection.Find(filter).ToListAsync();
            //进行排序
            return await collection.Find(filter).Sort(sort).ToListAsync();
        }
        //指定查询某个字段（属性）
        var fieldList = new List<ProjectionDefinition<T>>();
        foreach (string field in fields)
        {
            fieldList.Add(Builders<T>.Projection.Include(field));
        }
        var projection = Builders<T>.Projection.Combine(fieldList);
        fieldList?.Clear();

        if (sort == null) return await collection.Find(filter).Project<T>(projection).ToListAsync();
        return await collection.Find(filter).Sort(sort).Project<T>(projection).ToListAsync();
    }
    catch (Exception ex)
    {
        Debug.LogError("异步批量查询数据出错：" + ex);
        throw;
    }
}