C# 訪問MongoDB 通用方法類

using MongoDB.Driver;  
using System;  
  
namespace MongoDBDemo  
{  
    public class MongoDb  
    {  
        public MongoDb(string host,string timeOut)  
        {  
            this.CONNECT_TIME_OUT = timeOut;  
            this.MONGO_CONN_HOST = host;  
        }  
  
        /// <summary>  
        /// 數據庫所在主機  
        /// </summary>  
        private readonly string MONGO_CONN_HOST;  
  
        /// <summary>  
        /// 數據庫所在主機的端口  
        /// </summary>  
        private readonly int MONGO_CONN_PORT = 27017;  
  
        /// <summary>  
        /// 連接超時設置 秒  
        /// </summary>  
        private readonly string CONNECT_TIME_OUT;  
  
        /// <summary>  
        /// 數據庫的名稱  
        /// </summary>  
        private readonly string DB_NAME = "Mdemo";  
  
        /// <summary>  
        /// 得到數據庫實例  
        /// </summary>  
        /// <returns></returns>  
        public MongoDatabase GetDataBase()  
        {  
            MongoClientSettings mongoSetting = new MongoClientSettings();  
            //設置連接超時時間  
            mongoSetting.ConnectTimeout = new TimeSpan(int.Parse(CONNECT_TIME_OUT) * TimeSpan.TicksPerSecond);  
            //設置數據庫服務器  
            mongoSetting.Server = new MongoServerAddress(MONGO_CONN_HOST, MONGO_CONN_PORT);  
            //創建Mongo的客戶端  
            MongoClient client = new MongoClient(mongoSetting);  
            //得到服務器端並且生成數據庫實例  
            return client.GetServer().GetDatabase(DB_NAME);  
        }  
    }  
}  

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Text;  
  
namespace MongoDBDemo 
{  
    /// <summary>  
    /// Mongodb數據庫的字段特性  主要是設置索引之用  
    /// </summary>  
    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]  
    public class MongoDbFieldAttribute : Attribute  
    {  
        /// <summary>  
        /// 是否是索引  
        /// </summary>  
        public bool IsIndex { get; set; }  
  
        /// <summary>  
        /// 是否是唯一的  默認flase  
        /// </summary>  
        public bool Unique { get; set; }  
  
        /// <summary>  
        /// 是否是升序 默認true  
        /// </summary>  
        public bool Ascending { get; set; }  
  
        public MongoDbFieldAttribute(bool _isIndex)  
        {  
            this.IsIndex = _isIndex;  
            this.Unique = false;  
            this.Ascending = true;  
        }  
    }  
}  

 

using System;  
using System.Collections.Generic;  
using System.Linq;  
using MongoDB.Driver;  
using MongoDB.Bson;  
using MongoDB.Driver.Builders;  
using System.Reflection;  
  
  
namespace MongoDBDemo  
{  
    /// <summary>  
    /// Mongo db的數據庫幫助類  
    /// </summary>  
    public class MongoDbHelper  
    {  
        /// <summary>  
        /// 數據庫的實例  
        /// </summary>  
        private MongoDatabase _db;  
  
        /// <summary>  
        /// ObjectId的鍵  
        /// </summary>  
        private readonly string OBJECTID_KEY = "_id";  
  
        public MongoDbHelper(string host,string timeOut)  
        {  
            this._db = new MongoDb(host,timeOut).GetDataBase();  
        }  
  
        public MongoDbHelper(MongoDatabase db)  
        {  
            this._db = db;  
        }  
  
        public T GetNextSequence<T>(IMongoQuery query, SortByDocument sortBy, UpdateDocument update, string collectionName,string indexName)  
        {  
            if (this._db == null)  
            {  
                return default(T);  
            }  
            try  
            {  
                MongoCollection<T> mc = this._db.GetCollection<T>(collectionName);  
                query = this.InitQuery(query);  
                sortBy = this.InitSortBy(sortBy, OBJECTID_KEY);  
                update = this.InitUpdateDocument(update, indexName);  
                var ido = mc.FindAndModify(query, sortBy, update, true, false);  
  
                return ido.GetModifiedDocumentAs<T>();  
            }  
            catch (Exception ex)  
            {  
                return default(T);  
            }  
        }  
 
