1.概述

本教程是10gen支持C＃驅動程序MongoDB的介紹。假定您熟悉使用MongoDB，因此主要集中在如何使用C＃訪問MongoDB的。 它分為兩個部分：C＃ 驅動程序 ，BSON圖書館。C＃驅動程序是建立在頂部，其目的是單獨使用的C＃驅動程序的的BSON圖書館，。

在第1部分中，我們將介紹C＃驅動程序的主類：MongoServer，MongoDatabase，MongoCollection，MongoCursor，MongoGridFS，MongoGridFSFileInfo和SafeMode。

在第2部分，我們將討論的主要類的BSON Library的：BsonType，BsonValue（及其子類），BsonElement，BsonDocument和BsonArray。

第1部分：C＃驅動程序

本教程的第1部分組織自頂向下的方式，所以你有時可能提前偷看，如果事情是沒有意義。您甚至可能想要讀第2，如果你是完全陌生的的BSON概念，如文檔和元素與前第1部分。

參考文獻和命名空間

為了從你的程序中使用C＃的驅動程序，您必須添加以下兩個DLL文件：

• MongoDB.BsonLibrary.dll
• MongoDB.CSharpDriver.dll

您還應該添加以下語句到你的源文件：

using MongoDB.BsonLibrary;

using MongoDB.CSharpDriver;

 

除了 極少數例外，你將要使用的類的名稱前綴與任何“BSON”的，如果他們的BsonLibrary或“Mongo”的一部分，如果他們的C＃驅動程序的一部分 。這樣做是為了獲得名稱沖突的可能性降至最低，當您添加到你的程序的兩個使用語句。預計將方法的參數（主要是枚舉和標志）的一些類，具有較短的名稱，不使用任何前綴。

我們喜歡使用C＃的var語句聲明 的變量，因為它會導致更短，我們的感覺，更可讀的代碼。Visual Studio可以很容易地看到一個變量的類型 ，如果您需要通過將鼠標指針懸停在變量 或使用IntelliSense。然而，當閱讀本文檔，你沒有這個能力，所以在這個文件中，而不是寫：

              var server = MongoServer.Create(connectionString);

              var test = server[“test”];

              var books = test[“books”];

 

按照我們的建議，我們會來寫：

              MongoServer server = MongoServer.Create(connectionString);

              MongoDatabase test = server[“test”];

              MongoCollection<BsonDocument> books = test[“books”];

 

所以，你可以看到什么類型正在使用。

線程安全

只有少數的C＃驅動程序 類是線程安全的。其中：MongoServer的，MongoDatabase，MongoCollection MongoGridFS。通用類，你會使用很多是不是線程安全包括MongoCursor的所有類的BsonLibrary（除 BsonSymbolTable）的。A類不是線程安全的，除非特別記載是線程安全的。

所有的所有類的靜態屬性和方法是線程安全的。

MongoServer類

這個類服務 s的工作與MongoDB的根對象。這個類的一個實例的客戶端是一個MongoDB服務器，你想溝通。雖然這個類有公共的構造函數，推薦的方式來獲得這個類的一個實例是使用工廠方法。

每個實例MongoServer保持與服務器的連接池。這些連接之間共享所有的呼叫到服務器。你可能要調用構造函數，而不是直接調用創建工廠方法MongoServer的幾個原因之一是，如果你要保持一個單獨的連接池的一些操作。

這個類的實例是線程安全的。

連接字符串

最簡單的方法是使用一個連接字符串連接到MongoDB的。標準 MongoDB的連接字符串的格式是一個以下列格式的URL：

              mongodb://[username:password@]hostname[:port][/database]

 

如果您使用的是MongoDB服務器的身份驗證的用戶名和密碼，只應。這些憑據將適用于一個單一的數據庫，如果數據庫名稱是存在的，否則他們將所有的數據庫的默認憑據。要進行身份驗證對管理數據庫追加“（管理）”的用戶名的。

端口號是可選的，默認為27017。

如果數據庫名是存在的，那么這個連接字符串，也可以與創建方法MongoDatabase的使用。創建方法MongoServer忽略的數據庫名稱（如果存在）（以外的憑據，以確定是否適用于一個單一的數據庫或所有數據庫的默認憑據）。

要連接到一個副本設置指定的種子提供多個以逗號分隔的主機名列表。例如:

              mongodb://server1,server2:27017,server2:27018

 

該連接字符串指定的種子名單，由三個服務器（其中兩個是在同一臺機器上，但在不同的端口號）。

C＃驅動程序 能夠連接到副本集，即使種子名單是不完整的。它會發現在主服務器即使主只要不是種子列表中的種子列表上的至少一個次級服務器響應（響應將包含完整副本集和當前的主的名稱）。

工廠方法

最好的方式得到的一個實例MongoServer是，使用CREATE工廠方法。使用相同的連接字符串時，此方法將返回相同的實例 MongoServer，所以你不必擔心一大堆的情況下，如果你調用Create不止一次。此外，如果你只使用一個數據庫時，你可能會發現它更容易跳過調用此方法，并呼吁建立 工廠方法MongoDatabase。

要連接到MongoDB的本地，你會寫這樣的代碼：

              string connectionString = “mongodb://localhost”;

              MongoServer server = MongoServer.Create(connectionString);

 

或許......

              MongoServer server = MongoServer.Create();

 

因為連接到本地主機是默認的。

中的Create方法MongoServer忽略了數據庫名稱，如果存在的話。但是，如果省略數據庫名稱，但存在憑據，然后MongoServer 將承擔這些憑據要使用的所有數據庫，將它們存儲在MongoServer的Credentials屬性，并利用它們時GetDatabase被稱為無憑據的默認憑據。這使得它真正易于使用相同的憑證與所有的數據庫。

Create方法使用的種子列表中的服務器的身份時，如果已經有一個現有的實例MongoServer返回（而不是實際的副本集的成員，直到建立連接后，不知道是受改變）。

安全模式屬性

此屬性表示此服務器的默認安全模式。返回此服務器實例的MongoDatabase任何情況下，它會被繼承，但可以改變indepently服務器的數據庫的默認安全模式。安全模式類有進一步的描述。

GetDatabase方法

，從一個實例MongoServer你可以代表該服務器上的數據庫使用GetDatabase方法的對象的實例。要得到一個數據庫對象，你可以這樣寫：

              MongoDatabase test = server.GetDatabase（“”）;

 

或

              MongoDatabase test = server[“test”];

 

這兩種形式是完全等效的。如果您使用的認證，就必須寫略有不同的代碼，如：

              MongoCredentials credentials =

new MongoCredentials(“username”, “password”);

              MongoDatabase test = server.GetDatabase(“test”, credentials);

 

或

              MongoDatabase test = server[“test”, credentials];

 

MongoServer維護一個表的MongoDatabase實例的數據庫/憑據組合，并每次你問相同的數據庫/憑據組合，你得到相同的實例MongoDatabase，所以你無需擔心不必要的重復的實例存在。

MongoDatabase類

這個類表示一個MongoDB服務器上的數據庫。除非你正在使用的身份驗證，你通常有 您要為每個數據庫這一類 只有 一個實例。如果您正在使用的身份驗證，那么 ， 你 最終會為每個數據庫/憑據的組合，你要使用這個類的一個實例。

這個類的實例是線程安全的。

但是，如果你正在編寫一個多線程程序，并做了一系列的相關操作（這是很常見的！），你可能希望使用的RequestStart，/ RequestDone，以確保一個線程的相關操作都發生在同一連接上的服務器。

工廠方法

通常情況下你的服務器實例上調用GetDatabase獲得的MongoDatabase的實例，但 MongoDatabase也有創建工廠方法，這需要一個URL作為一個參數。但在這種情況下，數據庫的名稱是 必需的，將拋出一個異常，如果它缺少的URL。如果你選擇到使用的創建工廠方法在MongoDatabase你做不有來電的創建工廠方法在 MongoServer（雖然它會被稱為為您和的導致服務器對象是提供給您，如果需要的新的數據庫實例的服務器屬性） 。

使用創建工廠方法，你能寫的MongoDatabase要創建一個實例：

              string connectionString = “mongodb://localhost/test”;

              MongoDatabase test = MongoDatabase.Create(connectionString);

              MongoServer server = test.Server; // 如果需要的話

 

請注意，這是完全等價于下面的代碼：

              string connectionString = “mongodb://localhost/test”;

              MongoServer server = MongoServer.Create(connectionString);

              MongoDatabase test = server.GetDatabase（“”）;

 

第一種形式是有利的，如果你不直接訪問服務器對象，也因為來自URL的數據庫名稱（如果存在的憑據），并沒有硬編碼。

服務器屬性

這個屬性允許你導航回從MongoDatabase對象，的MongoServer對象，它屬于。

Credentials屬性

這個屬性允許你檢查這個的MongoDatabase實例關聯的憑據。你不能改變的憑據。如果你想用不同的憑據，你必須回到服務器對象并得到一個新的數據庫對象的新的 憑證。這通常是由許多部分的 代碼 共享因為MongoDatabase的一個實例 ，并更改憑證，可能會產生意想不到的副作用。

安全模式屬性

此屬性表示該數據庫的默認安全模式。返回該數據庫實例的MongoCollection任何情況下，它會被繼承，但可以改變一個集合的默認安全模式indepently數據庫的。安全模式類有進一步的描述。

GridFS property

此屬性使您可以訪問這個數據庫關聯的的GridFS對象的。請參閱下面的MongoGridFS類的描述。MongoGridFS類的方法，如上傳，下載，查找，讓您的GridFS文件系統進行交互。

GetCollection方法

，從一個實例MongoDatabase你可以得到代表在該數據庫使用GetCollection方法的集合對象的實例。為了得到一個集合對象，你可以這樣寫：

              MongoCollection<BsonDocument> books =

                            database.GetCollection(“books”);

 

