1. 程式人生 > >【MongoDB學習-在.NET中的簡單操作】

【MongoDB學習-在.NET中的簡單操作】

using MongoDB.Driver;
using System;

namespace DAL
{
    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 DAL
{
    /// <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 DAL
{
    /// <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
    }
}

4.呼叫:先引用庫檔案:


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
    }
}
簡單的使用.NET 進行MongoDB的增刪改查。