        #region 插入數據  
        /// <summary>  
        /// 將數據插入進數據庫  
        /// </summary>  
        /// <typeparam name="T">需要插入數據的類型</typeparam>  
        /// <param name="t">需要插入的具體實體</param>  
        public bool Insert<T>(T t)  
        {  
            //集合名稱  
            string collectionName = typeof(T).Name;  
            return Insert<T>(t, collectionName);  
        }  
  
        /// <summary>  
        /// 將數據插入進數據庫  
        /// </summary>  
        /// <typeparam name="T">需要插入數據庫的實體類型</typeparam>  
        /// <param name="t">需要插入數據庫的具體實體</param>  
        /// <param name="collectionName">指定插入的集合</param>  
        public bool Insert<T>(T t, string collectionName)  
        {  
            if (this._db == null)  
            {  
                return false;  
            }  
            try  
            {  
                MongoCollection<BsonDocument> mc = this._db.GetCollection<BsonDocument>(collectionName);  
                //將實體轉換為bson文檔  
                BsonDocument bd = t.ToBsonDocument();  
                //進行插入操作  
                WriteConcernResult result = mc.Insert(bd);  
                if (!string.IsNullOrEmpty(result.ErrorMessage))  
                {  
                    return false;  
                }  
                return true;  
            }  
            catch (Exception ex)  
            {  
                return false;  
            }  
        }  
  
        /// <summary>  
        /// 批量插入數據  
        /// </summary>  
        /// <typeparam name="T">需要插入數據庫的實體類型</typeparam>  
        /// <param name="list">需要插入數據的列表</param>  
        public bool Insert<T>(List<T> list)  
        {  
            //集合名稱  
            string collectionName = typeof(T).Name;  
            return this.Insert<T>(list, collectionName);  
        }  
  
        /// <summary>  
        /// 批量插入數據  
        /// </summary>  
        /// <typeparam name="T">需要插入數據庫的實體類型</typeparam>  
        /// <param name="list">需要插入數據的列表</param>  
        /// <param name="collectionName">指定要插入的集合</param>  
        public bool Insert<T>(List<T> list, string collectionName)  
        {  
            if (this._db == null)  
            {  
                return false;  
            }  
            try  
            {  
                MongoCollection<BsonDocument> mc = this._db.GetCollection<BsonDocument>(collectionName);  
                //創建一個空間bson集合  
                List<BsonDocument> bsonList = new List<BsonDocument>();  
                //批量將數據轉為bson格式 並且放進bson文檔  
                list.ForEach(t => bsonList.Add(t.ToBsonDocument()));  
                //批量插入數據  
                mc.InsertBatch(bsonList);  
                return true;  
            }  
            catch (Exception ex)  
            {  
                return false;  
            }  
        }  
        #endregion  
 
        #region 查詢數據  
 
        #region 查詢所有記錄  
        /// <summary>  
        /// 查詢一個集合中的所有數據  
        /// </summary>  
        /// <typeparam name="T">該集合數據的所屬類型</typeparam>  
        /// <param name="collectionName">指定集合的名稱</param>  
        /// <returns>返回一個List列表</returns>  
        public List<T> FindAll<T>(string collectionName)  
        {  
            if (this._db == null)  
            {  
                return null;  
            }  
            try  
            {  
                MongoCollection<T> mc = this._db.GetCollection<T>(collectionName);  
                //以實體方式取出其數據集合  
                MongoCursor<T> mongoCursor = mc.FindAll();  
                //直接轉化為List返回  
                return mongoCursor.ToList<T>();  
            }  
            catch (Exception ex)  
            {  
                return null;  
            }  
        }  
  
        /// <summary>  
        /// 查詢一個集合中的所有數據 其集合的名稱為T的名稱  
        /// </summary>  
        /// <typeparam name="T">該集合數據的所屬類型</typeparam>  
        /// <returns>返回一個List列表</returns>  
        public List<T> FindAll<T>()  
        {  
            string collectionName = typeof(T).Name;  
            return FindAll<T>(collectionName);  
        }  
        #endregion  
 
        #region 查詢一條記錄  
        /// <summary>  
        /// 查詢索引最大的一條記錄  
        /// </summary>  
        /// <typeparam name="T">該數據所屬的類型</typeparam>  
        /// <param name="collectionName">去指定查詢的集合</param>  
        /// <param name="sort">排序字段</param>  
        /// <returns>返回一個實體類型</returns>  
        public T FindOneToIndexMax<T>(string collectionName, string[] sort)  
        {  
            return FindOneToIndexMax<T>(null, collectionName, sort);  
        }  
  