或

              MongoCollection<BsonDocument> books = database[“books”];

 

這兩種形式是完全等效的。

MongoDatabase維護一個表，至今已經使用的集合，每一次你問的同一個集合中，你得到相同的實例，所以你就不需要擔心不必要的重復的實例存在。

GetCollection <TDefaultDocument>方法

在MongoDB中集合的特點之一是，他們是無架構。然而，它也是不尋常的一個集合 主要 持有 一種類型 的文件。我們稱此為默認文檔類型。通常情況下，默認的文件類型是BsonDocument，但你可以指定一個不同的默認文件類型的集合通過使用 GetCollection <TDefaultDocument> 方法。例如:

              MongoCollection<Employee> employees =

                            Database.GetCollection<Employee>(“employees”);

 

有沒有索引等效的，因為C＃不允許的類型參數索引。

即使一個集合有一個默認的文件類型，你可以隨時查詢任何其他類型的文件，使用查找<TQuery, TDocument>方法，而不是查找<TQuery>（查找的<TQuery>僅僅是一個方便的快捷鍵<TQuery的， TDefaultDocument>）。

C＃驅動程序的最初版本只支持與文件類型BsonDocument的（因為BSON序列化/反序列化的支持尚未實現，對于其他類型）。

DropCollection方法

此方法可以用于從數據庫中刪除一個集合。MongoCollection也有一個方法叫做removeall過下降的數據，但在葉集（及任何索引）。要使用此方法寫：

              BsonDocument result = database.DropCollection(“books”);

 

DropCollection實際上是一個數據庫命令的包裝。所有的方法來包裝一個命令返回命令的結果，這在某些情況下，可能有您感興趣的信息。

RequestStart方法/ RequestDone方法

它經常發生，一個線程執行一系列數據庫操作 有關重新 。更重要的是，線程 有時確實是依賴于早期寫的讀入。如果讀出的發生比寫要完成的一個不同的連接有時結果將尚未提供。一個線程可以表明它已被使用RequestStart一個 第二，它是一系列相關的操作由Cal 靈RequestDone 做了一系列的相關操作 。例如:

              database.RequestStart（）;

              / /數據庫的操作做了一系列的

              database.RequestDone（）;

 

