2. 程式人生 > >MongoDB .Net Driver(C#驅動) - 內嵌數組/嵌入文檔的操作(增加、刪除、修改、查詢(Linq 分頁))

MongoDB .Net Driver(C#驅動) - 內嵌數組/嵌入文檔的操作(增加、刪除、修改、查詢(Linq 分頁))

阿新 • • 發佈：2018-07-30
odbc article err native linq protocol remove mit 實體類

目錄

  • 一、前言
    • (一) 運行環境
  • 二、前期準備工作
    • （一) 創建 MongoDBContext MongoDb操作上下文類
    • （二）創建測試類
    • （三） 創建測試代碼
  • 三、內嵌數組增加元素操作
    • （一） Update.Set()方法 替換內嵌數組（不推薦使用）
    • （二）Update.Push()方法 直接將元素壓入內嵌數組（推薦）
    • (三) Update.PushEach()方法 將多個元素壓入內嵌數組（推薦）
  • 四、內嵌數組刪除元素操作
    • (一) Update.Set()方法 替換內嵌數組（不推薦使用）
    • (二) Update.Pull()方法 Pull刪除一個元素（推薦）
    • （三）Update.PullFilter()方法 刪除過濾器刪除元素（推薦）
  • 五、內嵌數組修改元素操作
    • （一） Update.Set() Set先查詢後修改（不推薦）
    • （二） Update.Set() 配合過濾器修改（推薦）
  • 六、內嵌數組查找元素操作(Linq)
    • （一）Linq查詢一條記錄（推薦）
    • （二）Linq查詢分頁 (推薦)
  • 七、總結

一、前言

本教程是入門基礎教程，主要是筆者在項目中使用MongoDB .Net官方驅動對MongoDB內嵌文檔的操作時遇到了很多不方便的情況，踩了很多的坑，所以單獨整理出來一篇文章，來講一講筆者踩坑的過程。

筆者水平有限，如有錯誤還請批評指正！

(一) 運行環境

.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#驅動對內嵌文檔的增刪改查操作，筆者水平有限，如有錯誤請批評指正！
  歡迎轉載，請註明來源！

MongoDB .Net Driver(C#驅動) - 內嵌數組/嵌入文檔的操作(增加、刪除、修改、查詢(Linq 分頁))

相關推薦

MongoDB .Net Driver(C#驅動) - 內嵌數組/嵌入文檔的操作(增加、刪除、修改、查詢(Linq 分頁))

odbc article err native linq protocol remove mit 實體類 目錄 一、前言 (一) 運行環境 二、前期準備工作 （一) 創建 MongoDBContext MongoDb操作上下文類 （二）創建測試類 （三） 創建測試代碼

Mongodb內嵌數組的完全匹配查詢

mongo 查詢條件 body god font ont detail mongod 內嵌 樣例數據： {      "cNo" : "11",    

MongoDB數據庫文檔操作

數據庫插入文檔　　要將數據插入到 MongoDB 集合中，需要使用 MongoDB 的 insert()或save()方法，還有insertOne()或insertMany()方法【insert()】　　insert()命令的基本語法如下db.COLLECTION_NAME.insert(document)　

數組中元素的動態增加和刪除

solid line point ont block mar 增加 cli image 1 <div class="ser-pup-line1"> 2 <div

C#.NET常見問題(FAQ)-list比數組效率低多少

優酷 c# font ima ges ace csr img image 對於List，即長度不確定的數組而言，十萬筆數據*12倍，就是120萬筆數據，只需要93ms左右 ?換成了二維數組，效果也是差不多，78ms，可見list的效率只比double差一點點

C語言結構體數組內帶字符數組初始化和賦值

指定 char 字符數 全局 種類 def 變量 指針 變量定義 1.首先定義結構體數組： typedef struct BleAndTspRmtCmd{ char terminal[3]; char note[3]; char rmtCmd[10]; char cmdP

C語言內嵌匯編

內嵌匯編1.C語言內嵌匯編 1.1內嵌匯編的語法 1.2內嵌匯編示例 #include <stdio.h> int main() { int result = 0; int input = 1; int a = 1; int b = 2; asm v

JAVA內嵌數據庫H2

部分 tool span 分享圖片 總結 和我 一個 web應用 soft H2作為一個嵌入型的數據庫，它最大的好處就是可以嵌入到我們的Web應用中，和我們的Web應用綁定在一起，成為我們Web應用的一部分，本次培訓的目的是前後端分離，在後端中采用H2存儲數據，H2數據庫有

一個基於ASP.NET（C#）的ACCESS數據庫操作類

region array conn 數據庫操作類 ide try esc [] int using System; using System.Collections; using System.Collections.Specialized; using Syst

C行內函數的內外連結的區別

1.行內函數的內連結如inline static void fn(void) {} 沒有任何限制（建議使用） 2.行內函數的外連結如inline void fn(void) {} 則有諸多限制，最易被忽略的便是行內函數的外連結的定義（不僅需要.h檔案的替換體，還需要單獨的.c檔案存放extern&

C++ 行內函數 摘自 C++ 應用程式效能優化

行內函數 在C++語言的設計中，行內函數的引入可以說完全是為了效能的考慮。因此在編寫對效能要求比較高的C++程式時，非常有必要仔細考量行內函數的使用。 所謂"內聯"，即將被呼叫函式的函式體程式碼直接地整個插入到該函式被呼叫處，而不是通過call語句進行。當然，編譯器在真正進行"內聯"時，因為考慮到被行內函數

UE4 C++行內函數

#pragma once #include "CoreMinimal.h" #include "GameFramework/Actor.h" #include "Components/SphereComponent.h" #include "Collecable.generated.h" U

【C++】C++行內函數也可以用來代替巨集

巨集是可以帶引數的，它在形式上和函式非常相似。不過不像函式，巨集僅僅是字串替換，不是按值傳遞，所以在編寫巨集時要特別注意，一不小心可能就會踩坑。 #define SQ(y) y*y 當n = 9 時，SQ(n) = 81 如果把SQ(n)換成SQ(n+1)卻得不到1

C++ 行內函數 （講解的TM真好）【轉】

1.  行內函數 在C++中我們通常定義以下函式來求兩個整數的最大值: 複製程式碼 程式碼如下:  int max(int a, int b)  {   return a > b ? a : b;  }  為這麼一個小的操作定義一個函式的好處有: ① 閱讀和

（一）C++行內函數

行內函數：編譯器將函式程式碼替換函式呼叫，省去函式呼叫帶來的時間和空間開銷，增加程式碼段記憶體開銷。 適用於：函式呼叫的時間代價高於函式執行所需的時間代價，且函式被頻繁呼叫，程式碼簡短。 定義與宣告： 1> 函式宣告前加關鍵字 inline，一般省略原型宣告 2> 函式定義前加關鍵字 inline

C++ 行內函數

行內函數的宣告和定義應該寫在標頭檔案中 //主要CPP 1.h//標頭檔案 //行內函數的宣告和定義應該寫在標頭檔案中 inline int add(int a, int b) { return a + b; } //普通函式的宣告寫.h檔案，定義寫在.c

c++ 學習三 C++行內函數

     使用函式能夠避免將相同程式碼重寫多次的麻煩，還能減少可執行程式的體積，但也會帶來程式執行時間上的開銷。 函式呼叫在執行時，首先要在棧中為形參和區域性變數分配儲存空間，然後還要將實參的值複製給形參，接下來還要將函式的返回地址（該地址指明瞭函式執行結束後，

mongodb對陣列元素及內嵌文件進行增刪改查操作

https://my.oschina.net/132722/blog/168274 比如我有一個user類，他包含一個標籤屬性，這個標籤是一個數組,數組裡面的元素是內嵌文件，格式如下： <!-- lang: js --> { "_id" : "195861", "tags" :

c++ 行內函數和constexper函式

行內函數 將函式宣告行內函數， 通常是在編譯器， 將它在呼叫點將函式“內聯展開”。 inline int len(const string& str) { return st

c++ 行內函數（一看就懂）

1.行內函數 在C++中我們通常定義以下函式來求兩個整數的最大值： int max(int a, int b) { return a > b ? a : b; } 為這麼一個小的操作定義一個函式的好處有： ① 閱讀和理解函式 max 的