        /// <summary>  
        /// 查詢索引最大的一條記錄  
        /// </summary>  
        /// <typeparam name="T">該數據所屬的類型</typeparam>  
        /// <param name="query">查詢的條件 可以為空</param>  
        /// <param name="collectionName">去指定查詢的集合</param>  
        /// <param name="sort">排序字段</param>  
        /// <returns>返回一個實體類型</returns>  
        public T FindOneToIndexMax<T>(IMongoQuery query,string collectionName, string[] sort)  
        {  
            if (this._db == null)  
            {  
                return default(T);  
            }  
            try  
            {  
                MongoCollection<T> mc = this._db.GetCollection<T>(collectionName);  
                query = this.InitQuery(query);  
                T t = mc.Find(query).SetSortOrder(SortBy.Descending(sort)).FirstOrDefault<T>();  
                return t;  
            }  
            catch (Exception ex)  
            {  
                return default(T);  
            }  
        }  
        /// <summary>  
        /// 查詢一條記錄  
        /// </summary>  
        /// <typeparam name="T">該數據所屬的類型</typeparam>  
        /// <param name="query">查詢的條件 可以為空</param>  
        /// <param name="collectionName">去指定查詢的集合</param>  
        /// <returns>返回一個實體類型</returns>  
        public T FindOne<T>(IMongoQuery query, string collectionName)  
        {  
            if (this._db == null)  
            {  
                return default(T);  
            }  
            try  
            {  
                MongoCollection<T> mc = this._db.GetCollection<T>(collectionName);  
                query = this.InitQuery(query);  
                T t = mc.FindOne(query);  
                return t;  
            }  
            catch (Exception ex)  
            {  
                return default(T);  
            }  
        }  
  
        /// <summary>  
        /// 查詢一條記錄  
        /// </summary>  
        /// <typeparam name="T">該數據所屬的類型</typeparam>  
        /// <param name="collectionName">去指定查詢的集合</param>  
        /// <returns>返回一個實體類型</returns>  
        public T FindOne<T>(string collectionName)  
        {  
            return FindOne<T>(null, collectionName);  
        }  
  
        /// <summary>  
        /// 查詢一條記錄  
        /// </summary>  
        /// <typeparam name="T">該數據所屬的類型</typeparam>  
        /// <returns>返回一個實體類型</returns>  
        public T FindOne<T>()  
        {  
            string collectionName = typeof(T).Name;  
            return FindOne<T>(null, collectionName);  
        }  
  
  
        /// <summary>  
        /// 查詢一條記錄  
        /// </summary>  
        /// <typeparam name="T">該數據所屬的類型</typeparam>  
        /// <param name="query">查詢的條件 可以為空</param>  
        /// <returns>返回一個實體類型</returns>  
        public T FindOne<T>(IMongoQuery query)  
        {  
            string collectionName = typeof(T).Name;  
            return FindOne<T>(query, collectionName);  
        }  
        #endregion  
 
        #region 普通的條件查詢  
        /// <summary>  
        /// 根據指定條件查詢集合中的數據  
        /// </summary>  
        /// <typeparam name="T">該集合數據的所屬類型</typeparam>  
        /// <param name="query">指定的查詢條件 比如Query.And(Query.EQ("username","admin"),Query.EQ("password":"admin"))</param>  
        /// <param name="collectionName">指定的集合的名稱</param>  
        /// <returns>返回一個List列表</returns>  
        public List<T> Find<T>(IMongoQuery query, string collectionName)  
        {  
            if (this._db == null)  
            {  
                return null;  
            }  
            try  
            {  
                MongoCollection<T> mc = this._db.GetCollection<T>(collectionName);  
                query = this.InitQuery(query);  
                MongoCursor<T> mongoCursor = mc.Find(query);  
                return mongoCursor.ToList<T>();  
            }  
            catch (Exception ex)  
            {  
                return null;  
            }  
        }  
  