這個例子其實是有一個小問題：如果拋出一個異常，而這樣做 對數據庫的操作RequestDone永遠不會被調用。要預防，你可以把到RequestDone在一個最后的塊，或更容易的調用，利用，RequestStart返回一個幫手對象實現IDisposable的實例 ， 并使用了C＃使用陳述保證，RequestDone被稱為自動。在這種情況下，你這樣寫：

              using (database.RequestStart（））{

                            / /數據庫的操作做了一系列的

              }

 

請注意，在這種情況下，你不叫RequestDone自己，這種情況發生時，會自動離開using語句的范圍。

RequestStart的增量一計數器和RequestDone的的減少，所以你可以嵌套調用到RequestStart和 RequestDone的要求實際上是不開 ，直到 再次達到零。這有助于當你執行方法，需要調用RequestStart / RequestDone的 ， 但 稱為的代碼本身RequestStart的在轉。 這方面的一個例子是上載的方法在MongoGridFS，這要求RequestStart / RequestDone的。由于RequestStart筑巢產卵的行為是完全沒有上傳代碼，已經本身稱為RequestStart的調用。

MongoCollection <TDefaultDocument>類

在MongoDB數據庫中， 這個類的實例 參閱下文的集合。你會得到一個的MongoCollection實例通過調用 GetCollection或GetCollection <TDefaultDocument>的方法MongoDatabase。 的類型參數TDefaultDocument的 是這個集合中的默認文檔類型（如果你不指定，否則這將是BsonDocument）。

這個類的實例是線程安全的。

數據庫屬性

這個屬性允許你導航回從MongoCollection對象，的MongoDatabase對象，它屬于。

安全模式屬性

此屬性表示該集合中的默認安全模式。這將是對這個集合進行操作的默認安全模式，但已有許多方法提供了一種方法來覆蓋安全模式只是一個操作。安全模式類有進一步的描述。

插入<TDocument>方法

之前，我們可以從集合中獲取任何信息，我們需要把它放在那里。Insert方法的一種方式插入到一個集合中的文件（也可以查看保存的方法和UPSERT版本的Update方法）。例如:

              BsonDocument book = new BsonDocument {

                            { “author”, “Ernest Hemingway” },

                            { “title”, “For Whom the Bell Tolls” }

              };

              books.Insert(book);

 

INSERT語句也可以寫成：

              books.Insert<BsonDocument>(book);

 

但是這是沒有必要的，因為編譯器可以推斷 從參數 類型 TDocument的。需要注意的是TDocument 必須是一個類型，可以被序列化到一個BSON文檔。C＃驅動程序 的最初版本 只知道如何序列化的BsonDocument類的實例。

當你要插入一個以上的文件，使用InsertBatch方法 。例如:

              BsonDocument[] batch = {

new BsonDocument {

                            { “author”, “Kurt Vonnegut” },

                            { “title”, “Cat’s Cradle” }

              }

              new BsonDocument {

                            { “author”, “Kurt Vonnegut” },

                            { “title”, “Slaughterhouse-Five” }

              }

};

              books.InsertBatch(batch);

 

在一次插入多個文件的優點是，它最大限度地減少了網絡傳輸。被插入的所有文件被發送到服務器在一個消息中（除非序列化的文件的總大小超過16MB，在這種情況下，它們將被在多個消息發送各保持為盡可能多的文件）。

<TQuery>方法

最常見的操作，您將執行對集合進行查詢。這樣做的find方法的幾個變化。在本教程中，我們只顯示簡單的表格S， 但也有其他形式，讓您使用JavaScript where子句而不是一個查詢對象和/或指定要返回的字段。

下面是一些示例代碼來讀取的文件，我們剛剛插入的藏書：

              BsonDocument query = new BsonDocument {

                            { “author”, “Kurt Vonnegut” }

              };

              MongoCursor<BsonDocument> cursor = books.Find(query);

              foreach (BsonDocument book in cursor) {

ConsoleWriteLine。

                                          “{0} {1}”，

book[“title”].AsString，

book[“author”].AsString

）;

              }

 

如果該文件被退回是不是默認的文件類型，然后使用一個版本的查找，可以讓你指定的文件類型：

              MongoCursor<Employee> cursor =

employees.Find<BsonDocument, Employee>(query);

 

有很多形式的查詢對象的支持，但他們不是具體 到C＃驅動程序 ，我們沒有足夠的空間來形容他們。一個空的查詢對象檢索的所有文件， 相當于一個空的查詢對象 的 C＃驅動程序允許空。

還有很多說關于MongoCursor，但有一整節以下使用游標在那里尋找更多詳細信息。

FindAll方法

這種方法僅僅是一個快捷方式FindAll擴展<TDefaultDocument> 和檢索的所有文件的集合。例如:

              MongoCursor<BsonDocument> cursor = books.FindAll();

              foreach (BsonDocument book in cursor) {

                            Console.WriteLine(

                                          “{0} {1}”，

book[“title”].AsString，

book[“author”].AsString

）;

              }

 

要查詢一個文件，是不是默認的文件類型使用FindAll擴展<TDocument>。

FindOne <TQuery>方法

如果你知道有只有一個匹配的文件或如果你只是想第一個匹配的文件，你可以使用FindOne方法。例如:

              BsonDocument query = new BsonDocument {

                            { “author”, “Kurt Vonnegut” }

              };

              BsonDocument book = books.FindOne(query);

 

FindOne返回它找到第一個匹配的文件或C＃NULL，如果 是沒有的。如果進一步 e是一個以上的匹配文檔，它沒有指定哪一個將被退回。

FindOne <TQuery>實際上是一個快捷方式：

              FindOne<TQuery, TDefaultDocument>(query);

 

這又是一個快捷方式：

              Find<TQuery, TDefaultDocument>(query).Limit(1).FirstOrDefault();

 

瓦特 HICH是有用的，要知道，如果你認為可能有多個匹配的文件和要控制哪一個是返回。FirstOrDefault方法的MongoCursor下面 的例子 。

要查詢一個文件，是不是默認的文檔類型使用FindOne <TQuery,的TDocument>。

保存<TDocument>方法

保存方法是插入和更新的組合。檢查提供的文件，如果該文件是缺乏一個“_id”的元素，它假定這是一個新的文檔和調用上的插入。如果該文件有一個 “_id”的元素，它假定這可能是現有的文件，并調用Update就可以了，但以防萬一，所以該文件將被插入，如果它不存在，將UPSERT標志。例如，您可以糾正錯誤使用的一本書的標題：

              BsonDocument query = new BsonDocument {

                            { “author”, “Kurt Vonnegut” }

                            { “title”, “Cats Craddle” }

              };

              BsonDocument book = books.FindOne(query);

              if (book != null) {

                            book[“title”] = “Cat’s Cradle”;

                            books.Save(book);

}

 

需要注意的是，我們的FindOne檢查返回值，以確認它實際上找到了一個匹配的文檔。

更新<TQuery, TUpdate>方法

更新方法用于更新現有的文件（見 下面的 UPSERT標志 ）。的代碼示例所示的保存方法也可以寫為：

              BsonDocument query = new BsonDocument {

                            { “author”, “Kurt Vonnegut” }

                            { “title”, “Cats Craddle” }

              };

              BsonDocument update = new BsonDocument {

                            { “$set”, new BsonDocument(“title”, “Cat’s Cradle”) }

              };

              BsonDocument updatedBoook = books.Update(query, update);

 

Update方法支持許多不同種類的更新文件，但再次，我們沒有足夠的空間來形容他們在本教程中。使用上面的例子中的“$集” 更新修飾符更新匹配的文件的一個元素的值。

此外，還有一個過載的更新，使您可以指定一個或多個UpdateFlags。的值是和多UPSERT。 正常情況下，更新只影響一個文件，但使用UpdateFlags。多，你可以要求所有匹配的文件被更新。此外，指定UpdateFlags。UPSERT 您可以要求的 更新文件被插入，如果無法找到符合條件的文件（注意，UPSERT功能需要更新文件是一個完整的文件，而不是在上面的示例中，只是一個更新操作）。

計算方法

有時候，你只需要知道一個集合有多少文件。 有兩個版本的指望 。2-15 方法，首先計算所有的文件，和第二計數匹配的文件。例如:

              BsonDocument query = new BsonDocument {

                            { “author”, “Ernest Hemingway” }

              };

              int total = books..Count();

              int booksByHemingway = books.Count(query);

刪除方法

可以使用此方法，從集合中刪除文件。例如，要刪除所有收集海明威的書，我們寫的：

              BsonDocument query = new BsonDocument {

                            { “author”, “Ernest Hemingway” }

              };

              books.Remove(query);

 

如果我們只是想刪除一本書 - 海明威，我們可以這樣寫：

              BsonDocument query = new BsonDocument {

                            { “author”, “Ernest Hemingway” }

              };

              books.Remove(query, RemoveFlags.Single);

 

雖然我們沒有控制過這本書完全去除，但是這將是一個由海明威。

RemoveAll方法

如果你想刪除一個集合中的所有文件，請使用：

              books.RemoveAll();

 

請謹慎使用！ RemoveAll只是一個快捷方式刪除（空）。 也參看的DropCollection在MongoDatabase方法，這種方法雖然不同從 DropCollection中，只有數據被刪除，而不是集合本身或任何索引。

的CreateIndex方法

此方法用于創建索引的集合。在其最簡單的形式中，你只需要提供一個列表的元素名稱被編入索引。還有更復雜的形式，使用一個 參數來指定要創建的索引的詳細信息，但它們超出了本文的討論范圍。

要建立索引的藏書作者，我們可以這樣寫：

              books.CreateIndex(“author”);

 

注意，MongoDB是寬容的，如果您嘗試創建一個索引已經存在，但要減少次數的服務器被要求創建相同的索引方法，而不是使用EnsureIndex。

EnsureIndex方法

您通常會調用此方法，而不是的CreateIndex。驅動跟蹤的索引， 它 創造 了 只調用一次，每個索引（索引是否存在于服務器上，所以它必須調用的CreateIndex至少一次，以確保指數存在的驅動程序不知道）的 CreateIndex。就像調用的CreateIndex調用EnsureIndex是：

              books.EnsureIndex(“author”);

 

EnsureIndex也不能判斷索引是否已被刪除，因為它是在服務器上創建。你可以，知道任何索引的EnsureIndex忘記通過調用 ResetIndexCache。被稱為接下來的時間EnsureIndex的，它會調用的CreateIndex再次后，該指數將再次在索引緩存和 createindex將不會被調用了該指數。

不同的方法

此方法用于對于一個給定的密鑰，找到所有的不同的值。例如，要查找所有作者的藏書中，你可以這樣寫：

              IEnumerable<BsonValue> authors = books.Distinct(“author”);

              foreach (string author in authors) {

                            Console.WriteLine(author.AsString）;

              }

 

也有一個過載的不同的方法，該方法的查詢，所以你可以找到不同的值，對于一個給定鍵的只是那些與查詢匹配的文件。

FindAndModify方法

文本缺失。

Group method

文本缺失。

MapReduce的方法

文本缺失。

MongoCursor <TQuery, TDocument>類

找到方法（及其變化）不返回的實際結果的發現 。相反， 他們返回一個游標，可以列舉出 檢索結果的發現。該查詢實際上并沒有發送到服務器之前，我們 首先對試圖枚舉光標，這不僅意味著，查找方法不溝通與服務器（它們只返回一個游標）時，但我們可以控制的結果，通過改變光標之前列舉的有用的方法。

在C＃中的 光標列舉 了最便捷的方式 是使用foreach語句。但是，如果必要的話，你可以調用一個游標的的GetEnumerator方法和 工作直接用枚舉。 您可以列舉許多倍，你想一個光標。每次你調用GetEnumerator（通常是間接地通過foreach語句）一個新的查詢發送到服務器。

一旦你列舉游標被凍結，并沒有進一步的變化可以向它提出的。

這個類的實例不是線程安全的。 然而，一旦光標被凍結，成為線程安全的枚舉（請記住，每一次的GetEnumerator被稱為一個單獨的查詢將被發送到服務器）。

集合屬性

您可以使用此屬性來定位光標集合查詢。

修改光標之前執行的方法

在此類別的使用方法修改之前以某種方式被列舉的光標控制游標返回的結果。請注意，所有這些方法都返回游標本身，讓他們鏈接起來（“流利接口”）。

Skip方法

這種方法控制服務器應該跳過多少文件，然后返回結果。它往往是有用的分頁，雖然是大值跳過知道，會變得非常低效的。例如，假設我們有很多由Isaac Asimov的書，想跳過第5：

              BsonDocument query = new BsonDocument {

                            { “author”, “Isaac Asimov” }

              };

              MongoCursor<BsonDocument> cursor = books.Find(query);

              foreach (BsonDocument book in cursor.Skip(5)) {

                            Console.WriteLine(book[“title”].AsString）;

              }

限制方法

限制的方法可以讓我們控制游標返回多少個文件 。此例子是類似于前一個，并告訴光標 返回至多10匹配文檔：

              BsonDocument query = new BsonDocument {

                            { “author”, “Isaac Asimov” }

              };

              MongoCursor<BsonDocument> cursor = books.Find(query);

              foreach (BsonDocument book in cursor.Limit(10)) {

                            Console.WriteLine(book[“title”].AsString）;

              }

 

強制執行該限制是客戶端，它是可能的服務器可能返回比需要更多的文件，在這種情況下，額外的將被忽略 。枚舉中的某些值的查詢發送到服務器，告訴它有多少文件發回的消息，但這些有時被視為暗示的服務器。對于小的范圍內，你可以用一個負價值，讓服務器知道在一個消息中返回所有的結果（實際限制 客戶端將是負數的絕對值）。

排序方法

通常情況下，我們希望在一個特定的順序返回結果。排序方法，讓我們來告訴 服務器 ， 什么樣的順序返回結果中。在其最簡單的形式中，我們只需提供姓名的關鍵，我們要排序的結果，如：

              MongoCursor<BsonDocument> cursor = books.FindAll();

              foreach (BsonDocument book in cursor.Sort(“author”, “title”)) {

                            Console.WriteLine。

                                          “{0}: {1}”,

book.[“author”].AsString,

book.[“title”].AsString

）;

              }

 

其他重載的排序方法讓你單獨控制每個鍵的排列順序。

其他光標修改方法

改性方法有更多的光標不會在這里描述，但他們的名字就建議他們使用AddOption，批次，字段，標志，提示，和快照。

觸發列舉的方法，

下面的方法所有觸發列舉的光標。這意味著，必須先完成，光標使用上面的方法修改，光標前的枚舉，并成為凍結。

計算方法

如果你不需要個別的結果，但只是想知道的計數匹配的文檔，你可以使用此方法。這種方法相當于調用計數的收集。請注意，這種方法忽略任何跳過“或”限價已經設置光標（但看到“大小”的方法）。

尺寸的方法

這種方法是類似的計數方法，但任何榮譽跳過或限制已設置的選項上的光標。

的GetEnumerator方法（或foreach語句）

這種方法可以用來枚舉 的結果 返回一個IEnumerator <TDocument>的 。通常你不會調用此方法，而是使用C＃foreach語句來 枚舉的結果。 請注意，實際與服務器的通信不會發生，直到 第一次的MoveNext方法被調用的枚舉，但光標并成為凍結盡快的GetEnumerator被稱為。

FirstOrDefault方法

有時，你只是想要或期望的一個結果，在這種情況下，您可以使用 此方法，這是更方便，比列舉光標。在簡單的情況下，你可能更喜歡，到使用FindOne方法MongoCollection的，但 FirstOrDefault方法上的光標在檢索一個文件，讓你提供有趣的選項上的光標。例如，假設你想找到海明威出版的第一本書：

              BsonDocument query = new BsonDocument {

                            { “author”, “Ernest Hemingway” }

              };

              MongoCursor<BsonDocument> cursor = books.Find(query);

              cursor.Sort(“publicationDate”);

              BsonDocument firstBook = cursor.FirstOrDefault();

 

因為游標的修改方法支持流暢的界面，你也可以鏈的召集中：

              BsonDocument query = new BsonDocument {

                            { “author”, “Ernest Hemingway” }

              };

              BsonDocument firstBook = books.Find(query)

                            .Sort(“publicationDate”)

                            .FirstOrDefault();

 

FirstOrDefault實際上是一個IEnumerable的擴展方法，可以用一個MongoCursor，，因為MongoCursor <TQuery, TDocument>實現IEnumerable的<TDocument>的 。正因為如此，你可以使用任何IEnumerable的擴展方法與MongoCursor。

ToArray方法

這IEnumerable的擴展方法為您列舉了光標，并返回一個數組的T.例如：

              BsonDocument query = new BsonDocument {

                            { “author”, “Ernest Hemingway” }

              };

              BsonDocument[] books = books.Find(query).ToArray();

 

如果沒有匹配的文檔的返回值將是一個空數組，而不是C＃空。

ToList方法

這IEnumerable的擴展方法為你列舉了光標，并返回 列表 <T>的。例如:

              BsonDocument query = new BsonDocument {

                            { “author”, “Ernest Hemingway” }

              };

              List<BsonDocument> books = books.Find(query).ToList（）;

 

如果沒有匹配的文檔的返回值將是一個空列表，而不是C＃空。

IEnumerable的擴展方法，觸發枚舉

由于MongoCursor <TQuery, TDocument>實現IEnumerable <TDocument> 所有的為IEnumerable <T>的定義的擴展方法可以與MongoCursor使用，以及他們的大部分觸發光標的枚舉的。以下是一些比較常見的方法的列表：

• First
• FirstOrDefault
• Last
• LastOrDefault
• Single
• SingleOrDefault
• ToArray
• Tolist

請記住，所有的擴展方法“看”的序列，當然列舉的光標。另外要指出的是，一些IEnumerable的擴展方法具有相同的名稱的方法 MongoCursor <TQuery, TDocument>，在這種情況下定義的方法，在MongoCursor <TQuery, TDocument>優先（除非你投您的光標移動到IEnumerable <TDocument>）。

安全消耗光標的

在列舉上的光標觸發一個連接從連接池獲得，并不會被釋放，直到它不再需要返回到連接池 。重要的 是 要確保枚舉器得到一個機會釋放連接，確保連接被返回到連接池 。實施的 一個MongoCursor的枚舉釋放連接，因為它可以（甚至可能的結果是在統計前完成）的連接丟失的可能性降至最低 。如果 枚舉沒有正確配置你的程序不會崩潰，但連接將不會被返回到連接池，將丟失（并且最終將被關閉，當它被垃圾回收），這將導致你的程序中打開連接數多于必要的。

如果MongoCursor枚舉消耗了所有的連接釋放回連接池（其實，你可以肯定的，它會被退回盡快答復查詢，或能獲得更多產品信息就沒有額外的結果）。

確保連接被返回到連接池在所有情況下，關鍵是要保證Dispose方法調用的GetEnumerator返回的枚舉。這是唯一真正的問題，如果你是消費手動枚舉。所有的IEnumerable的擴展方法調用Dispose的枚舉。C＃foreach語句也可以保證在調用Dispose的枚舉，因此，如果你堅持 IEnumerable的擴展方法和foreach語句，你將被罰款。

說明方法

此方法是從任何其他光標 方法 不同 ，因為它實際上并不返回查詢的結果。相反，服務器返回的信息如何查詢將被執行。這些信息可以是有用時，試圖弄清楚為什么一個查詢效果不理想。要使用此方法，你可以這樣寫：

              BsonDocument query = new BsonDocument {

                            { “author”, “Ernest Hemingway” }

              };

              MongoCursor<BsonDocument> cursor = books.Find(query);

              BsonDocument explanation = cursor.Explain();

MongoGridFS類

這個類是 C＃GridFS規范將文件存儲在MongoDB數據庫 驅動程序 實現的。使用GridFS財產MongoDatabase，你通常會得到這個類的一個實例。

這個類的實例是線程安全的。但是，如果你打算修改設置這種情況下，你應該做的，所以在多線程訪問 的一個實例。

數據庫屬性

這個屬性允許你來瀏覽，從實例MongoGridFS的數據庫，它是與。

設置屬性

此屬性使您可以訪問這種情況下的設置。您可以更改根目錄名稱GridFS集合（默認為“FS”）和DefaultChunkSize新的文件（默認為256KB）。需要注意的是缺省的塊大小只適用于新的文件。不同的塊尺寸與先前創建的任何文件將繼續使用現有的塊大小進行處理。這是不可能改變的塊大小的文件，一旦它被創建。

上傳方法

此方法上傳的文件從客戶端計算機的數據庫。它總是GridFS文件系統中創建一個新的文件，所以，如果你上傳的文件超過一次，將有多個版本的文件在數據庫中。要使用此方法寫：

              MongoGridFS gridFS = database.GridFS;

              MongoGridFSFileInfo的fileInfo = gridFS.Upload（“volcano.jpg”）;

 

上傳的返回值是剛剛上傳的文件的信息。如果你愿意，你可以忽略返回值。上傳將拋出一個異常，如果它失敗。

有其他重載上傳，讓您指定不同的本地和遠程的文件名，或者從一個流，而不是從一個文件直接上傳。

下載方式

此方法下載一個文件，從數據庫到客戶端計算機。如果該文件已存在用戶端電腦上，它會被覆蓋。要使用此方法寫：

              MongoGridFS gridFS = database.GridFS;

              gridFS.Download（“volcano.jpg”）;

 

正如前面提到的，可能有多個版本的相同的文件名在數據庫中。缺省情況下，下載下載最新的版本（如所定義的“uploadDate”的文件的元數據的元素）。你可以下載一個不同的版本，提供一個完整版本參數。一個版本號的值可以是：

1              The first version

2              The second version

n              The nth version

-1              The newest version

-2              The second newest version

-n              The nth newest version

0              Any version (not very useful unless there’s only one)

 

因此，例如，檢索最新版本的文件，你可以這樣寫：

              MongoGridFS gridFS = database.GridFS;

              gridFS.Download（“volcano.jpg”，-2）; / /第二個版本

 

其他的下載方法的重載讓你指定不同的本地和遠程的文件名，或者直接下載到一個流，而不是一個文件。

查找方法

Find方法查詢GridFS文件系統的有關文件的信息。如果有一個以上的文件匹配 ，然后 將返回所有的信息（即使在提供特定的文件名 相同的文件名 可能有多個匹配，如果已上載超過一次）。例如:

              MongoGridFS gridFS = database.GridFS;

              IEnumerable<MongoGridFSFileInfo> files =

gridFS.Find（“volcano.jpg”）;

 

如果沒有相匹配的列表將是空的（不是C＃NULL）。

FindOne方法

如果您希望只有一個匹配的文件名或愿意指定一個版本號的話，那就更方便的使用FindOne方法。例如:

              MongoGridFS gridFS = database.GridFS;

              MongoGridFSFileInfo file = gridFS.FindOne(“volcano.jpg”);

 

或獲得的第二個版本的文件信息：

              MongoGridFS gridFS = database.GridFS;

              MongoGridFSFileInfo file = gridFS.FindOne(“volcano.jpg”, 2);

 

在這兩種情況下，如果沒有匹配的文件C＃NULL被返回。

Exists方法

如果你只是想知道，如果該文件存在，但不需要任何的文件的元數據，你可以使用此方法。例如:

              MongoGridFS gridFS = database.GridFS;

              if (gridFS.Exists(“volcano.jpg”)) {

                            / /現在你知道該文件是否存在

              }

 

刪除方法

該方法將刪除從GridFS文件系統匹配的文件。如果有一個以上的文件匹配，他們都將被刪除（見下面的示例中如何刪除的文件只有一個版本）。例如:

              MongoGridFS gridFS = database.GridFS;

              gridFS.Delete（“volcano.jpg”）;

 

如果你只是想刪除的最新版本寫的東西一樣：

              MongoGridFS gridFS = database.GridFS;

              MongoGridFSFileInfo的fileInfo = gridFS.FindOne（“volcano.jpg”，-2）;

              if (fileInfo != null) {

                            gridFS.DeleteById（fileInfo.Id）; / /刪除_id

              }

MongoGridFSFileInfo class

這個類表示GridFS文件系統中存儲的文件的信息。此類設計是類似的 。NET的FileInfo類的 POSS IBLE。

ChunkSize property

使用的塊大小時，創建此文件。

GridFS property

您可以使用這個屬性來導航從MongoGridFSFileInro實例的MongoGridFS它所屬的對象。

Id property

此屬性具有價值的“_id”元素這個文件。這個值是第一次上傳文件時，分配，并保證是唯一的。 對于使用 C＃驅動程序 上載的文件， 這將是一個ObjectID，雖然有可能你會遇到不同的驅動器上載的文件的ID可能是不同類型的。

Length屬性

以字節為單位的文件的總長度。

MD5 property

該文件的MD5哈希計算在服務器上，當它被上傳。

Name屬性

遠程GridFS文件系統中的文件的文件名。

UploadDate財產

該文件已被上傳時的日期時間。這的DateTime是始終在UTC。

即將實施的方法

這個類還實現方法，返回一個流對象（流的一個子類），使您可以讀取和寫入GridFS文件相同的方式，做本地文件（一個可能的替代使用上傳/下載方法，雖然可能沒有那么快 ）。這些方法都返回一個實例的MongoGridFSStream， 流的一個子類，支持讀，寫和S 伊克。，返回一個MongoGridFSStream的一個StreamWriter（或包裹著它的）的方法是：AppendText，創建，CreateText，打開，打開讀取 ，OpenText，OpenWrite。

安全模式類

有好幾次在本教程前面我們所提到的 安全模式。有各種級別的安全模式，并且這個類被用來 表示 這些級別。將SafeMode僅適用于不已經返回的值（因此，它并不適用于查詢或命令）的操作。它適用于的方法MongoCollection：插入，刪除，保存和更新。它也適用于到一個MongoGridFS的對象作為一個整體，使所有GridFS的操作都在相同的安全模式級別。

安全模式的要點是后插入，刪除，保存或更新信息發送到服務器后面是一個GetLastError函數命令使C＃D 河可以確認操作成功。此外，當使用副本集，有SafeModes，讓我們指定我們要等待多少次重復前完成GetLastError返回。進入安全模式 的值 的標準方法 是使用靜態的類的屬性和方法，如：

              SafeMode.False

              SafeMode.True

              SafeMode.WaitForReplications(n);

 

的“n”的值包括伯，所以等待至少一個從已完成的復制，我們將使用“2”的值。

我們也提到安全模式是繼承了從服務器到數據庫收集和操作。這種繼承的時刻發生在創建相應的對象，但可以修改indepently 其后。因此，例如，如果我們 想要安全模式是在普通（默認是出于性能原因），但我們有一個集合，我們希望它被關閉，我們可以這樣寫：

              MongoServer server = MongoServer.Create(connectionString);

              server.SafeMode = SafeMode.True; // default to SafeMode.True

              MongoDatabase test = server[“test”]; // inherits SafeMode.True

MongoCollection log = test[“log”]; // inherits SafeMode.True

              log.SafeMode = SafeMode.False; // turn off SafeMode for log

              BsonDocument importantMessage = new BsonDocument {

                            / /內容的重要信息

              };

log.Insert(importantMessage, SafeMode.TRUE）; / /覆蓋安全模式

 

代碼的最后一行說明了安全模式，可以覆蓋在個人的操作水平。

第2部分：BSON圖書館

本教程的其余部分是的BSON 圖書館。此庫實現了序列化和反序列化BSON格式（我們將不包括）的數據中，還提供了一個BSON文檔（我們將 ） 在內存中的表示 。的重要類BsonType，BsonValue（及其子類），BsonElement，BsonDocument和BsonArray。

第1部分，其中有一個自上而下的結構不同，我們將在第2部分的的BSON庫底檢查后，開始對元素，文件和陣列類型和值，和工作。

BsonType枚舉

BSON中的每個值都有一個類型，這是一個BSON支持一組固定的類型。以下列舉列出了所有BSON支持的數據類型：

    public enum BsonType {

        Double = 0x01,

        String = 0x02,

        Document = 0x03,

        Array = 0x04,

        Binary = 0x05,

        ObjectId = 0x07,

        Boolean = 0x08,

        DateTime = 0x09,

        Null = 0x0a,

        RegularExpression = 0x0b,

        JavaScript = 0x0d,

        Symbol = 0x0e,

        JavaScriptWithScope = 0x0f,

        Int32 = 0x10,

        Timestamp = 0x11,

        Int64 = 0x12,

        MinKey = 0xff,

        MaxKey = 0x7f

}

 

我們將研究這些類型的更多細節，我們討論BsonValues。

BsonValue類

這是一個抽象類，它代表一個類型的BSON值的概念。有一個子類BsonValue的每一個 值 在 BsonType枚舉。BsonValue定義一些屬性和方法是共同所有 BSON類型（或在某些情況下，將其轉換從BsonValue到一些它的子類或。NET類型）。

，因為BsonValue是一個抽象類，不能構造這個類的實例，你只能構建其具體子類的實例。另一方面，你經常會看到這種類型的變量，參數和返回值。

創建BsonValues

有幾種方法來創建實例BsonValues（所有）：

1.       使用靜態創建方法BsonValue

2. 使用的一個的BsonValue子類的靜態Create方法

3利用隱式轉換。NET類型的BsonValue

4：的BsonValue子類調用公共的構造函數（如果有的話）

所有的BsonValue子類有一個靜態的創建方法。我們鼓勵您使用的靜態Create方法，使子類可以處理特殊情況的要求（通常返回常用值預先創建的對象的一個實例，以避免造成不必要的對象）。在某些情況下，有沒有公共的構造函數，你必須使用靜態創建方法。

BsonType財產

這個屬性可以用來確定實際的的 BsonValue 類型 。當然，你可以使用實際的類的對象做同樣的事情，但它往往是更方便，速度更快，使用此屬性。下面的例子顯示了 幾種方法：

              BsonValue value;

              if (value.BsonType == BsonType.INT32）

                            / /我們知道的值是一個實例BsonInt32

              }

              if (value is BsonInt32) {

                            / /另一種方式告訴該值是一個BsonInt32

              }

              if (value.IsInt32) {

                            / /最簡單的方法，告訴該值是一個BsonInt32

              }

 

另請參閱[類型]最便捷的方式來測試，如果值是一個特定類型的屬性。

[類型]屬性

BsonValue定義一些屬性，可用于沮喪的一個BsonValue一個具體的類型。的結果[類型]屬性的一個子類的BsonValue或在適當的時候。NET的原始值。作為[類型]屬性的完整列表是：

              AsBoolean (bool)

              AsBsonArray

              AsBsonBinaryData

              AsBsonDocument

              AsBsonJavaScript / /也可以，如果BsonType == JavaScriptWithScope

              AsBsonJavaScriptWithScope

              AsBsonMaxKey

              AsBsonMinKey

              AsBsonNull

              AsBsonRegularExpression

              AsBsonSymbol

              AsBsonTimestamp

              AsByteArray

              AsDateTime (DateTime)

              AsDouble (double)

              AsGuid (Guid)

              AsInt32 (int)

              AsInt64 (long)

              AsObjectId

              AsString (string)

 

的回報。NET基本類型的屬性后，他們在上面的列表中，括號中的一個。NET類型的。

所有這些屬性拋出一個InvalidCastException，如果實際類型的BsonValue是不是必需的。如果你不確定類型 的BsonValue，你可以事先測試使用的是[類型]屬性如下所述。

AsBsonJavaScript是一個特殊的情況下，即使成功，因為它的實際類型的價值是BsonJavaScriptWithScope的，因為BsonJavaScriptWithScope是一個子類，BsonJavaScript。

[類型]屬性，它可以將某些類型之間的更為有限。

[類型]屬性

BsonValue定義一些屬性，可以用來查詢特定類型的一個實例BsonValue。這些便利，讓你寫的更緊湊的代碼。例如:

              if (value.IsString) {

                            / /我們知道的值是一個實例BsonString

                            / /我們也知道價值。AsString不會失敗

              }

 

的完整列表[類型]屬性是：

              IsBoolean

IsBsonArray

              IsBsonBinaryData

              IsBsonDocument

              IsBsonJavaScript

              IsBsonJavaScriptWithCode

              IsBsonMaxKey

              IsBsonMinKey

              IsBsonNull

IsBsonRegularExpression

              IsBsonSymbol

IsBsonTimestamp

IsDateTime

IsDouble

IsGuid

IsInt32

IsInt64

              IsObjectId

              ISSTRING

[類型]的方法

BsonValue提供了一些方法 ，可以進行有限的類型之間的轉換。這些轉換的，在大多數情況下是安全的，被預期不會失敗。在[類型]的 方法是：

              ToBoolean

              ToDouble

              ToInt32

              ToInt64

 

ToBoolean方法 永遠不會失敗。它使用JavaScript定義2006：。2006年：內感真相，假，0，0.0，南，BsonNull和“是假的，一切是”真“（包括字符串”假“！）。

ToBoolean方法 是非常有用的，當你正在處理的文件有不一致的方式記錄true / false值。例如:

              if (employee[“ismanager”].ToBoolean（））{

                            / /我們知道員工是經理

                            / /即使價值有時是正確的，有時1

              }

 

將工作，即使混合使用的文件類型 代表true / false值。相比之下，AsBoolean的屬性將只 當值被記錄下來使用嚴格BsonBoolean值。

ToDouble，ToInt32犯法，ToInt64方法將失敗，如果轉換之間的數值類型（雖然可能會被截斷值！）。如果轉換的一些目標類型，如果該字符串可以被解析為一個字符串，他們會取得成功 ，否則，拋出一個異常。

創建方法

雖然你不能創建實例BsonValue，在BsonValue類有一個 靜態方法調用創建，你可以用它來 創建具體的實例BsonValue。在運行時的基礎上提供的值的實際類型 決定所產生的BsonValue。A N 異常被拋出，如果提供的價值不能被映射到一個BsonValue。例如:

              BsonValue value = BsonValue.Create(1); // creates a BsonInt32

              BsonValue value = BsonValue.Create(1.0); // creates a BsonDouble

              BsonValue value = BsonValue.Create(“abc”); // a BsonString

 

如果你想選擇的BsonValue類型，使用的子類BsonValue，而不是一個靜態的創建方法：

              BsonDouble value = BsonDouble.Create(1);

              BsonJavaScript value = BsonJavaScript.Create(“this.a == 4”);

              BsonSymbol value = BsonSymbol.Create(“+”);

 

在第一種情況將創建一個BsonDouble，和int值將被轉換為雙精度值1.0。在第二個例子將創建一個BsonJavaScript，編碼值將是“this.a == 4”。在第三種情況下將創建一個BsonSymbol的“+”定定地看著在BsonSymbolTable的。 如果提供的值不能轉換為需要的類型的BsonValue子類拋出一個異常。

。NET類型的隱式轉換BsonValue

BsonValue類還定義了一些隱式轉換BsonValue的。這使得它非常容易地創建BsonValues。下面是一些例子：

              BsonValue value = 1; // converts 1 to a BsonInt32

              BsonValue value = 1.0; // converts 1.0 to a BsonDouble

              BsonValue value = “abc”; // converts “abc” to a BsonString

 

這些隱式轉換是特別方便。NET值作為參數調用函數時，采取BsonValue的一個參數，允許你使用原始 。這些隱式轉換的一個重要優勢是映射。NET類型的 匹配 BsonType，發生在編譯的時候，這樣的創作是非常快的BsonValues。也有非常小的開銷的事實是，我們 正在創建一個實例BsonValue，因為如果我們不使用BsonValue和使用的對象，而不是 所有的原始。NET值將不得不盒裝的。從本質上講，BsonValue就是我們的方式拳。NET類型（但我們的方法，我們得到，以標記值與 BsonType的和我們得到了很多有用的屬性和方法定義）。

下列隱式轉換定義如下：

NET類型。	BsonType
bool	Boolean
byte[]	Binary (subtype Binary)
DateTime	DateTime
double	Double
GUID	Binary (subtype Uuid)
int	Int32
long	Int64
Regex	RegularExpression
string（字符串）	String

 

隱式轉換的列表是相當短的目的。我們只定義了隱式轉換的情況下，有一個完全匹配的。NET類型和相應的BsonType，其中有可以不丟失信息的轉換。

從BsonValue。NET類型的顯式轉換

作為一種替代[類型]屬性BsonValue類也定義了一組明確一些。NET原始類型的轉換。例如，下面的兩個語句是等價的：

              int age = person[“age”].AsInt32;

int age = (int) person[“age”];

 

所提供的顯式轉換的一組是完全相反的組提供的隱式轉換，所以在上一節的表可以讀取由右至左，以尋找可用的顯式轉換。

你可以使用任何你喜歡的，但 由于[類型]的方法往往更具可讀性。考慮這些：

              string zip = person[“address”].AsBsonDocument[“zip”].AsString;

              string zip = (string) ((BsonDocument) person[“address”])[“zip”];

 

在第二種形式中，你學會更好地得到所有這些括號恰到好處！

Equals和GetHashCode方法 （和運算符==和！=）

的BsonValue類的所有重載equals和GetHashCode的因此，BsonValue的情況下，安全使用字典中的鍵。

BsonValue子類

前面我們提到過，有一個子類BsonValue每BsonType。下面是的完整列表BsonValue子類：

              BsonArray

              BsonBinaryData

              BsonBoolean

              BsonDateTime

              BsonDocument

              BsonDouble

              BsonInt32

              BsonInt64

              BsonJavaScript

              BsonJavaScriptWithScope

              BsonMaxKey

              BsonMinKey

              BsonObjectId

              BsonRegularExpression

              BsonString

              BsonSymbol

              BsonTimestamp

 

我們將討論這些子類的簡單地說，離開BsonDocument BsonArray的結束，因為他們是最復雜的。

BsonBinaryData類

這個類持有BSON類型 的二進制 值 。它具有 以下的屬性和方法（除了繼承自BsonValue）：

              BsonBinaryData(byte[] bytes)

              BsonBinaryData(byte[] bytes, BsonBinarySubType subType)

              BsonBinaryData（GUID GUID）

              byte[] Bytes

              BsonBinarySubType SubType

              implicit conversion from byte[]

              implicit conversion from Guid

              static BsonBinaryData Create(byte[] bytes)

              static BsonBinaryData Create(byte[] bytes,

                            BsonBinarySubType subType)

              static BsonBinaryData Create(Guid guid)

              static BsonBinaryData Create(object value)

              Guid ToGuid()

BsonBoolean類

這個類包含的BSON類型 布爾 值 。它 具有以下的屬性和方法（除了繼承自BsonValue）：

              BsonBoolean(bool value)

              static BsonBoolean False

              static BsonBoolean True

              object RawValue

              bool Value

              implicit conversion from bool

              static BsonBoolean Create(bool value)

              static BsonBoolean Create(object value)

 

這個類有一些預先創建的實例（FALSE，TRUE）。您可以使用他們自己，和Create方法返回他們在適當的時候。

BsonDateTime類

這個類持有BSON DateTime類型的值。它 具有以下的屬性和方法（除了繼承自BsonValue）：

              BsonDateTime(DateTime value)

              object RawValue

              DateTime Value

              implicit conversion from DateTime

              static BsonDateTime Create(DateTime value)

              static BsonDateTime Create(object value)

 

需要注意的是BSON DateTime值始終在UTC。

BsonDouble類

這個類持有BSON類型雙值。它 具有以下的屬性和方法（除了繼承自BsonValue）：

              BsonDouble(double value)

              object RawValue

              double Value

              implicit conversion from double

              static BsonDouble Create(double value)

              static BsonDouble Create(object value)

BsonInt32類

這個類持有BSON Int32類型的值。它 具有以下的屬性和方法（除了繼承自BsonValue）：

              BsonInt32(int value)

              static BsonInt32 MinusOne

              static BsonInt32 Zero

              static BsonInt32 One

              static BsonInt32 Two

              static BsonInt32 Three

              object RawValue

              int Value

              implicit conversion from int

              static BsonInt32 Create(int value)

              static BsonInt32 Create(object value)

 

這個類有一些預先創建的實例（MinusOne，零，一，二，三）。靜態創建方法將返回他們在適當的時候。

BsonInt64類

此類包含BSON類型的Int64值。它 具有以下的屬性和方法（除了繼承自BsonValue）：

              BsonInt64(long value)

              object RawValue

              long Value

              implicit conversion from long

              static BsonInt64 Create(long value)

              static BsonInt64 Create(object value)

BsonJavaScript類

這個類擁有的BSON JavaScript類型的值。它 具有以下的屬性和方法（除了繼承自BsonValue）：

              BsonJavaScript(string code)

              object RawValue

              string Code

              implicit conversion from string

              static BsonBinaryData Create(object value)

              static BsonJavaScript Create(string code)

BsonJavaScriptWithScope類

這個類包含值BSON類型JavaScriptScope的。它 具有以下的屬性和方法（除了繼承自BsonValue）：

              BsonJavaScriptWithScope(string code, BsonDocument scope)

              string Code // inherited from BsonJavaScript

              BsonDocument Scope

              static BsonJavaScriptWithScope Create(object value)

              static BsonJavaScriptWithScope Create(string code,

                            BsonDocument scope)

 

請注意，BsonJavaScriptWithScope是一個子類的BsonJavaScript。

BsonMaxKey類

這個類持有單一值BSON類型MaxKey的。它 具有以下的屬性和方法（除了繼承自BsonValue）：

              static BsonMaxKey Singleton // can use Bson.MaxKey instead

 

請注意，這個類實現獨立的，并因此它只有一個實例存在。您可以在你的代碼中訪問此單一值在兩個方面：

              BsonMaxKey mk = BsonMaxKey.Singleton;

              BsonMaxKey mk = Bson.MaxKey / /更方便

BsonMinKey類

這個類持有單一值BSON類型MinKey的。它 具有以下的屬性和方法（除了繼承自BsonValue）：

              static BsonMinKey Singleton // can use Bson.MinKey instead

 

請注意，這個類實現獨立的，并因此它只有一個實例存在。您可以在你的代碼中訪問此單一值在兩個方面：

              BsonMinKey mk = BsonMinKey.Singleton;

              BsonMinKey mk = Bson.MinKey / /更方便

 

BsonNull類

這個類包含的單身BSON類型的空值。它 具有以下的屬性和方法（除了繼承自BsonValue）：

              static BsonNull Singleton // can use Bson.Null instead

 

請注意，這個類實現獨立的，并因此它只有一個實例存在。您可以在你的代碼中訪問此單一值在兩個方面：

              BsonNull n = BsonNull. // Singleton

              BsonNull n = Bson.NULL; / /更方便

 

注意，也有BsonElement永遠不會有一個C＃NULL作為它的值，取而代之的是BsonNull單身是用來表示的BSON空值。

BsonObjectId類

這個類包含的值BSON類型的ObjectId的 。它 具有以下的屬性和方法（除了繼承自BsonValue）：

              BsonObjectId(byte[] bytes) // must be exactly 12 bytes

              BsonObjectId(int timestamp, long machinePidIncrement)

              BsonObjectId(ObjectId value)

              BsonObjectId(string value)

              int Timestamp // first 4 bytes of ObjectId

              long MachinePidIncrement // last 8 bytes of ObjectId

              int Machine

              int Pid

              int Increment

              object RawValue

              ObjectId Value

              DateTime CreationTime // derived from Timestamp

              implicit conversion from ObjectId

              static BsonObjectId Create(byte[] bytes)

              static BsonObjectId Create(int timestamp,

long machinePidIncrement)

              static BsonObjectId Create(object value)

              static BsonObjectId Create(ObjectId value)

              static BsonObjectId Create(string value)

              static BsonObjectId GenerateNewId()

              static BsonObjectId Parse(string value)

              static bool TryParse(string value, out BsonObjectId objectId)

              byte[] ToByteArray()

 

的ObjectId結構在下一節。之間的差異BsonObjectId和OBJECTID是BsonObjectId是一個子類，BsonValue可以的BsonElement的價值，而objectid是一個結構和包含的實際 物理表示一個ObjectID（這樣的Value屬性的BsonObjectId類型的ObjectId）。 的ObjectID的屬性回蕩在BsonObjectId，只需調用底層的ObjectId屬性。

OBJECTID STRUCT

這個結構持有一個 ObjectID的物理表示 。它具有以下 的屬性和方法：

              ObjectId(byte[] bytes) // must be exactly 12 bytes

              ObjectId(int timestamp, long machinePidIncrement)

              ObjectId(string value)

              int Timestamp // first 4 bytes of ObjectId

              long MachinePidIncrement // last 8 bytes of ObjectId

              int Machine

              int Pid

              int Increment

              DateTime CreationTime // derived from Timestamp

              static ObjectId GenerateNewId()

              static ObjectId Parse(string value)

              static bool TryParse(string value, out ObjectId objectId)

              byte[] ToByteArray()

BsonRegularExpression類

此類包含BSON類型正則表達式的值。它 具有以下的屬性和方法（除了繼承自BsonValue）：

              BsonRegularExpression(string pattern) // options == “”

              BsonRegularExpression(string pattern, string options)

              BsonRegularExpression(Regex regex)

              string Pattern

              string Options

              implicit conversion from Regex

              implicit conversion from string

              static BsonRegularExpression Create(object value)

              static BsonRegularExpression Create(string pattern)

              static BsonRegularExpression Create(string pattern,

string options)

              static BsonRegularExpression Create(Regex regex)

              Regex ToRegex()

BsonString類

這個類持有BSON String類型的值。它 具有以下的屬性和方法（除了繼承自BsonValue）：

              BsonString (string value)

              static BsonString Empty

              object RawValue

              string Value

              implicit conversion from string

              static BsonString Create(object value)

              static BsonString Create(string value)

 

這個類有一個預先創建的實例（空）。您可以使用它自己的Create方法返回在適當的時候。

BsonSymbol類

這個類持有BSON類型符號的值。它 具有以下的屬性和方法（除了繼承自BsonValue）：

              string Name

              implicit conversion from string

              static BsonSymbol Create(object value)

              static BsonSymbol Create(string name)

 

這個類沒有一個公共的構造函數，因為BsonSymbols保證是唯一的，因此你必須使用靜態Create方法，而不是（它看起來的BsonSymbol的BsonSymbolTable和創建一個新的的實例BsonSymbol僅在必要時）。

BsonTimestamp類

這個類持有的BSON Timestamp類型的值。它 具有以下的屬性和方法（除了繼承自BsonValue）：

              BsonTimestamp(int timestamp, int increment)

BsonTimestamp(long value)

              object RawValue

              long Value

              int Timestamp // high order 32 bits of Value

              int Increment // low order 32 bits of Value

              implicit conversion from long

              static BsonTimestamp Create(int timestamp, int increment)

              static BsonTimestamp Create(long value)

              static BsonTimestamp Create(object value)

BsonElement類

這個類表示的BSON元素 的名稱/值對的 實例 。它是什么BsonDocuments包含（不像BsonArrays，其中包含BsonValues）。這是一個非常簡單的類，包含以下方法和屬性：

              BsonElement(string name, BsonValue value)

              string Name

              BsonValue Value

              static BsonElement Create(string name, BsonValue value)

              static BsonElement Create(bool condition, string name,

                            BsonValue值）

             

你可能不會有明確地建立BsonElement，很多時候，他們就越有可能將創建自動為您調用的Add方法BsonDocument之一當你。

靜態創建方法的返回值是C＃空C＃空（或者，如果條件為假）。

需要注意的是BsonElement實現Equals和GetHashCode，所以BsonElements的，可以作為字典鍵。

BsonDocument類

這個類是C＃驅動程序的主力 。您將使用了很多！因為它是用來這么多的接口是有點復雜的，以提供許多常見的用例。基本上有三種方式創建和填充BsonDocument的：

1.       創建一個新的文件，并調用添加和設置方法

2. 創建一個新的文件，并使用C＃集合初始化器的語法

3創建一個新的文件，并使用流暢的界面風格，支持添加和設置

首先是簡單，易于使用，但第二，要求您要熟悉與集合初始化器的語法，更具有可讀性和推薦的方法是創建BsonDocuments。

BsonDocument構造函數

您可以使用BsonDocument的構造函數來創建一個空的BsonDocument或作為一個簡單 的方法來創建一個單一的元素BsonDocument。所有重載BsonDocument（有兩個例外），只是簡單的調用提供的參數匹配的Add方法。

，要創建一個空BsonDocument的寫：

              BsonDocument document = new BsonDocument();

 

要創建一個文檔填充一個元素寫：

              BsonDocument query = new BsonDocument(“author”, “Hemmingway”);

 

默認情況下，BsonDocument不重復的元素名稱，如果您嘗試添加一個元素與現有名稱拋出一個異常。如果你想允許重復的元素的名稱，您必須使用下面的構造函數：

              BsonDocument document = new BsonDocument(true); // allow dups

              document.Add(“hobby”, “hiking”);

              document.Add(“hobby”, “cycling”); // only acessible via index

              BsonValue h1 = document[“hobby”]; // returns “hiking”

              BsonValue h2 = document[0]; // also returns “hiking”

              BsonValue h3 = document[1]; // returns “cycling”

 

也有過載的BsonDocument的構造函數，它接受一個：

• BsonElement
• IDictionary<string, object>
• IEnumerable<BsonElement>
• params BsonElement[]

請參閱相應的Add方法的說明，每一個。

BsonDocument構造函數與集合初始化器的語法

這是首選的方式來創建和填充BsonDocuments，（除單元素文件的 名稱和值 傳遞 給構造函數 更容易地創建 ）。C＃集合初始化器語法的工作方式是，它可以讓你提供的值的列表（可以是元組），被 傳遞到一個匹配的Add方法 。簡單的編譯器將調用 匹配 的 Add方法 。許多中創建示例代碼，您見過這么遠的BsonDocuments使用此語法。例如:

              BsonDocument book = new BsonDocument {

                            { “author”, “Ernest Hemingway” },

                            { “title”, “For Whom the Bell Tolls” }

              };

 

由編譯器被轉換為以下：

              BsonDocument book = new BsonDocument();

              book.Add(“author”, “Ernest Hemingway”);

              book.Add(“title”, “For Whom the Bell Tolls”);

 

這兩者是完全等效的，但首先是更加優雅和可讀性，因為它反映了結構的BsonDocument正在創建更加簡潔。

使用集合初始化器的語法時，一個常見的錯誤是忘記了一個括號套。這不起作用的原因是明顯的，當我們看到，編譯器將其轉換：

              BsonDocument wrong = new BsonDocument { “name”, “value” };

 

到：

              BsonDocument wrong = new BsonDocument();

錯誤。添加NAME

錯誤。擴大廣告價值。

 

編譯時錯誤，因為沒有相匹配的簽名（幸好）的Add方法。

BsonDocument構造函數用流利的接口方法

到構建一個BsonDocument的另一種方式是使用流暢的界面風格Add方法來填充文件。例如:

              BsonDocument book = new BsonDocument()

                            .Add(“author”, “Ernest Hemingway”)

                            .Add(“title”, “For Whom the Bell Tolls”);

 

我們并不網友的這種風格，因為我們覺得C＃集合初始化器的語法是優越的，但如果你從另一個驅動程序的移植代碼，你會發現這種風格有用的。

AllowDuplicateNames財產

確定該文件是否被允許包含重復的名稱或。BSON標準規定，重復的名字是不允許的，但在某些情況下，它可能是有用的（例如，當一個XML文檔映射到BsonDocument）。

Count屬性

此屬性返回該文件包含的元素的數量。

元素屬性

此屬性返回一個可用于列舉了文檔的元素的IEnumerable的<BsonElement>值。您也可以枚舉元素在一個 BsonDocument的直接（不使用元素屬性）因為 BsonDocument 實現了IEnumerable <BsonElement>。的名字也，價值觀和RawValues的性能。

名稱屬性

此屬性返回的IEnumerable的<String>的值，可以用來列舉了文檔的元素的名稱。

RawValues財產

該屬性返回一個的IEnumerable的<OBJECT>值，可以用來列舉了為原料的對象（而不是所有BsonValues的原始值，布爾，日期時間，雙，INT32，的Int64，String和時間戳的文件的元素的值這樣做）。返回的序列包含C＃空為任何BsonValue的 s的類型，沒有RawValue。

Values屬性

此屬性返回一個枚舉的值的的文件，BsonValues的元素，可用于的IEnumerable的<BsonValue>值。

添加方法

有很多重載的Add方法。請注意，在所有情況下，C＃空值將被忽略，所以你就不必把if語句添加在你的電話，以檢查是否你的價值是空的（假設你希望它被忽略）。當 一個Add方法傳遞一個C＃空值，它根本什么都不做。

添加（BsonElement）方法

這是基本的Add方法。所有其他的Add方法調用這一個。此方法的行為略有不同，具體取決于是否允許重復的元素名稱或沒有。如果重復的名字是不允許的元素具有相同的名稱存在，則拋出一個異常，否則它被添加到集合末尾，并且只能通過索引訪問（訪問將返回現有的元素，而不是新的名字1）。

添加方法（IEnumerable的<BsonElement>）

這個方法只是簡單地調用的添加（BsonElement）的每個元素傳遞的。

添加（名稱，值）的方法

此方法創建和一個BsonElement添加到文檔中，如果提供的值是C＃空 。例如:

              BsonDocument book = new BsonDocument();

              book.Add(“author”, “Ernest Hemingway”);

 

由于這Add方法將其參數直接通過的BsonElement構造，你可以參考下面的討論中有關創建BsonElements的和。NET提供的價值映射到一個BsonValue的。

重要的是要記住，Add方法不執行任何操作，如果該值suplied是一個C＃空。如果你想一個BSON的NULL被存儲為一個缺失值，您必須提供的BSON空值自己。一個方便的方式做到這一點是使用C＃的空合并運算符：

              BsonDocument book = new BsonDocument {

                            { “author”, author ?? Bson.Null }

              };

添加方法（條件，名稱，值）

此方法創建并添加了一個新的BsonElement的文件，如果條件為真時提供的值是C＃空 。這種方法的存在是為了支持有條件地將元素添加到文檔時，使用C＃集合初始化器的語法。例如:

              BsonDocument book = new BsonDocument {

                            { “author”, “Ernest Hemingway” },

                            { “title”, “For Whom the Bell Tolls” },

                            {havePublicationDate，“publicationDate”，publicationDate}

              };

 

這是唯一真正必要的結構值（因為它們不能被C＃NULL）。例如，假設您只是想添加的“字幕”元素，如果它不是C＃空。我們可以簡單的寫：

              BsonDocument book = new BsonDocument {

                            { “author”, “Ernest Hemingway” },

                            { “title”, “For Whom the Bell Tolls” },

                            { “subtitle”, subTitle }

              };

             

如果該值的副標題是C＃空“字幕”元素將被添加到文檔中。

添加方法（IEnumerable的<BsonElement>）

每一個元素將被添加這BsonDocument。需要注意的是不被復制的元素。

由于BsonDocument實現了IEnumerable <BsonElement>，你可以傳遞一個的實例BsonDocument這種方法。然而，由于該元素不被克隆，相同的 BsonElements是在兩個BsonDocuments的。這意味著，如果你改變了價值的BsonElement在一個文檔中，它會改變其他。如果你不希望這種行為，那么你之前，必須復制的元素添加到 文檔中。例如:

              BsonDocument order = new BsonDocument();

              BsonDocument items; // passed in from somewhere

              order.Add(items); // 元素現在在這兩份文件

 

或者，如果你不想共享的元素，這兩個文件之間使用之一：

              order.Add((BsonDocument) items.Clone

              order.Add((BsonDocument) items.DeepClone（））;

 

這取決于你是否需要淺或深的克隆。

默認的行為是不能克隆，因為克隆是昂貴的，這樣一來，我們默認情況下，最有效的行為，你會得到來決定何時克隆的成本是必要的。

（IDictionary的<string,的對象）的方法

這種方法增加了新的元素到基于一個BsonDocument的一本字典的內容。在字典中的每個鍵成為新元素的名稱，以及每個對應的值成為新的元件的值。與往常一樣，這個方法調用每個新元素的添加（BsonElement）的處理，所以重復的名稱所描述的添加（BsonElement）。

清除方法

該方法將刪除所有文檔中的元素。

Contains方法

這種方法測試該文件是否包含給定名稱的元素。

ContainsValue方法

此方法測試該文件是否包含與給定的值的元素。

GetElement方法

通常情況下，你會使用GetValue，或更常見相應的索引。在極少數情況下，您可能需要得到BsonElements自己使用的兩種重載GetElement（如果指數，如果按名稱）。

GetValue方法和索引

GetValue方法主要有三種形式：第一個數字索引，第二個需要的元素的名稱，和第三也需要 一個默認值被返回，如果不存在該名稱的元素。在所有情況下返回值類型BsonValue，。還設有一個匹配索引器每個GetValue方法。例如:

              BsonDocument book = books.FindOne（）;

              string author = book.GetValue(“author”).AsString;

              DateTime publicationDate =

book.GetValue(“publicationDate”).AsDateTime;

              int pages = book.GetValue(“pages”).AsInt32;

              int pages = book.GetValue(“pages”, -1).AsInt32; / /默認-1

 

或使用的索引，這是推薦的方法：

              BsonDocument book = books.FindOne（）;

              string author = book[“author”].AsString;

              DateTime publicationDate = book[“publicationDate”].AsDateTime;

              int pages = book[“pages”].AsInt32;

              int pages = book[“pages”, -1].AsInt32; / /默認-1

 

由于BsonValue還支持顯式轉換到對應的。NET類型，這個例子也可以寫成：

              BsonDocument book = books.FindOne（）;

              string author = (string) book[“author”];

              DateTime publicationDate = (DateTime) book[“publicationDate”];

              int pages = (int) book[“pages”];

              int pages = (int) book[“pages”, -1]; // default -1

 

使用 這些方法， 你是一個個人選擇的問題。我們建議第二種 方法（使用索引和[類型]屬性），因為我們認為它是最可讀的（不需要額外的括號有時需要的類型轉換（可以是特別混亂時，他們被嵌套（它們經常是）））。比較下面的兩個語句：

              / /每人是一個BsonDocument的了

              BsonDocument firstBorn =

person[“children”].AsBsonArray [0]。AsDocument;

BsonDocument firstBorn =

(BsonDocument) ((BsonArray) person[“children”])[0];

 

第一 是有點更容易讀取從左到右。相同的事件序列是在這兩種情況下發生：

1.       被檢索的個人文檔的“孩子們”的元素（BsonValue）

2. 該BsonValue轉換為一個BsonArray

3被檢索的孩子數組的第一個元素（BsonValue）

4：BsonValue轉換為一個BsonDocument的

有一個名字參數獲取方法拋出一個異常，如果沒有找到具有該名稱的元素，并沒有提供默認值 。請參閱TryGetValue方法，如果你不想要一個例外。

Merge方法

這種方法允許你合并元素從一個BsonDocument到另一個。從源文檔的每個元件進行測試，以查看是否具有該名稱的目標文檔已經有一個元素。如果該名稱已經存在，該元素將被跳過，如果不是，它被添加到目標文檔。

刪除方法

此方法用于刪除一個元素從BsonDocument。如果允許重復的文件名，然后調用刪除將刪除與該名稱的所有元素。

RemoveAt方法

此方法用于刪除一個元素從一個BsonDocument使用它的索引位置。

設置方法（指數值）

雖然大多數的時候，你會訪問元素的名稱，偶爾會訪問他們的指數。使用此方法時，該文件必須已經有一個元素在該指數或將拋出一個異常。有一個等價的索引。例如:

              book.Set(0, “Ernest Hemingway”); // assume element 0 is author

              book[0] = “Ernest Hemingway”; // shorter and better

SET（名稱，值）的方法

如果這個名字的元素存在，它的值將被替換為新的值，否則這個名字和值的一個新的元素。例如:

              BsonDocument book = new BsonDocument();

              book.Set(“author”, “Ernest Hemway”); // adds element

              / /一些其他的工作

              / /注意，作者姓名拼寫錯誤

書的聲音Set(“author”, “Ernest Hemingway”); // replaces value

 

使用的索引器，前面的例子可以寫成：

              BsonDocument book = new BsonDocument();

              book[“author”] = “Ernest Hemway”; // adds element

              / /一些其他的工作

              / /注意，作者姓名拼寫錯誤

              book[“author”] = “Ernest Hemingway”; // replaces value

ToBson方法

此方法將BSON格式的二進制序列化的BsonDocument作為一個字節數組，并返回序列化的文件。

toJSON方法

此方法將序列化的BsonDocument的的一個JSON格式的字符串。這是可能的，有一定的控制生成的JSON表示提供一些BsonJsonWriterSettings的。

ToString方法

這種方法是覆蓋調用的ToJSON使用默認設置。它主要用于調試。如果您有意創建JSON調用的ToJSON。

TryGetElement和TryGetValue方法

如果你不知道該文件所包含的元素與給定的名稱，你可以第一個測試使用Contains方法或使用的TryGetElement或TryGetValue方法。例如:

              BsonValue age;

              if (person.TryGetValue(“age”, out age)) {

                            / /做一些事情隨著年齡的增長

              } else {

                            / /處理丟失的年齡情況

              }

BsonArray類

這個類是用來代表BSON陣列。需要注意的是，而BSON陣列外部表示作為一個的BSON文檔中（用一個特殊的命名約定的元素），C＃ 驅動程序 的BsonArray類是沒有關系的的BsonDocument類。這是因為一個BsonArray作為BsonDocument外部表示的事實是偶然的，實際行為一個BsonArray是非常從一個BsonDocument不同。

BsonArray構造函數

您可以使用不帶參數的構造函數創建一個空的數組，并同時將項目添加到數組，你可以使用C＃的集合初始化器的語法：

              BsonArray a1 = new BsonArray(); // empty

              BsonArray a2 = new BsonArray { 1 }; // 1 element

              BsonArray a3 = new BsonArray { 1, 2, 3 }; // 3 elements

 

還有一個構造函數的的IEnumerable的<BsonValue>參數（它調用 匹配 的 AddRange方法）。例如:

              IEnumerable<BsonValue> values; // from somewhere

              BsonArray a = new BsonArray(values); // adds values to array

 

許多額外超載（IEnumerable的<int>的像）提供支持常見的情況，如：

              int[] values = new int[] { 1, 2, 3 };

              BsonArray a = new BsonArray(values);

 

這個例子將不能正確編譯的，因為IEnumerable <int>的不能自動轉換到IEnumerable <BsonValue>的IEnumerable的<int>的過載。 IEnumerable的重載為布爾型，日期時間型，雙，整型，長，對象和字符串。

索引器屬性

這個類提供了一個索引屬性來獲取或設置數組中的元素。的索引器返回類型是 BsonValue，的，所以通常有做一些轉換 。例如:

              array[0] = “Tom”;

              array[1] = 39;

              string name = array[0].AsString;

              int age = array[1].AsInt32;

Count屬性

這個屬性返回的值存儲在BsonArray

添加方法

只有一個Add方法，它 一個BsonValue添加到數組（但也看到AddRange方法）。例如:

              BsonValue value; // from somewhere

              array.Add(value);

              array.Add(1); // implicit conversion from int to BsonInt32

AddRange方法

一個重載，AddRange方法需要的IEnumerable <BsonValue>參數和添加 多個項目的數組。例如:

              IEnumerable<BsonValue> values; // from somewhere

              array.AddRange(values); // adds values to array

 

許多額外超載（IEnumerable的<int>的像）提供支持常見的情況，如：

              int[] values = new int[] { 1, 2, 3 };

              array.AddRange(values);

 

這個例子將無法編譯，因為IEnumerable <int>的不能被自動轉換IEnumerable的 <BsonValue>的 沒有了IEnumerable <int>的過載 。IEnumerable的重載為布爾型，日期時間型，雙，整型，長，對象和字符串。

清除方法

此方法清除所有值的數組。

的indexOf方法

可以使用下面的indexOf方法找到在數組中的值的索引：

              int IndexOf(BsonValue value)

              int IndexOf(BsonValue value, int index)

              int IndexOf(BsonValue value, int index, int count)

 

他們所有的工作一樣名單<T>匹配的indexOf方法，則返回-1，如果沒有匹配的數組中的項目。

插入方法

此方法用于添加一個值，在陣列中的一個特定的位置。例如:

              array.Insert(2, value);

 

這個例子假設數組包含至少2個元素。如果包含兩個以上的元素，索引2處的元素開始被移到一個位置，以騰出空間給新的元素。

刪除方法

Remove方法從數組中刪除一個特定的值。如果該值出現不止一次 在數組中，只有第一個實例被 刪除。所有剩余的元素被轉移到右側，以便不留間隙，在陣列中，得到的數組會更短（除非沒有匹配的元素被發現在這種情況下，這個方法沒有任何效果）。

RemoveAt方法

此方法將刪除從一個特定的值在數組中的位置。跟隨它的任何元素移動一個位置向左側和陣列是現在縮短一個元件的。

來自：http://www.cnblogs.com/WilliamWang/archive/2012/10/19/MongoDB.html