您的位置:首页 > 数据库 > Mongodb

MongoDB .Net Driver(C#驱动) - 内嵌数组/嵌入文档的操作(增加、删除、修改、查询(Linq 分页))

2018-03-16 20:16 1341 查看

一. 前言

本教程是入门基础教程,主要是笔者在项目中使用MongoDB .Net官方驱动对MongoDB内嵌文档的操作时遇到了很多不方便的情况,踩了很多的坑,所以单独整理出来一篇文章,来讲一讲笔者踩坑的过
4000
程。

笔者水平有限,如有错误还请批评指正!

(一). 运行环境

.net版本

.Net Framwork 4.6.2 x64


MongoDb数据库版本

MongoDb 3.6.2 x64


驱动版本

MongoDb Driver 2.5


笔者采用的MongoDB驱动是官方2.5版本驱动,大家可以通过下载GitHub源码自行编译,或者通过NuGet包管理工具安装。

GitHub地址:戳一戳查看、Link

NuGet地址:戳一戳查看、Link

本例源码已上传至Gitee

本例源码地址:戳一戳、Link

二. 前期准备工作

(一). 创建 MongoDBContext MongoDb操作上下文类

创建MongoDBContext操作上下文类,用于连接Mongodb数据库和管理Collection对象


using MongoDB.Bson;
using MongoDB.Driver;
using System;
using System.Collections.Generic;
using System.Security.Authentication;
using System.Threading.Tasks;

namespace MongoDBEmbeddedOperation
{
public class MongoDbContext
{
#region Fields
/// <summary>
/// 缓存Mongodb集合
/// </summary>
private Dictionary<string, object> _collectionsMongoDb;

#endregion

#region Properties
/// <summary>
/// 数据库连接字符串
/// </summary>
public string ConnectionString { get; }

/// <summary>
/// Mongo客户端设置
/// </summary>
public MongoClientSettings Settings { get; }

/// <summary>
/// 数据库名称
/// </summary>
public string DatabaseName { get; }

/// <summary>
/// Mongo上下文
/// </summary>
public IMongoDatabase DbContext { get; }
#endregion

/// <summary>
/// MongoDb数据上下文
/// </summary>
/// <param name="connectionString">
/// 连接字符串,如:"mongodb://username:password@host:port/[DatabaseName]?ssl=true"
/// 详情参见:http://www.runoob.com/mongodb/mongodb-connections.html
/// </param>
public MongoDbContext(string connectionString)
{
if (string.IsNullOrWhiteSpace(connectionString))
throw new ArgumentException("connectionString 连接字符串不能为空!");

try
{
var mongoUrl = new MongoUrl(connectionString);
ConnectionString = connectionString;
Settings = MongoClientSettings.FromUrl(mongoUrl);

if (string.IsNullOrWhiteSpace(mongoUrl.DatabaseName))
throw new ArgumentException("数据库名称不能为空!");

DatabaseName = mongoUrl.DatabaseName;
// SSL加密
if (Settings.UseSsl)
{
Settings.SslSettings = new SslSettings
{
EnabledSslProtocols = SslProtocols.Tls12
};
}

var mongoClient = new MongoClient(Settings);
DbContext = mongoClient.GetDatabase(DatabaseName);
}
catch (Exception e)
{
// TODO: 记录错误日志
throw;
}
}

/// <summary>
/// 异步获取集合
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <returns></returns>
public async Task<IMongoCollection<TEntity>> GetCollectionAsync<TEntity>() where TEntity : class
{
// 集合缓存如果为空,那么创建一个
if (_collectionsMongoDb == null)
{
_collectionsMongoDb = new Dictionary<string, object>();
}

// 获取集合名称,使用的标准是在实体类型名后添加Set
var collectionName = $"{typeof(TEntity).Name}Set";

// 如果集合不存在,那么创建集合
if (false == await IsCollectionExistsAsync<TEntity>())
{
await DbContext.CreateCollectionAsync(collectionName);
}

// 如果缓存中没有该集合,那么加入缓存
if (!_collectionsMongoDb.ContainsKey(collectionName))
{
_collectionsMongoDb[collectionName] = DbContext.GetCollection<TEntity>(collectionName);
}

// 从缓存中取出集合返回
return (IMongoCollection<TEntity>)_collectionsMongoDb[collectionName];
}

/// <summary>
/// 集合是否存在
/// </summary>
/// <typeparam name="TEntity"></typeparam>
/// <returns></returns>
public async Task<bool> IsCollectionExistsAsync<TEntity>()
{
var filter = new BsonDocument("name", $"{typeof(TEntity).Name}Set");
// 通过集合名称过滤
var collections = await DbContext.ListCollectionsAsync(new ListCollectionsOptions { Filter = filter });
// 检查是否存在
return await collections.AnyAsync();
}
}
}


(二). 创建测试类

假设当前是一个物联网数据采集项目,其中有很多个传感器节点(SensorNode),每个节点都会产生记录(Records),一条记录(Record)由数据值(Data)和记录时间(RecordDateTime)组成。要求对其Recods内嵌数组进行增删改查操作。

那么由上需求可以抽象出如下对象关系,在实际应用中,不建议将记录直接放在SensorNode下,因为Mongodb数据库对单个文档有16MB的大小限制

/// <summary>
/// 传感器节点
/// </summary>
public class SensorNode
{
/// <summary>
/// ID
/// </summary>
public ObjectId Id { get; set; }

/// <summary>
/// 记录数
/// </summary>
public List<Record> Records { get; set; }
}

/// <summary>
/// 数据记录
/// </summary>
public class Record
{
/// <summary>
/// 数据值
/// </summary>
public double Data { get; set; }

/// <summary>
/// 记录时间
/// </summary>
public DateTime RecorDateTime { get; set; }
}


测试类所对应的Bson结构,如下所示.

{
"_id" : ObjectId("5aa877e4aa25752ab4d4cae3"),
"Records" : [
{
"Data" : 1962163552.0,
"RecorDateTime" : ISODate("2018-03-16T10:01:14.931Z")
},
{
"Data" : 1111405346.0,
"RecorDateTime" : ISODate("2018-03-16T08:53:14.931Z")
},
......
]
}


(三). 创建测试代码

新建一个控制台程序,加入以下代码。对MongodbContext进行初始化,插入用于测试的SensorNode.


using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using MongoDB.Bson;
using MongoDB.Driver.Linq; // <---- 此引用非常重要
using MongoDB.Driver;

......

private static ObjectId _sensorNodeId;
private static MongoDbContext _dbContext;
private static IMongoCollection<SensorNode> _sensorNodes;
static void Main(string[] args)
{
// 使用链接字符串创建dbContext对象
_dbContext = new MongoDbContext("mongodb://hynuAdmin:123456@localhost:27017/HynuIOTA");
// 创建_Sensors数据库,入口方法不能使用异步,我们等待结果返回
_sensorNodes = _dbContext.GetCollectionAsync<SensorNode>().Result;
// 创建一个SensorNode 存入MongoDb数据库中
_sensorNodeId = ObjectId.Parse("5aa877e4aa25752ab4d4cae3");
#region 创建测试用例
var sensorNode = new SensorNode()
{
Id = _sensorNodeId,
Records = new List<Record>()
};
// 插入数据库中
_sensorNodes.InsertOne(sensorNode);
#endregion
}


添加一个方法,用于随机生成Record对象。


/// <summary>
/// 生成count个Rocred对象
/// </summary>
/// <param name="count">生成数量</param>
/// <returns></returns>
static List<Record> GetRandomRecord(int count)
{
var records = new List<Record>();
var rd = new Random();
for (int i = 0; i < count; i++)
{
records.Add(new Record()
{
Data = rd.Next(),
RecorDateTime = DateTime.Now.AddMinutes(rd.Next() % 100)
});
}
return records;
}


三. 内嵌数组增加元素操作

(一). Update.Set()方法 替换内嵌数组(不推荐使用)

此方法主要使用操作符[$set],它的思路是先将内嵌文档的父元素查找出来,然后对子文档数组进行增删改操作,最后将子文档数组重新替换。此方式性能较低,除非涉及到大批量更改,否则不推荐使用。

#region 方法一. 查出sensor再更新Records, $set操作 - 随机插入100个元素(不推荐)
// 查询需修改的sensorNode对象
var sensor = await _sensorNodes.Find(s => s.Id == _sensorNodeId).FirstOrDefaultAsync();
// 往Records里面增加随机元素
sensor.Records.AddRange(GetRandomRecord(100));
// 构建update Bson, 将原有Records替换为新的Records
var update = Builders<SensorNode>.Update.Set(d => d.Records, sensor.Records);
// 使用Update方法
await _sensorNodes.UpdateOneAsync(s => s.Id == _sensorNodeId, update);
#endregion


(二).Update.Push()方法 直接将元素压入内嵌数组(推荐)

此方法主要使用操作符[$push]来增加元素到子文档数组,性能好,推荐使用。

// 构建update Bson ,添加一条记录使用Push方法
var updateOne = Builders<SensorNode>.Update.Push(d => d.Records, GetRandomRecord(1).First());
// 更新
await _sensorNodes.UpdateOneAsync(s => s.Id == _sensorNodeId, updateMany);


(三).Update.PushEach()方法 将多个元素压入内嵌数组(推荐)

此方法使用的也是[$push]操作符,只是在生成BsonDocument时允许接收数组。

#region 方法二. $push操作 - 随机插入100个元素(推荐)
// 构建update Bson 添加多条记录使用PushEach方法
var updateMany = Builders<SensorNode>.Update.PushEach(d => d.Records, GetRandomRecord(100));
// 更新
await _sensorNodes.UpdateOneAsync(s => s.Id == _sensorNodeId, updateMany);
#endregion


四. 内嵌数组删除元素操作

(一) .Update.Set()方法 替换内嵌数组(不推荐使用)

此方式思路和增加元素的思路一致,性能较低,不推荐使用。

#region 方法一 . $set方式删除 - 删除前5个元素(不推荐)
// 查询需修改的sensorNode对象
var sensor = await _sensorNodes.Find(s => s.Id == _sensorNodeId).FirstOrDefaultAsync();
// 删除Record
for (int i = 0; i < 5; i++)
{
sensor.Records.RemoveAt(i);
}
// 构建update Bson, 将原有Records替换为新的Records
var update = Builders<SensorNode>.Update.Set(d => d.Records, sensor.Records);
// 使用Update方法
await _sensorNodes.UpdateOneAsync(s => s.Id == _sensorNodeId, update);
#endregion


(二).Update.Pull()方法 Pull删除一个元素(推荐)

// 假设需要删除的Record已经被查询转换为对象,那么使用Pull方式删除一个元素
var record = new Record()
{ Data = 1670941112.0, RecorDateTime = DateTime.Parse("2018-03-16T09:36:14.930Z") };
// 构建Pull删除Bson
var update = Builders<SensorNode>.Update.Pull(s => s.Records, record);
// 使用Update方法
await _sensorNodes.UpdateOneAsync(s => s.Id == _sensorNodeId, update);


(三).Update.PullFilter()方法 删除过滤器删除元素(推荐)

#region 方法三. PullFilter方式删除 - 删除符合Filter条件的元素(推荐)
// 如果r.Data == 339119843.0,那么从数组中删除
var update = Builders<SensorNode>.Update.PullFilter(s => s.Records, r => r.Data == 339119843.0);
await _sensorNodes.UpdateOneAsync(s => s.Id == _sensorNodeId, update);
#endregion


五. 内嵌数组修改元素操作

(一).Update.Set() Set先查询后修改(不推荐)

此方式性能较低,不推荐。

#region 方法一. $set方式修改(将某个元素记录时间改为最小值) - 先查询后修改(不推荐)
// 查询需修改的sensorNode对象
var sensor = await _sensorNodes.Find(s => s.Id == _sensorNodeId).FirstOrDefaultAsync();
// 修改Record值
sensor.Records[0].RecorDateTime = DateTime.MinValue;
// 构建update Bson, 将原有Records替换为新的Records
var update = Builders<SensorNode>.Update.Set(d => d.Records, sensor.Records);
// 使用Update方法
await _sensorNodes.UpdateOneAsync(s => s.Id == _sensorNodeId, update);
#endregion


(二).Update.Set() 配合过滤器修改(推荐)

在数据库内部完成过滤和修改,性能高,推荐使用。

#region 方法二. $set方式修改(将Data = 1835821478.0的元素记录时间改为最大值) - 直接过滤修改(推荐)
// 构造filter
var filter = Builders<SensorNode>.Filter.Where(s => s.Id == _sensorNodeId)
& Builders<SensorNode>.Filter.Where(d => d.Records.Any(r => r.Data == 1835821478.0));
// 执行更新
var update = Builders<SensorNode>.Update.Set(d => d.Records[-1].RecorDateTime, DateTime.MaxValue);
await _sensorNodes.UpdateOneAsync(filter, update);
#endregion


六. 内嵌数组查找元素操作(Linq)

对于内嵌数组/文档的查询,在.net里建议直接使用Linq或拼接BsonDocument。笔者着重使用Linq方式。


需要先using MongoDB.Driver.Linq,否则Linq无法使用。

(一).Linq查询一条记录(推荐)

主要是SelectMany()方法的使用,此方法用于选择一个数组。

#region SelectMany查询内嵌数组(查询Data = 1340695206.0的第一条记录) - (推荐)
// 转换为Queryable
var result = await _sensorNodes.AsQueryable()
// 查找对应的sensorNode
.Where(s => s.Id == _sensorNodeId)
// 选择Records内嵌数组
.SelectMany(s => s.Records)
// 查找Data == 1340695206.0的元素
.Where(r => r.Data == 1340695206.0)
// 取第一个
.FirstOrDefaultAsync();
#endregion


(二).Linq查询分页 (推荐)

主要区别使用SelectMany其它与EF Linq方式差不多

#region SelectMany、Skip、Take内嵌数组排序分页 - (推荐)
// 页码
var index = 4;
// 页面大小
var size = 10;
// 转换为Queryable
var page = await _sensorNodes.AsQueryable()
// 查找对应的sensorNode
.Where(s => s.Id == _sensorNodeId)
// 选择Records内嵌数组
.SelectMany(s => s.Records)
// 根据记录时间排序
.OrderBy(r => r.RecorDateTime)
// 跳过 index - 1页数据
.Skip((index - 1) * size)
// 选取一页数据
.Take(size)
// 转换为集合
.ToListAsync();
#endregion


对内嵌数组的查询操作主要是通过聚合来实现,以上代码转换为Native方式后是以下命令。


aggregate(
[
{"$match" : { "_id" : ObjectId("5aa877e4aa25752ab4d4cae3") } },
{ "$unwind" : "$Records" },
{ "$project" : { "Records" : "$Records", "_id" : 0 } },
{ "$sort" : { "Records.RecorDateTime" : 1 } }, { "$skip" : 30 }, { "$limit" : 10 }
]);


如果同时引用了System.Linq 和 MongoDB.Driver.Linq 调用Linq方法会产生方法二义性,解决方案链接如下。

Linq方法二义性解决方案:

http://blog.csdn.net/qq_27441069/article/details/79586216

七. 总结

本文简单的介绍了MongoDB C#驱动对内嵌文档的增删改查操作,笔者水平有限,如有错误请批评指正!
欢迎转载,请注明来源!
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: 
相关文章推荐