        /// <summary>  
        /// 根據指定條件查詢集合中的數據  
        /// </summary>  
        /// <typeparam name="T">該集合數據的所屬類型</typeparam>  
        /// <param name="query">指定的查詢條件 比如Query.And(Query.EQ("username","admin"),Query.EQ("password":"admin"))</param>  
        /// <returns>返回一個List列表</returns>  
        public List<T> Find<T>(IMongoQuery query)  
        {  
            string collectionName = typeof(T).Name;  
            return this.Find<T>(query,collectionName);  
        }  
        #endregion  
 
        #region 分頁查詢 PageIndex和PageSize模式  在頁數PageIndex大的情況下 效率明顯變低  
  
        /// <summary>  
        /// 分頁查詢 PageIndex和PageSize模式  在頁數PageIndex大的情況下 效率明顯變低  
        /// </summary>  
        /// <typeparam name="T">所需查詢的數據的實體類型</typeparam>  
        /// <param name="query">查詢的條件</param>  
        /// <param name="pageIndex">當前的頁數</param>  
        /// <param name="pageSize">當前的尺寸</param>  
        /// <param name="sortBy">排序方式</param>  
        /// <param name="collectionName">集合名稱</param>  
        /// <returns>返回List列表</returns>  
        public List<T> Find<T>(IMongoQuery query, int pageIndex, int pageSize, SortByDocument sortBy, string collectionName)  
        {  
            if (this._db == null)  
            {  
                return null;  
            }  
            try  
            {  
                MongoCollection<T> mc = this._db.GetCollection<T>(collectionName);  
                MongoCursor<T> mongoCursor = null;  
                query = this.InitQuery(query);  
                sortBy = this.InitSortBy(sortBy, OBJECTID_KEY);  
                //如頁序號為0時初始化為1  
                pageIndex = pageIndex == 0 ? 1 : pageIndex;  
                //按條件查詢 排序 跳數 取數  
                mongoCursor = mc.Find(query).SetSortOrder(sortBy).SetSkip((pageIndex - 1) * pageSize).SetLimit(pageSize);  
                return mongoCursor.ToList<T>();  
            }  
            catch (Exception ex)  
            {  
                return null;  
            }  
        }  
  
        /// <summary>  
        /// 分頁查詢 PageIndex和PageSize模式  在頁數PageIndex大的情況下 效率明顯變低  
        /// </summary>  
        /// <typeparam name="T">所需查詢的數據的實體類型</typeparam>  
        /// <param name="query">查詢的條件</param>  
        /// <param name="pageIndex">當前的頁數</param>  
        /// <param name="pageSize">當前的尺寸</param>  
        /// <param name="sortBy">排序方式</param>  
        /// <returns>返回List列表</returns>  
        public List<T> Find<T>(IMongoQuery query, int pageIndex, int pageSize, SortByDocument sortBy)  
        {  
            string collectionName = typeof(T).Name;  
            return this.Find<T>(query, pageIndex, pageSize, sortBy, collectionName);  
        }  
 
        #endregion  
 
        #region 分頁查詢 指定索引最后項-PageSize模式  
  
        /// <summary>  
        /// 分頁查詢 指定索引最后項-PageSize模式   
        /// </summary>  
        /// <typeparam name="T">所需查詢的數據的實體類型</typeparam>  
        /// <param name="query">查詢的條件 沒有可以為null</param>  
        /// <param name="indexName">索引名稱</param>  
        /// <param name="lastKeyValue">最后索引的值</param>  
        /// <param name="pageSize">分頁的尺寸</param>  
        /// <param name="sortType">排序類型 1升序 -1降序 僅僅針對該索引</param>  
        /// <param name="collectionName">指定的集合名稱</param>  
        /// <returns>返回一個List列表數據</returns>  
        public List<T> Find<T>(IMongoQuery query, string indexName, object lastKeyValue, int pageSize, int sortType, string collectionName)  
        {  
            if (this._db == null)  
            {  
                return null;  
            }  
            try  
            {  
                MongoCollection<T> mc = this._db.GetCollection<T>(collectionName);  
                MongoCursor<T> mongoCursor = null;  
                query = this.InitQuery(query);  
  
                //判斷升降序后進行查詢  
                if (sortType > 0)  
                {  
                    //升序  
                    if (lastKeyValue != null)  
                    {  
                        //有上一個主鍵的值傳進來時才添加上一個主鍵的值的條件  
                        query = Query.And(query, Query.GT(indexName, BsonValue.Create(lastKeyValue)));  
                    }  
                    //先按條件查詢 再排序 再取數  
                    mongoCursor = mc.Find(query).SetSortOrder(new SortByDocument(indexName, 1)).SetLimit(pageSize);  
                }  
                else  
                {  
                    //降序  
                    if (lastKeyValue != null)  
                    {  
                        query = Query.And(query, Query.LT(indexName, BsonValue.Create(lastKeyValue)));  
                    }  
                    mongoCursor = mc.Find(query).SetSortOrder(new SortByDocument(indexName, -1)).SetLimit(pageSize);  
                }  
                return mongoCursor.ToList<T>();  
            }  
            catch (Exception ex)  
            {  
                return null;  
            }  
        }  
  
