c#操作MangoDB 之MangoDB CSharp Driver驱动详解

序言

MangoDB CSharp Driver是c#操作mongodb的官方驱动。

官方Api文档：http://api.mongodb.org/csharp/2.2/html/R_Project_CSharpDriverDocs.htm#!

驱动的具体介绍：https://docs.mongodb.org/ecosystem/drivers/csharp/

本文主要对c#操作mongodb的增删改查，以及数据库链接配置做代码示例，方便进一步封装及学习。

mongodb链接配置

 public class MongoConfig
    {       
        public static MongoServerSettings config = null;
        static MongoConfig()
        {
            config = MongoServerSettings.FromUrl(MongoUrl.Create(conStr));
            //最大连接池
            config.MaxConnectionPoolSize = 500;
            //最大闲置时间
            config.MaxConnectionIdleTime = TimeSpan.FromSeconds(30);
            //最大存活时间
            config.MaxConnectionLifeTime = TimeSpan.FromSeconds(60);
            //链接时间
            config.ConnectTimeout = TimeSpan.FromSeconds(10);
            //等待队列大小
            config.WaitQueueSize = 50;
            //socket超时时间
            config.SocketTimeout = TimeSpan.FromSeconds(10);
            //队列等待时间
            config.WaitQueueTimeout = TimeSpan.FromSeconds(60);
            //操作时间
            config.OperationTimeout = TimeSpan.FromSeconds(60); 
        }
        public static string conStr
        {
            get
            {
                return ConfigurationManager.AppSettings["connectionString"];
            }
        }
        public static string mongoDB
        {
            get
            {
                return ConfigurationManager.AppSettings["mongoDB"];
            }
        }
    }

public class MongoCon : IDisposable
    {
        public static MongoServer mongoCon = null;
        public static MongoDatabase mongo { get; private set; }
        private bool disposed = false;
        static MongoCon()
        {
            //创建链接
            mongoCon = new MongoServer(MongoConfig.config);
            //打开链接
            mongoCon.Connect();
            //获取mongodb指定数据库
            mongo = mongoCon.GetDatabase(MongoConfig.mongoDB);
        }
        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                {
                    //释放链接
                    mongoCon.Disconnect();
                }
                mongoCon = null;
            }
            this.disposed = true;
        }
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
    }

