使用MongoDB修改数据时，需要先定义过滤条件，找到要修改的行，再定义修改内容

同步修改一行记录

在MongoDBMgr里面添加Update方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#region 修改数据
/// <summary>
/// 修改一行数据
/// </summary>
/// <typeparam name="T">实体类</typeparam>
/// <param name="entity">实体</param>
/// <param name="collName">表名</param>
/// <param name="objectId">当前行的id</param>
/// <returns>修改结果</returns>
public UpdateResult Update<T>(T entity,string collName ,string objectId) where T : class, new()
{
    try
    {
        var collection = m_Database?.GetCollection<T>(collName);
        //设置修改条件，这里指的是按照objectId相等为条件
        FilterDefinition<T> filter = Builders<T>.Filter.Eq("_id",new ObjectId(objectId));
        //如果没有使用MongoDB的ObjectId作为Key值，那么这个条件需要这样写（下面的"_id"和objectId都是自己定义的）：
        //FilterDefinition<T> filter = Builders<T>.Filter.Eq("_id", objectId);
        //要修改的属性合集
        var list = new List<UpdateDefinition<T>>();

        foreach (var item in entity.GetType().GetProperties())
        {
            if(item.Name.ToLower() == "_id") continue;//跳过ObjectId
            list.Add(Builders<T>.Update.Set(item.Name,item.GetValue(entity)));//将其他属性名字和值放进合集中
        }
        var updatefilter = Builders<T>.Update.Combine(list);//将合集混合成一条修改命令
        return collection!.UpdateOne(filter, updatefilter);//修改对应的一行数据
        
    }
    catch (Exception ex)
    {
        Debug.LogError("修改数据出错：" + ex);
        throw;
    }
}
#endregion

异步修改一行记录

前面都一样，最后调用UpdateOneAsync

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/// <summary>
/// 异步修改一行数据
/// </summary>
/// <typeparam name="T">实体类</typeparam>
/// <param name="entity">实体</param>
/// <param name="collName">表名</param>
/// <param name="objectId">当前行的id</param>
/// <returns>修改结果</returns>
public async Task<UpdateResult> UpdateAsync<T>(T entity, string collName, string objectId) where T : class, new()
{
    try
    {
        var collection = m_Database?.GetCollection<T>(collName);
        //设置修改条件，这里指的是按照objectId相等为条件
        FilterDefinition<T> filter = Builders<T>.Filter.Eq("_id", new ObjectId(objectId));
        //要修改的属性合集
        var list = new List<UpdateDefinition<T>>();

        foreach (var item in entity.GetType().GetProperties())
        {
            if (item.Name.ToLower() == "_id") continue;//跳过ObjectId
            list.Add(Builders<T>.Update.Set(item.Name, item.GetValue(entity)));//将其他属性名字和值放进合集中
        }
        var updatefilter = Builders<T>.Update.Combine(list);//将合集混合成一条修改命令
        return await collection!.UpdateOneAsync(filter, updatefilter);//修改对应的一行数据

    }
    catch (Exception ex)
    {
        Debug.LogError("异步修改数据出错：" + ex);
        throw;
    }
}

同步批量修改记录

在MongoDBMgr里面添加UpdateMany方法，核心API是使用collection!.UpdateMany

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/// <summary>
/// 批量修改数据
/// </summary>
/// <typeparam name="T">实体类</typeparam>
/// <param name="collName">表名</param>
/// <param name="dic">要修改的属性合集</param>
/// <param name="filter">修改条件</param>
/// <returns>修改结果</returns>
public UpdateResult UpdateMany<T>(string collName, Dictionary<string,string> dic, FilterDefinition<T> filter) where T : class, new()
{
    try
    {
        var collection = m_Database?.GetCollection<T>(collName);
        T t = new T();
        //要修改的属性
        var list = new List<UpdateDefinition<T>>();
        foreach (var item in t.GetType().GetProperties())
        {
            if(!dic.ContainsKey(item.Name)) continue;
            var value = dic[item.Name];
            list.Add(Builders<T>.Update.Set(item.Name, value));
        }
        var updatefilter = Builders<T>.Update.Combine(list);
        return collection!.UpdateMany(filter,updatefilter);

    }
    catch (Exception ex)
    {
        Debug.LogError("批量修改数据出错：" + ex);
        throw;
    }
}

这里批量修改其实是体现在这个方法的filter参数上，设定一个能修改多行的条件就好了。

异步批量修改记录

在MongoDBMgr里面添加UpdateManyAsync方法，核心API是使用collection!.UpdateManyAsync

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/// <summary>
/// 异步批量修改数据
/// </summary>
/// <typeparam name="T">实体类</typeparam>
/// <param name="collName">表名</param>
/// <param name="dic">要修改的属性合集</param>
/// <param name="filter">修改条件</param>
/// <returns>修改结果</returns>
public async Task<UpdateResult> UpdateManyAsync<T>(string collName, Dictionary<string, string> dic, FilterDefinition<T> filter) where T : class, new()
{
    try
    {
        var collection = m_Database?.GetCollection<T>(collName);
        T t = new T();
        //要修改的属性
        var list = new List<UpdateDefinition<T>>();
        foreach (var item in t.GetType().GetProperties())
        {
            if (!dic.ContainsKey(item.Name)) continue;
            var value = dic[item.Name];
            list.Add(Builders<T>.Update.Set(item.Name, value));
        }
        var updatefilter = Builders<T>.Update.Combine(list);
        return await collection!.UpdateManyAsync(filter, updatefilter);
    }
    catch (Exception ex)
    {
        Debug.LogError("异步批量修改数据出错：" + ex);
        throw;
    }
}