        /// <summary>  
        /// 分頁查詢 指定索引最后項-PageSize模式   
        /// </summary>  
        /// <typeparam name="T">所需查詢的數據的實體類型</typeparam>  
        /// <param name="query">查詢的條件 沒有可以為null</param>  
        /// <param name="indexName">索引名稱</param>  
        /// <param name="lastKeyValue">最后索引的值</param>  
        /// <param name="pageSize">分頁的尺寸</param>  
        /// <param name="sortType">排序類型 1升序 -1降序 僅僅針對該索引</param>  
        /// <returns>返回一個List列表數據</returns>  
        public List<T> Find<T>(IMongoQuery query, string indexName, object lastKeyValue, int pageSize, int sortType)  
        {  
            string collectionName = typeof(T).Name;  
            return this.Find<T>(query, indexName, lastKeyValue, pageSize, sortType, collectionName);  
        }  
  
        /// <summary>  
        /// 分頁查詢 指定ObjectId最后項-PageSize模式   
        /// </summary>  
        /// <typeparam name="T">所需查詢的數據的實體類型</typeparam>  
        /// <param name="query">查詢的條件 沒有可以為null</param>  
        /// <param name="lastObjectId">上一條記錄的ObjectId 沒有可以為空</param>  
        /// <param name="pageSize">每頁尺寸</param>  
        /// <param name="sortType">排序類型 1升序 -1降序 僅僅針對_id</param>  
        /// <param name="collectionName">指定去查詢集合的名稱</param>  
        /// <returns>返回一個List列表數據</returns>  
        public List<T> Find<T>(IMongoQuery query, string lastObjectId, int pageSize, int sortType, string collectionName)  
        {  
            return this.Find<T>(query, OBJECTID_KEY, new ObjectId(lastObjectId), pageSize, sortType, collectionName);  
        }  
  
        /// <summary>  
        /// 分頁查詢 指定ObjectId最后項-PageSize模式   
        /// </summary>  
        /// <typeparam name="T">所需查詢的數據的實體類型</typeparam>  
        /// <param name="query">查詢的條件 沒有可以為null</param>  
        /// <param name="lastObjectId">上一條記錄的ObjectId 沒有可以為空</param>  
        /// <param name="pageSize">每頁尺寸</param>  
        /// <param name="sortType">排序類型 1升序 -1降序 僅僅針對_id</param>  
        /// <returns>返回一個List列表數據</returns>  
        public List<T> Find<T>(IMongoQuery query, string lastObjectId, int pageSize, int sortType)  
        {  
            string collectionName = typeof(T).Name;  
            return Find<T>(query, lastObjectId, pageSize, sortType, collectionName);  
        }  
 
        #endregion  
 
 
        #endregion  
 
        #region 更新數據  
  
        /// <summary>  
        /// 更新數據  
        /// </summary>  
        /// <typeparam name="T">更新的數據 所屬的類型</typeparam>  
        /// <param name="query">更新數據的查詢</param>  
        /// <param name="update">需要更新的文檔</param>  
        /// <param name="collectionName">指定更新集合的名稱</param>  
        public bool Update<T>(IMongoQuery query, IMongoUpdate update, string collectionName)  
        {  
            if (this._db == null)  
            {  
                return false;  
            }  
            try  
            {  
                MongoCollection<T> mc = this._db.GetCollection<T>(collectionName);  
                query = this.InitQuery(query);  
                //更新數據  
                WriteConcernResult result = mc.Update(query, update, UpdateFlags.Multi);  
                return true;  
            }  
            catch (Exception ex)  
            {  
                return false;                 
            }  
        }  
  