c#操作mongodb增删改查详细

 public class DoMongo
    {
        private static MongoDatabase mdb = MongoCon.mongo;
        #region 新增
        /// <summary>  
        /// 新增  
        /// </summary>   
        public static Boolean Insert(String collectionName, BsonDocument document)
        {
            MongoCollection<BsonDocument> collection = mdb.GetCollection<BsonDocument>(collectionName);
            try
            {
                collection.Insert(document);
                return true;
            }
            catch
            {
                return false;
            }
        }
        /// <summary>  
        /// 新增  
        /// </summary>   
        public static Boolean Insert<T>(String collectionName, T t)
        {
            var collection = mdb.GetCollection<T>(collectionName);
            try
            {
                collection.Insert(t);
                return true;
            }
            catch
            {
                return false;
            }
        }
        /// <summary>  
        /// 批量新增  
        /// </summary>
        public static WriteConcernResult Insert<T>(String collectionName, List<T> list)
        {
            var collection = mdb.GetCollection<T>(collectionName);
            try
            {
                return collection.Insert(list);
            }
            catch
            {
                return null;
            }
        }
        #endregion
        #region 查询
        /// <summary>  
        /// 查询单个对象  
        /// </summary>    
        public static T GetModel<T>(String collectionName, IMongoQuery query)
        {

            MongoCollection<T> collection = mdb.GetCollection<T>(collectionName);
            try
            {
                return collection.FindOneAs<T>(query);
            }
            catch
            {
                return default(T);
            }
        }
        /// <summary>
        /// 查询对象集合
        /// </summary>
        public static List<T> GetList<T>(String collectionName, IMongoQuery query)
        {
            MongoCollection<T> collection = mdb.GetCollection<T>(collectionName);
            try
            {
                return collection.FindAs<T>(query).ToList();
            }
            catch
            {
                return null;
            }
        }
        /// <summary>
        /// 查询对象集合
        /// </summary>
        public static List<T> GetList<T>(String collectionName, IMongoQuery query, int top)
        {
            MongoCollection<T> collection = mdb.GetCollection<T>(collectionName);
            try
            {
                return collection.FindAs<T>(query).SetLimit(top).ToList();
            }
            catch
            {
                return null;
            }
        }
        /// <summary>
        /// 查询对象集合
        /// </summary>
        public static List<T> GetList<T>(String collectionName, IMongoQuery query, string sort, bool isDesc)
        {
            MongoCollection<T> collection = mdb.GetCollection<T>(collectionName);
            try
            {
                if (isDesc)
                {
                    return collection.FindAs<T>(query).SetSortOrder(SortBy.Descending(sort)).ToList();
                }
                else
                {
                    return collection.FindAs<T>(query).SetSortOrder(SortBy.Ascending(sort)).ToList();
                }
            }
            catch
            {
                return null;
            }
        }
        /// <summary>
        /// 查询对象集合
        /// </summary>
        public static List<T> GetList<T>(String collectionName, IMongoQuery query, string[] sort, bool isDesc)
        {
            MongoCollection<T> collection = mdb.GetCollection<T>(collectionName);
            try
            {
                if (isDesc)
                {
                    return collection.FindAs<T>(query).SetSortOrder(SortBy.Descending(sort)).ToList();
                }
                else
                {
                    return collection.FindAs<T>(query).SetSortOrder(SortBy.Ascending(sort)).ToList();
                }
            }
            catch
            {
                return null;
            }
        }

        /// <summary>
        /// 查询对象集合
        /// </summary>
        public static List<T> GetList<T>(String collectionName, IMongoQuery query, string sort, bool isDesc, int top)
        {
            MongoCollection<T> collection = mdb.GetCollection<T>(collectionName);
            try
            {
                if (isDesc)
                {
                    return collection.FindAs<T>(query).SetSortOrder(SortBy.Descending(sort)).SetLimit(top).ToList();
                }
                else
                {
                    return collection.FindAs<T>(query).SetSortOrder(SortBy.Ascending(sort)).SetLimit(top).ToList();
                }
            }
            catch
            {
                return null;
            }
        }
        /// <summary>
        /// 查询对象集合
        /// </summary>
        public static List<T> GetList<T>(String collectionName, IMongoQuery query, string[] sort, bool isDesc, int top)
        {
            MongoCollection<T> collection = mdb.GetCollection<T>(collectionName);
            try
            {
                if (isDesc)
                {
                    return collection.FindAs<T>(query).SetSortOrder(SortBy.Descending(sort)).SetLimit(top).ToList();
                }
                else
                {
                    return collection.FindAs<T>(query).SetSortOrder(SortBy.Ascending(sort)).SetLimit(top).ToList();
                }
            }
            catch
            {
                return null;
            }
        }
        /// <summary>
        /// 分页查询
        /// </summary>       
        public static List<T> GetPageList<T>(String collectionName, IMongoQuery query, string sort, bool isDesc, int index, int pageSize, out long rows)
        {
            MongoCollection<T> collection = mdb.GetCollection<T>(collectionName);
            try
            {
                rows = collection.FindAs<T>(query).Count();
                if (isDesc)
                {
                    return collection.FindAs<T>(query).SetSortOrder(SortBy.Descending(sort)).SetSkip(index).SetLimit(pageSize).ToList();
                }
                else
                {
                    return collection.FindAs<T>(query).SetSortOrder(SortBy.Ascending(sort)).SetSkip(index).SetLimit(pageSize).ToList();
                }
            }
            catch
            {
                rows = 0;
                return null;
            }
        }
        /// <summary>
        /// 分页查询
        /// </summary>       
        public static List<T> GetPageList<T>(String collectionName, IMongoQuery query, string[] sort, bool isDesc, int index, int pageSize, out long rows)
        {
            MongoCollection<T> collection = mdb.GetCollection<T>(collectionName);
            try
            {
                rows = collection.FindAs<T>(query).Count();
                if (isDesc)
                {
                    return collection.FindAs<T>(query).SetSortOrder(SortBy.Descending(sort)).SetSkip(index).SetLimit(pageSize).ToList();
                }
                else
                {
                    return collection.FindAs<T>(query).SetSortOrder(SortBy.Ascending(sort)).SetSkip(index).SetLimit(pageSize).ToList();
                }
            }
            catch
            {
                rows = 0;
                return null;
            }
        }
        #endregion
        #region 修改
        /// <summary>  
        /// 修改  
        /// </summary>    
        public static WriteConcernResult Update(String collectionName, IMongoQuery query, QueryDocument update)
        {
            MongoCollection<BsonDocument> collection = mdb.GetCollection<BsonDocument>(collectionName);
            try
            {
                var new_doc = new UpdateDocument() { { "$set", update } };
                //UpdateFlags设置为Multi时，可批量修改
                var result = collection.Update(query, new_doc, UpdateFlags.Multi);
                return result;
            }
            catch
            {
                return null;
            }
        }
        #endregion
        #region 移除
        /// <summary>  
        /// 移除匹配的集合
        /// </summary>  
        public static Boolean Remove(String collectionName, IMongoQuery query)
        {

            MongoCollection<BsonDocument> collection = mdb.GetCollection<BsonDocument>(collectionName);
            try
            {
                collection.Remove(query);
                return true;
            }
            catch
            {
                return false;
            }
        }
        /// <summary>  
        /// 移除所有集合  
        /// </summary>  
        public static Boolean RemoveAll(String collectionName)
        {

            MongoCollection<BsonDocument> collection = mdb.GetCollection<BsonDocument>(collectionName);
            try
            {
                collection.RemoveAll();
                return true;
            }
            catch
            {
                return false;
            }
        }
        #endregion
        #region 其它
        /// <summary>
        /// 是否存在
        /// </summary>      
        public static bool IsExist(string collectionName)
        {
            MongoCollection<BsonDocument> collection = mdb.GetCollection<BsonDocument>(collectionName);
            try
            {
                return collection.Exists();
            }
            catch
            {
                return false;
            }
        }
        /// <summary>
        /// 总数
        /// </summary>      
        public static long Count(string collectionName)
        {
            MongoCollection<BsonDocument> collection = mdb.GetCollection<BsonDocument>(collectionName);
            try
            {
                return collection.Count();
            }
            catch
            {
                return 0;
            }
        }
        /// <summary>
        /// 总数
        /// </summary>    
        public static long Count(string collectionName, IMongoQuery query)
        {
            MongoCollection<BsonDocument> collection = mdb.GetCollection<BsonDocument>(collectionName);
            try
            {
                return collection.Count(query);
            }
            catch
            {
                return 0;
            }
        }
        #endregion
    }

monogodb中where条件操作符号

            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可包含正则表达式

小结

此文代码主要是作为仓储的基方法进行的封装，当然如果项目结构简单也可以直接使用操作，如果你有什么疑问，或者想一起交流学习，欢迎加入左上角的群。同事也欢迎点击观看, 我的mongodb系列