        /// <summary>  
        /// 更新數據  
        /// </summary>  
        /// <typeparam name="T">更新的數據 所屬的類型</typeparam>  
        /// <param name="query">更新數據的查詢</param>  
        /// <param name="update">需要更新的文檔</param>  
        public bool Update<T>(IMongoQuery query, IMongoUpdate update)  
        {  
            string collectionName = typeof(T).Name;  
            return this.Update<T>(query, update, collectionName);  
        }  
 
        #endregion  
 
        #region 移除/刪除數據  
        /// <summary>  
        /// 移除指定的數據  
        /// </summary>  
        /// <typeparam name="T">移除的數據類型</typeparam>  
        /// <param name="query">移除的數據條件</param>  
        /// <param name="collectionName">指定的集合名詞</param>  
        public bool Remove<T>(IMongoQuery query, string collectionName)  
        {  
            if (this._db == null)  
            {  
                return false;  
            }  
            try  
            {  
                MongoCollection<T> mc = this._db.GetCollection<T>(collectionName);  
                query = this.InitQuery(query);  
                //根據指定查詢移除數據  
                mc.Remove(query);  
                return true;  
            }  
            catch (Exception ex)  
            {  
                return false;  
            }  
        }  
  
        /// <summary>  
        /// 移除指定的數據  
        /// </summary>  
        /// <typeparam name="T">移除的數據類型</typeparam>  
        /// <param name="query">移除的數據條件</param>  
        public bool Remove<T>(IMongoQuery query)  
        {  
            string collectionName = typeof(T).Name;  
            return this.Remove<T>(query,collectionName);  
        }  
  
        /// <summary>  
        /// 移除實體里面所有的數據  
        /// </summary>  
        /// <typeparam name="T">移除的數據類型</typeparam>  
        public bool ReomveAll<T>()  
        {  
            string collectionName = typeof(T).Name;  
            return this.Remove<T>(null,collectionName);  
        }  
  
        /// <summary>  
        /// 移除實體里面所有的數據  
        /// </summary>  
        /// <typeparam name="T">移除的數據類型</typeparam>  
        /// <param name="collectionName">指定的集合名稱</param>  
        public bool RemoveAll<T>(string collectionName)  
        {  
            return this.Remove<T>(null,collectionName);  
        }  
        #endregion  
 
        #region 創建索引  
        /// <summary>  
        /// 創建索引   
        /// </summary>  
        /// <typeparam name="T">需要創建索引的實體類型</typeparam>  
        public bool CreateIndex<T>()  
        {  
            if (this._db == null)  
            {  
                return false;  
            }  
            try  
            {  
                string collectionName = typeof(T).Name;  
                MongoCollection<BsonDocument> mc = this._db.GetCollection<BsonDocument>(collectionName);  
  
                PropertyInfo[] propertys = typeof(T).GetProperties(BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Public | BindingFlags.SetProperty);  
                //得到該實體類型的屬性  
                foreach (PropertyInfo property in propertys)  
                {  
                    //在各個屬性中得到其特性  
                    foreach (object obj in property.GetCustomAttributes(true))  
                    {  
                        MongoDbFieldAttribute mongoField = obj as MongoDbFieldAttribute;  
                        if (mongoField != null)  
                        {// 此特性為mongodb的字段屬性  
  
                            IndexKeysBuilder indexKey;  
                            if (mongoField.Ascending)  
                            {  
                                //升序 索引  
                                indexKey = IndexKeys.Ascending(property.Name);  
                            }  
                            else  
                            {  
                                //降序索引  
                                indexKey = IndexKeys.Descending(property.Name);  
                            }  
                            //創建該屬性  
                            mc.CreateIndex(indexKey, IndexOptions.SetUnique(mongoField.Unique));  
                        }  
                    }  
                }  
                return true;  
            }  
            catch (Exception ex)  
            {  
                return false;  
            }  
        }  
        #endregion  
 
        #region 獲取表的行數  
        /// <summary>  
        /// 獲取數據表總行數  
        /// </summary>  
        /// <typeparam name="T"></typeparam>  
        /// <param name="query"></param>  
        /// <param name="collectionName"></param>  
        /// <returns></returns>  
        public long GetCount<T>(IMongoQuery query,string collectionName)  
        {  
            if (this._db == null)  
            {  
                return 0;  
            }  
            try  
            {  
                MongoCollection<T> mc = this._db.GetCollection<T>(collectionName);  
                if (query == null)  
                {  
                    return mc.Count();  
                }  
                else  
                {  
                    return mc.Count(query);  
                }                 
            }  
            catch (Exception ex)  
            {  
                return 0;  
            }  
        }  
        /// <summary>  
        /// 獲取數據表總行數  
        /// </summary>  
        /// <typeparam name="T"></typeparam>  
        /// <param name="query"></param>  
        /// <returns></returns>  
        public long GetCount<T>(IMongoQuery query)  
        {  
            string collectionName = typeof(T).Name;  
            return GetCount<T>(query,collectionName);  
        }  
 
        #endregion  
 
        #region 獲取集合的存儲大小  
        /// <summary>  
        /// 獲取集合的存儲大小  
        /// </summary>  
        /// <typeparam name="T">該集合對應的實體類</typeparam>  
        /// <returns>返回一個long型</returns>  
        public long GetDataSize<T>()  
        {  
            string collectionName = typeof(T).Name;  
            return GetDataSize(collectionName);  
        }  
  
        /// <summary>  
        /// 獲取集合的存儲大小  
        /// </summary>  
        /// <param name="collectionName">該集合對應的名稱</param>  
        /// <returns>返回一個long型</returns>  
        public long GetDataSize(string collectionName)  
        {  
            if (this._db == null)  
            {  
                return 0;  
            }  
            try  
            {  
                MongoCollection<BsonDocument> mc = this._db.GetCollection<BsonDocument>(collectionName);  
                return mc.GetTotalStorageSize();  
            }  
            catch (Exception ex)  
            {  
                return 0;  
            }  
        }  
 
 
        #endregion  
 
        #region 私有的一些輔助方法  
        /// <summary>  
        /// 初始化查詢記錄 主要當該查詢條件為空時 會附加一個恆真的查詢條件，防止空查詢報錯  
        /// </summary>  
        /// <param name="query">查詢的條件</param>  
        /// <returns></returns>  
        private IMongoQuery InitQuery(IMongoQuery query)  
        {  
            if (query == null)  
            {  
                //當查詢為空時 附加恆真的條件 類似SQL：1=1的語法  
                query = Query.Exists(OBJECTID_KEY);  
            }  
            return query;  
        }  
  
        /// <summary>  
        /// 初始化排序條件  主要當條件為空時 會默認以ObjectId遞增的一個排序  
        /// </summary>  
        /// <param name="sortBy"></param>  
        /// <param name="sortByName"></param>  
        /// <returns></returns>  
        private SortByDocument InitSortBy(SortByDocument sortBy, string sortByName)  
        {  
            if (sortBy == null)  
            {  
                //默認ObjectId 遞增  
                sortBy = new SortByDocument(sortByName, -1);  
            }  
            return sortBy;  
        }  
  
        private UpdateDocument InitUpdateDocument(UpdateDocument update,string indexName)  
        {  
            if (update == null)  
            {  
                update = new UpdateDocument("$inc", new QueryDocument(indexName, 0));  
            }  
            return update;  
        }  
        #endregion  
    }  
}  

using System;  
using System.Collections.Generic;  
using System.Linq;  
using System.Web;  
using System.Web.Mvc;  
using MongoDB;  
using MongoDbDemo;  
using MongoDB.Driver;  
using MongoDB.Bson;  
using DAL.Entity;  
using DAL;  
using MongoDB.Driver.Builders;  
using System.Diagnostics;  
  
namespace MongoDbDemo.Controllers  
{  
    public class HomeController : Controller  
    {  
        //  
        // GET: /Home/  
  
        public ActionResult Index()  
        {  
            return Content("MongoDbDemo");  
        }  
 
        #region INSERT  
        /// <summary>  
        /// 添加用戶  
        /// </summary>  
        /// <returns></returns>  
        public ActionResult Ruser()  
        {  
            try  
            {  
                string name = Request["name"];  
                string age = Request["age"];  
                User user1 = new User { Uname = name, Age = age };  
                MongoDbHelper mh = new MongoDbHelper("127.0.0.1", "1000");  
                if (mh.Insert<User>(user1))  
                {  
                    return Json(new { success = "true" });  
                }  
            }  
            catch (Exception)  
            {  
                return Json(new { success = "filled" });  
                throw;  
            }  
            return Json(new { success = "filled" });  
        }  
        #endregion  
 
        #region SELECT  
        /// <summary>  
        /// 查詢一個集合中的所有數據  
        /// </summary>  
        /// <returns></returns>  
        public ActionResult Seluser()  
        {             
            MongoDbHelper mh = new MongoDbHelper("127.0.0.1", "1000");  
            List<User> users = mh.FindAll<User>();  
            return Json(new { success="true"});  
        }  
  
        /// <summary>  
        /// 按條件查詢一條數據  
        /// </summary>  
        /// <returns></returns>  
        public ActionResult SelOne()  
        {  
            string name = Request["name"];  
            string age=Request["age"];  
            MongoDbHelper mh = new MongoDbHelper("127.0.0.1", "1000");  
            User users = mh.FindOne<User>(Query.And(Query.EQ("Uname", name), Query.EQ("Age", age)));  
            return Json(new {success="true" ,users=users});  
        }  
  
        /// <summary>  
        /// 分頁查詢  
        /// </summary>  
        /// <returns></returns>  
        public ActionResult SelPage()   
        {  
            int pageindex=int.Parse(Request["pageindex"]);//頁索引  
            int pagesize = int.Parse(Request["pagesize"]);//行數  
            MongoDbHelper mh = new MongoDbHelper("127.0.0.1", "1000");  
            Stopwatch sw1 = new Stopwatch();  
            sw1.Start();  
            List<User> users = mh.Find<User>(null,pageindex,pagesize,null);  
            return Json(new {success="true",users=users });  
        }  
        #endregion  
 
        #region UPDATE  
        /// <summary>  
        /// 修改信息  
        /// </summary>  
        /// <returns></returns>  
        public ActionResult upduser()  
        {  
            MongoDbHelper mh = new MongoDbHelper("127.0.0.1", "1000");  
            if (mh.Update<User>(Query.EQ("Uname", "阿斯達"), Update.Set("Uname", "阿斯達s"), "User"))  
            {  
                return Json(new { success = "true" });  
            }  
            else  
            {  
                return Json(new { success = "fales" });  
            }  
  
        }  
        #endregion  
 
        #region DELETE  
        /// <summary>  
        /// 刪除消息  
        /// </summary>  
        /// <returns></returns>  
        public ActionResult deluser()   
        {  
            MongoDbHelper mh = new MongoDbHelper("127.0.0.1", "1000");  
            if (mh.Remove<User>(Query.EQ("Uname", "阿斯達s")))  
            {  
                return Json(new { success = "true" });  
            }  
            else {  
                return Json(new { success = "fales" });  
            }  
        }  
        #endregion  
    }  
}  

 

Query.All("name", "a","b"); //通過多個元素來匹配數組

 Query.And(Query.EQ("name","a"), Query.EQ("title", "t"));//同時滿足多個條件

 Query.EQ("name", "a");//等於

 Query.Exists("type", true);//判斷鍵值是否存在

 Query.GT("value", 2);//大於>

 Query.GTE("value", 3);//大於等於>=

 Query.In("name", "a","b");//包括指定的所有值,可以指定不同類型的條件和值

 Query.LT("value", 9);//小於<

 Query.LTE("value", 8);//小於等於<=

 Query.Mod("value", 3, 1);//將查詢值除以第一個給定值,若余數等於第二個給定值則返回該結果

 Query.NE("name", "c");//不等於

 Query.Nor(Array);//不包括數組中的值

 Query.Not("name");//元素條件語句

 Query.NotIn("name", "a",2);//返回與數組中所有條件都不匹配的文檔

 Query.Or(Query.EQ("name","a"), Query.EQ("title", "t"));//滿足其中一個條件

 Query.Size("name", 2);//給定鍵的長度

 Query.Type("_id", BsonType.ObjectId);//給定鍵的類型

 Query.Where(BsonJavaScript);//執行JavaScript

 Query.Matches("Title",str);//模糊查詢 相當於sql中like -- str可包含正則表達式

 

網上找的，寫的不錯，收藏了，簡單的使用.NET 進行MongoDB的增刪改查