Mongo帮助类（DotNet版本）

该帮助类是针对 C#语言，   我使用的驱动版本为：MongoDB.Driver为2.7.0.0版本；

 增删改查，由网上大佬整理所得；

using Hubert.Common.Method.Log;
using MongoDB.Bson;
using MongoDB.Driver;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace Hubert.Common.Method.Mongo
{
    public class MongoDBHelper
    {
        private readonly string connectionString = null;
        private readonly string databaseName = null;
        private IMongoDatabase database = null;
        private readonly bool autoCreateDb = false;
        private readonly bool autoCreateCollection = false;

        static MongoDBHelper()
        {
            BsonDefaults.GuidRepresentation = GuidRepresentation.Standard;
        }

        public MongoDBHelper(string mongoConnStr, string dbName, bool autoCreateDb = false, bool autoCreateCollection = false)
        {
            this.connectionString = mongoConnStr;
            this.databaseName = dbName;
            this.autoCreateDb = autoCreateDb;
            this.autoCreateCollection = autoCreateCollection;
        }

        #region 私有方法

        private MongoClient CreateMongoClient()
        {
            return new MongoClient(connectionString);
        }


        private MongoDB.Driver.IMongoDatabase GetMongoDatabase()
        {
            if (database == null)
            {
                var client = CreateMongoClient();
                if (!DatabaseExists(client, databaseName) && !autoCreateDb)
                {
                    throw new KeyNotFoundException("此MongoDB名称不存在：" + databaseName);
                }

                database = CreateMongoClient().GetDatabase(databaseName);
            }

            return database;
        }

        private bool DatabaseExists(MongoClient client, string dbName)
        {
            try
            {
                var dbNames = client.ListDatabases().ToList().Select(db => db.GetValue("name").AsString);
                return dbNames.Contains(dbName);
            }
            catch //如果连接的账号不能枚举出所有DB会报错，则默认为true
            {
                return true;
            }

        }

        private bool CollectionExists(IMongoDatabase database, string collectionName)
        {
            var options = new ListCollectionsOptions
            {
                Filter = Builders<BsonDocument>.Filter.Eq("name", collectionName)
            };

            return database.ListCollections(options).ToEnumerable().Any();
        }


        private MongoDB.Driver.IMongoCollection<TDoc> GetMongoCollection<TDoc>(string name, MongoCollectionSettings settings = null)
        {
            var mongoDatabase = GetMongoDatabase();

            if (!CollectionExists(mongoDatabase, name) && !autoCreateCollection)
            {
                throw new KeyNotFoundException("此Collection名称不存在：" + name);
            }

            return mongoDatabase.GetCollection<TDoc>(name, settings);
        }

        private List<UpdateDefinition<TDoc>> BuildUpdateDefinition<TDoc>(object doc, string parent)
        {
            var updateList = new List<UpdateDefinition<TDoc>>();
            foreach (var property in typeof(TDoc).GetProperties(BindingFlags.Instance | BindingFlags.Public))
            {
                var key = parent == null ? property.Name : string.Format("{0}.{1}", parent, property.Name);
                //非空的复杂类型
                if ((property.PropertyType.IsClass || property.PropertyType.IsInterface) && property.PropertyType != typeof(string) && property.GetValue(doc) != null)
                {
                    if (typeof(IList).IsAssignableFrom(property.PropertyType))
                    {
                        #region 集合类型
                        int i = 0;
                        var subObj = property.GetValue(doc);
                        foreach (var item in subObj as IList)
                        {
                            if (item.GetType().IsClass || item.GetType().IsInterface)
                            {
                                updateList.AddRange(BuildUpdateDefinition<TDoc>(doc, string.Format("{0}.{1}", key, i)));
                            }
                            else
                            {
                                updateList.Add(Builders<TDoc>.Update.Set(string.Format("{0}.{1}", key, i), item));
                            }
                            i++;
                        }
                        #endregion
                    }
                    else
                    {
                        #region 实体类型
                        //复杂类型，导航属性，类对象和集合对象 
                        var subObj = property.GetValue(doc);
                        foreach (var sub in property.PropertyType.GetProperties(BindingFlags.Instance | BindingFlags.Public))
                        {
                            updateList.Add(Builders<TDoc>.Update.Set(string.Format("{0}.{1}", key, sub.Name), sub.GetValue(subObj)));
                        }
                        #endregion
                    }
                }
                else //简单类型
                {
                    updateList.Add(Builders<TDoc>.Update.Set(key, property.GetValue(doc)));
                }
            }

            return updateList;
        }


        private void CreateIndex<TDoc>(IMongoCollection<TDoc> col, string[] indexFields, CreateIndexOptions options = null)
        {
            if (indexFields == null)
            {
                return;
            }
            var indexKeys = Builders<TDoc>.IndexKeys;
            IndexKeysDefinition<TDoc> keys = null;
            if (indexFields.Length > 0)
            {
                keys = indexKeys.Descending(indexFields[0]);
            }
            for (var i = 1; i < indexFields.Length; i++)
            {
                var strIndex = indexFields[i];
                keys = keys.Descending(strIndex);
            }

            if (keys != null)
            {
                col.Indexes.CreateOne(keys, options);
            }

        }

        #endregion

        public void CreateCollectionIndex<TDoc>(string collectionName, string[] indexFields, CreateIndexOptions options = null)
        {
            CreateIndex(GetMongoCollection<TDoc>(collectionName), indexFields, options);
        }

        public void CreateCollection<TDoc>(string[] indexFields = null, CreateIndexOptions options = null)
        {
            string collectionName = typeof(TDoc).Name;
            CreateCollection<TDoc>(collectionName, indexFields, options);
        }

        public void CreateCollection<TDoc>(string collectionName, string[] indexFields = null, CreateIndexOptions options = null)
        {
            var mongoDatabase = GetMongoDatabase();
            mongoDatabase.CreateCollection(collectionName);
            CreateIndex(GetMongoCollection<TDoc>(collectionName), indexFields, options);
        }


        public List<TDoc> Find<TDoc>(Expression<Func<TDoc, bool>> filter, FindOptions options = null)
        {
            string collectionName = typeof(TDoc).Name;
            return Find<TDoc>(collectionName, filter, options);
        }

        public List<TDoc> Find<TDoc>(string collectionName, Expression<Func<TDoc, bool>> filter, FindOptions options = null)
        {
            var colleciton = GetMongoCollection<TDoc>(collectionName);
            return colleciton.Find(filter, options).ToList();
        }


        public List<TDoc> FindByPage<TDoc, TResult>(Expression<Func<TDoc, bool>> filter, Expression<Func<TDoc, TResult>> keySelector, int pageIndex, int pageSize, string sort, out int rsCount)
        {
            string collectionName = typeof(TDoc).Name;
            return FindByPage<TDoc, TResult>(collectionName, filter, keySelector, pageIndex, pageSize, sort, out rsCount);
        }

        public List<TDoc> FindByPage<TDoc, TResult>(string collectionName, Expression<Func<TDoc, bool>> filter, Expression<Func<TDoc, TResult>> keySelector, int pageIndex, int pageSize, string sort, out int rsCount)
        {
            var colleciton = GetMongoCollection<TDoc>(collectionName);
            rsCount = colleciton.AsQueryable().Where(filter).Count();

            int pageCount = rsCount / pageSize + ((rsCount % pageSize) > 0 ? 1 : 0);
            if (pageIndex > pageCount) pageIndex = pageCount;
            if (pageIndex <= 0) pageIndex = 1;

            List<SortDefinition<TDoc>> sortDefList = new List<SortDefinition<TDoc>>();
            if (sort != null)
            {
                var sortList = sort.Split(',');
                for (var i = 0; i < sortList.Length; i++)
                {
                    var sl = Regex.Replace(sortList[i].Trim(), @"\s+", " ").Split(' ');
                    if (sl.Length == 1 || (sl.Length >= 2 && sl[1].ToLower() == "asc"))
                    {
                        sortDefList.Add(Builders<TDoc>.Sort.Ascending(sl[0]));
                    }
                    else if (sl.Length >= 2 && sl[1].ToLower() == "desc")
                    {
                        sortDefList.Add(Builders<TDoc>.Sort.Descending(sl[0]));
                    }
                }
            }
            var sortDef = Builders<TDoc>.Sort.Combine(sortDefList);
            FindOptions options = null;
            //var result = colleciton.AsQueryable(new AggregateOptions { AllowDiskUse = true }).Where(filter).OrderByDescending(keySelector).Skip((pageIndex - 1) * pageSize).Take(pageSize);

            var result = colleciton.Find(filter, options).Sort(sortDef).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync().Result;
            return result.ToList();
        }

        public void Insert<TDoc>(TDoc doc, InsertOneOptions options = null)
        {
            string collectionName = typeof(TDoc).Name;
            Insert<TDoc>(collectionName, doc, options);
        }

        public void Insert<TDoc>(string collectionName, TDoc doc, InsertOneOptions options = null)
        {
            var colleciton = GetMongoCollection<TDoc>(collectionName);
            colleciton.InsertOne(doc, options);
        }


        public void InsertMany<TDoc>(IEnumerable<TDoc> docs, InsertManyOptions options = null)
        {
            string collectionName = typeof(TDoc).Name;
            InsertMany<TDoc>(collectionName, docs, options);
        }

        public void InsertMany<TDoc>(string collectionName, IEnumerable<TDoc> docs, InsertManyOptions options = null)
        {
            var colleciton = GetMongoCollection<TDoc>(collectionName);
            colleciton.InsertMany(docs, options);
        }

        public void Update<TDoc>(TDoc doc, Expression<Func<TDoc, bool>> filter, UpdateOptions options = null)
        {
            string collectionName = typeof(TDoc).Name;
            var colleciton = GetMongoCollection<TDoc>(collectionName);
            List<UpdateDefinition<TDoc>> updateList = BuildUpdateDefinition<TDoc>(doc, null);
            colleciton.UpdateOne(filter, Builders<TDoc>.Update.Combine(updateList), options);
        }

        public void Update<TDoc>(string collectionName, TDoc doc, Expression<Func<TDoc, bool>> filter, UpdateOptions options = null)
        {
            var colleciton = GetMongoCollection<TDoc>(collectionName);
            List<UpdateDefinition<TDoc>> updateList = BuildUpdateDefinition<TDoc>(doc, null);
            colleciton.UpdateOne(filter, Builders<TDoc>.Update.Combine(updateList), options);
        }


        public void Update<TDoc>(TDoc doc, Expression<Func<TDoc, bool>> filter, UpdateDefinition<TDoc> updateFields, UpdateOptions options = null)
        {
            string collectionName = typeof(TDoc).Name;
            Update<TDoc>(collectionName, doc, filter, updateFields, options);
        }

        public void Update<TDoc>(string collectionName, TDoc doc, Expression<Func<TDoc, bool>> filter, UpdateDefinition<TDoc> updateFields, UpdateOptions options = null)
        {
            var colleciton = GetMongoCollection<TDoc>(collectionName);
            colleciton.UpdateOne(filter, updateFields, options);
        }


        public void UpdateMany<TDoc>(TDoc doc, Expression<Func<TDoc, bool>> filter, UpdateOptions options = null)
        {
            string collectionName = typeof(TDoc).Name;
            UpdateMany<TDoc>(collectionName, doc, filter, options);
        }


        public void UpdateMany<TDoc>(string collectionName, TDoc doc, Expression<Func<TDoc, bool>> filter, UpdateOptions options = null)
        {
            var colleciton = GetMongoCollection<TDoc>(collectionName);
            List<UpdateDefinition<TDoc>> updateList = BuildUpdateDefinition<TDoc>(doc, null);
            colleciton.UpdateMany(filter, Builders<TDoc>.Update.Combine(updateList), options);
        }


        public void Delete<TDoc>(Expression<Func<TDoc, bool>> filter, DeleteOptions options = null)
        {
            string collectionName = typeof(TDoc).Name;
            Delete<TDoc>(collectionName, filter, options);
        }

        public void Delete<TDoc>(string collectionName, Expression<Func<TDoc, bool>> filter, DeleteOptions options = null)
        {
            var colleciton = GetMongoCollection<TDoc>(collectionName);
            colleciton.DeleteOne(filter, options);
        }


        public void DeleteMany<TDoc>(Expression<Func<TDoc, bool>> filter, DeleteOptions options = null)
        {
            string collectionName = typeof(TDoc).Name;
            DeleteMany<TDoc>(collectionName, filter, options);
        }


        public void DeleteMany<TDoc>(string collectionName, Expression<Func<TDoc, bool>> filter, DeleteOptions options = null)
        {
            var colleciton = GetMongoCollection<TDoc>(collectionName);
            colleciton.DeleteMany(filter, options);
        }

        public void ClearCollection<TDoc>(string collectionName)
        {
            var colleciton = GetMongoCollection<TDoc>(collectionName);
            var inddexs = colleciton.Indexes.List();
            List<IEnumerable<BsonDocument>> docIndexs = new List<IEnumerable<BsonDocument>>();
            while (inddexs.MoveNext())
            {
                docIndexs.Add(inddexs.Current);
            }
            var mongoDatabase = GetMongoDatabase();
            mongoDatabase.DropCollection(collectionName);

            if (!CollectionExists(mongoDatabase, collectionName))
            {
                CreateCollection<TDoc>(collectionName);
            }

            if (docIndexs.Count > 0)
            {
                colleciton = mongoDatabase.GetCollection<TDoc>(collectionName);
                foreach (var index in docIndexs)
                {
                    foreach (IndexKeysDefinition<TDoc> indexItem in index)
                    {
                        try
                        {
                            colleciton.Indexes.CreateOne(indexItem);
                        }
                        catch
                        { }
                    }
                }
            }

        }
        public List<T> Get<T>(string collectionName, Expression<Func<T, bool>> condition, int skip, int limit, string sort)
        {
            return Get(collectionName, new List<Expression<Func<T, bool>>> { condition }, skip, limit, sort);
        }
        public List<TDoc> Get<TDoc>(string collectionName, List<Expression<Func<TDoc, bool>>> conditions, int skip, int limit, string sort)
        {
            if (conditions == null || conditions.Count == 0)
            {
                conditions = new List<Expression<Func<TDoc, bool>>> { x => true };
            }
            var builder = Builders<TDoc>.Filter;
            var filter = builder.And(conditions.Select(x => builder.Where(x)));

            var ret = new List<TDoc>();
            try
            {
                List<SortDefinition<TDoc>> sortDefList = new List<SortDefinition<TDoc>>();
                if (sort != null)
                {
                    var sortList = sort.Split(',');
                    for (var i = 0; i < sortList.Length; i++)
                    {
                        var sl = Regex.Replace(sortList[i].Trim(), @"\s+", " ").Split(' ');
                        if (sl.Length == 1 || (sl.Length >= 2 && sl[1].ToLower() == "asc"))
                        {
                            sortDefList.Add(Builders<TDoc>.Sort.Ascending(sl[0]));
                        }
                        else if (sl.Length >= 2 && sl[1].ToLower() == "desc")
                        {
                            sortDefList.Add(Builders<TDoc>.Sort.Descending(sl[0]));
                        }
                    }
                }
                var mongoDatabase = GetMongoDatabase();
                var colleciton = mongoDatabase.GetCollection<TDoc>(collectionName);

                var sortDef = Builders<TDoc>.Sort.Combine(sortDefList);
                ret = Find(collectionName, filter).Sort(sortDef).Skip(skip).Limit(limit).ToListAsync().Result;
            }
            catch (Exception ex)
            {
                Logger.Error("Get is error", GetType(), ex);
            }
            return ret;
        }
        public IFindFluent<T, T> Find<T>(string collectionName, FilterDefinition<T> filter, FindOptions options = null)
        {
            var mongoDatabase = GetMongoDatabase();
            var colleciton = mongoDatabase.GetCollection<T>(collectionName);

            return colleciton.Find(filter, options);
        }
    }
}

 

 

　　希望能对各位朋友有所帮助。

using Hubert.Common.Method.Log;using MongoDB.Bson;using MongoDB.Driver;using System;using System.Collections;using System.Collections.Generic;using System.Linq;using System.Linq.Expressions;using System.Reflection;using System.Text;using System.Text.RegularExpressions;using System.Threading.Tasks;
namespace Hubert.Common.Method.Mongo{    public class MongoDBHelper    {        private readonly string connectionString = null;        private readonly string databaseName = null;        private IMongoDatabase database = null;        private readonly bool autoCreateDb = false;        private readonly bool autoCreateCollection = false;
        static MongoDBHelper()        {            BsonDefaults.GuidRepresentation = GuidRepresentation.Standard;        }
        public MongoDBHelper(string mongoConnStr, string dbName, bool autoCreateDb = false, bool autoCreateCollection = false)        {            this.connectionString = mongoConnStr;            this.databaseName = dbName;            this.autoCreateDb = autoCreateDb;            this.autoCreateCollection = autoCreateCollection;        }
        #region 私有方法
        private MongoClient CreateMongoClient()        {            return new MongoClient(connectionString);        }

        private MongoDB.Driver.IMongoDatabase GetMongoDatabase()        {            if (database == null)            {                var client = CreateMongoClient();                if (!DatabaseExists(client, databaseName) && !autoCreateDb)                {                    throw new KeyNotFoundException("此MongoDB名称不存在：" + databaseName);                }
                database = CreateMongoClient().GetDatabase(databaseName);            }
            return database;        }
        private bool DatabaseExists(MongoClient client, string dbName)        {            try            {                var dbNames = client.ListDatabases().ToList().Select(db => db.GetValue("name").AsString);                return dbNames.Contains(dbName);            }            catch //如果连接的账号不能枚举出所有DB会报错，则默认为true            {                return true;            }
        }
        private bool CollectionExists(IMongoDatabase database, string collectionName)        {            var options = new ListCollectionsOptions            {                Filter = Builders<BsonDocument>.Filter.Eq("name", collectionName)            };
            return database.ListCollections(options).ToEnumerable().Any();        }

        private MongoDB.Driver.IMongoCollection<TDoc> GetMongoCollection<TDoc>(string name, MongoCollectionSettings settings = null)        {            var mongoDatabase = GetMongoDatabase();
            if (!CollectionExists(mongoDatabase, name) && !autoCreateCollection)            {                throw new KeyNotFoundException("此Collection名称不存在：" + name);            }
            return mongoDatabase.GetCollection<TDoc>(name, settings);        }
        private List<UpdateDefinition<TDoc>> BuildUpdateDefinition<TDoc>(object doc, string parent)        {            var updateList = new List<UpdateDefinition<TDoc>>();            foreach (var property in typeof(TDoc).GetProperties(BindingFlags.Instance | BindingFlags.Public))            {                var key = parent == null ? property.Name : string.Format("{0}.{1}", parent, property.Name);                //非空的复杂类型                if ((property.PropertyType.IsClass || property.PropertyType.IsInterface) && property.PropertyType != typeof(string) && property.GetValue(doc) != null)                {                    if (typeof(IList).IsAssignableFrom(property.PropertyType))                    {                        #region 集合类型                        int i = 0;                        var subObj = property.GetValue(doc);                        foreach (var item in subObj as IList)                        {                            if (item.GetType().IsClass || item.GetType().IsInterface)                            {                                updateList.AddRange(BuildUpdateDefinition<TDoc>(doc, string.Format("{0}.{1}", key, i)));                            }                            else                            {                                updateList.Add(Builders<TDoc>.Update.Set(string.Format("{0}.{1}", key, i), item));                            }                            i++;                        }                        #endregion                    }                    else                    {                        #region 实体类型                        //复杂类型，导航属性，类对象和集合对象                         var subObj = property.GetValue(doc);                        foreach (var sub in property.PropertyType.GetProperties(BindingFlags.Instance | BindingFlags.Public))                        {                            updateList.Add(Builders<TDoc>.Update.Set(string.Format("{0}.{1}", key, sub.Name), sub.GetValue(subObj)));                        }                        #endregion                    }                }                else //简单类型                {                    updateList.Add(Builders<TDoc>.Update.Set(key, property.GetValue(doc)));                }            }
            return updateList;        }

        private void CreateIndex<TDoc>(IMongoCollection<TDoc> col, string[] indexFields, CreateIndexOptions options = null)        {            if (indexFields == null)            {                return;            }            var indexKeys = Builders<TDoc>.IndexKeys;            IndexKeysDefinition<TDoc> keys = null;            if (indexFields.Length > 0)            {                keys = indexKeys.Descending(indexFields[0]);            }            for (var i = 1; i < indexFields.Length; i++)            {                var strIndex = indexFields[i];                keys = keys.Descending(strIndex);            }
            if (keys != null)            {                col.Indexes.CreateOne(keys, options);            }
        }
        #endregion
        public void CreateCollectionIndex<TDoc>(string collectionName, string[] indexFields, CreateIndexOptions options = null)        {            CreateIndex(GetMongoCollection<TDoc>(collectionName), indexFields, options);        }
        public void CreateCollection<TDoc>(string[] indexFields = null, CreateIndexOptions options = null)        {            string collectionName = typeof(TDoc).Name;            CreateCollection<TDoc>(collectionName, indexFields, options);        }
        public void CreateCollection<TDoc>(string collectionName, string[] indexFields = null, CreateIndexOptions options = null)        {            var mongoDatabase = GetMongoDatabase();            mongoDatabase.CreateCollection(collectionName);            CreateIndex(GetMongoCollection<TDoc>(collectionName), indexFields, options);        }

        public List<TDoc> Find<TDoc>(Expression<Func<TDoc, bool>> filter, FindOptions options = null)        {            string collectionName = typeof(TDoc).Name;            return Find<TDoc>(collectionName, filter, options);        }
        public List<TDoc> Find<TDoc>(string collectionName, Expression<Func<TDoc, bool>> filter, FindOptions options = null)        {            var colleciton = GetMongoCollection<TDoc>(collectionName);            return colleciton.Find(filter, options).ToList();        }

        public List<TDoc> FindByPage<TDoc, TResult>(Expression<Func<TDoc, bool>> filter, Expression<Func<TDoc, TResult>> keySelector, int pageIndex, int pageSize, string sort, out int rsCount)        {            string collectionName = typeof(TDoc).Name;            return FindByPage<TDoc, TResult>(collectionName, filter, keySelector, pageIndex, pageSize, sort, out rsCount);        }
        public List<TDoc> FindByPage<TDoc, TResult>(string collectionName, Expression<Func<TDoc, bool>> filter, Expression<Func<TDoc, TResult>> keySelector, int pageIndex, int pageSize, string sort, out int rsCount)        {            var colleciton = GetMongoCollection<TDoc>(collectionName);            rsCount = colleciton.AsQueryable().Where(filter).Count();
            int pageCount = rsCount / pageSize + ((rsCount % pageSize) > 0 ? 1 : 0);            if (pageIndex > pageCount) pageIndex = pageCount;            if (pageIndex <= 0) pageIndex = 1;
            List<SortDefinition<TDoc>> sortDefList = new List<SortDefinition<TDoc>>();            if (sort != null)            {                var sortList = sort.Split(',');                for (var i = 0; i < sortList.Length; i++)                {                    var sl = Regex.Replace(sortList[i].Trim(), @"\s+", " ").Split(' ');                    if (sl.Length == 1 || (sl.Length >= 2 && sl[1].ToLower() == "asc"))                    {                        sortDefList.Add(Builders<TDoc>.Sort.Ascending(sl[0]));                    }                    else if (sl.Length >= 2 && sl[1].ToLower() == "desc")                    {                        sortDefList.Add(Builders<TDoc>.Sort.Descending(sl[0]));                    }                }            }            var sortDef = Builders<TDoc>.Sort.Combine(sortDefList);            FindOptions options = null;            //var result = colleciton.AsQueryable(new AggregateOptions { AllowDiskUse = true }).Where(filter).OrderByDescending(keySelector).Skip((pageIndex - 1) * pageSize).Take(pageSize);
            var result = colleciton.Find(filter, options).Sort(sortDef).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync().Result;            return result.ToList();        }
        public void Insert<TDoc>(TDoc doc, InsertOneOptions options = null)        {            string collectionName = typeof(TDoc).Name;            Insert<TDoc>(collectionName, doc, options);        }
        public void Insert<TDoc>(string collectionName, TDoc doc, InsertOneOptions options = null)        {            var colleciton = GetMongoCollection<TDoc>(collectionName);            colleciton.InsertOne(doc, options);        }

        public void InsertMany<TDoc>(IEnumerable<TDoc> docs, InsertManyOptions options = null)        {            string collectionName = typeof(TDoc).Name;            InsertMany<TDoc>(collectionName, docs, options);        }
        public void InsertMany<TDoc>(string collectionName, IEnumerable<TDoc> docs, InsertManyOptions options = null)        {            var colleciton = GetMongoCollection<TDoc>(collectionName);            colleciton.InsertMany(docs, options);        }
        public void Update<TDoc>(TDoc doc, Expression<Func<TDoc, bool>> filter, UpdateOptions options = null)        {            string collectionName = typeof(TDoc).Name;            var colleciton = GetMongoCollection<TDoc>(collectionName);            List<UpdateDefinition<TDoc>> updateList = BuildUpdateDefinition<TDoc>(doc, null);            colleciton.UpdateOne(filter, Builders<TDoc>.Update.Combine(updateList), options);        }
        public void Update<TDoc>(string collectionName, TDoc doc, Expression<Func<TDoc, bool>> filter, UpdateOptions options = null)        {            var colleciton = GetMongoCollection<TDoc>(collectionName);            List<UpdateDefinition<TDoc>> updateList = BuildUpdateDefinition<TDoc>(doc, null);            colleciton.UpdateOne(filter, Builders<TDoc>.Update.Combine(updateList), options);        }

        public void Update<TDoc>(TDoc doc, Expression<Func<TDoc, bool>> filter, UpdateDefinition<TDoc> updateFields, UpdateOptions options = null)        {            string collectionName = typeof(TDoc).Name;            Update<TDoc>(collectionName, doc, filter, updateFields, options);        }
        public void Update<TDoc>(string collectionName, TDoc doc, Expression<Func<TDoc, bool>> filter, UpdateDefinition<TDoc> updateFields, UpdateOptions options = null)        {            var colleciton = GetMongoCollection<TDoc>(collectionName);            colleciton.UpdateOne(filter, updateFields, options);        }

        public void UpdateMany<TDoc>(TDoc doc, Expression<Func<TDoc, bool>> filter, UpdateOptions options = null)        {            string collectionName = typeof(TDoc).Name;            UpdateMany<TDoc>(collectionName, doc, filter, options);        }

        public void UpdateMany<TDoc>(string collectionName, TDoc doc, Expression<Func<TDoc, bool>> filter, UpdateOptions options = null)        {            var colleciton = GetMongoCollection<TDoc>(collectionName);            List<UpdateDefinition<TDoc>> updateList = BuildUpdateDefinition<TDoc>(doc, null);            colleciton.UpdateMany(filter, Builders<TDoc>.Update.Combine(updateList), options);        }

        public void Delete<TDoc>(Expression<Func<TDoc, bool>> filter, DeleteOptions options = null)        {            string collectionName = typeof(TDoc).Name;            Delete<TDoc>(collectionName, filter, options);        }
        public void Delete<TDoc>(string collectionName, Expression<Func<TDoc, bool>> filter, DeleteOptions options = null)        {            var colleciton = GetMongoCollection<TDoc>(collectionName);            colleciton.DeleteOne(filter, options);        }

        public void DeleteMany<TDoc>(Expression<Func<TDoc, bool>> filter, DeleteOptions options = null)        {            string collectionName = typeof(TDoc).Name;            DeleteMany<TDoc>(collectionName, filter, options);        }

        public void DeleteMany<TDoc>(string collectionName, Expression<Func<TDoc, bool>> filter, DeleteOptions options = null)        {            var colleciton = GetMongoCollection<TDoc>(collectionName);            colleciton.DeleteMany(filter, options);        }
        public void ClearCollection<TDoc>(string collectionName)        {            var colleciton = GetMongoCollection<TDoc>(collectionName);            var inddexs = colleciton.Indexes.List();            List<IEnumerable<BsonDocument>> docIndexs = new List<IEnumerable<BsonDocument>>();            while (inddexs.MoveNext())            {                docIndexs.Add(inddexs.Current);            }            var mongoDatabase = GetMongoDatabase();            mongoDatabase.DropCollection(collectionName);
            if (!CollectionExists(mongoDatabase, collectionName))            {                CreateCollection<TDoc>(collectionName);            }
            if (docIndexs.Count > 0)            {                colleciton = mongoDatabase.GetCollection<TDoc>(collectionName);                foreach (var index in docIndexs)                {                    foreach (IndexKeysDefinition<TDoc> indexItem in index)                    {                        try                        {                            colleciton.Indexes.CreateOne(indexItem);                        }                        catch                        { }                    }                }            }
        }        public List<T> Get<T>(string collectionName, Expression<Func<T, bool>> condition, int skip, int limit, string sort)        {            return Get(collectionName, new List<Expression<Func<T, bool>>> { condition }, skip, limit, sort);        }        public List<TDoc> Get<TDoc>(string collectionName, List<Expression<Func<TDoc, bool>>> conditions, int skip, int limit, string sort)        {            if (conditions == null || conditions.Count == 0)            {                conditions = new List<Expression<Func<TDoc, bool>>> { x => true };            }            var builder = Builders<TDoc>.Filter;            var filter = builder.And(conditions.Select(x => builder.Where(x)));
            var ret = new List<TDoc>();            try            {                List<SortDefinition<TDoc>> sortDefList = new List<SortDefinition<TDoc>>();                if (sort != null)                {                    var sortList = sort.Split(',');                    for (var i = 0; i < sortList.Length; i++)                    {                        var sl = Regex.Replace(sortList[i].Trim(), @"\s+", " ").Split(' ');                        if (sl.Length == 1 || (sl.Length >= 2 && sl[1].ToLower() == "asc"))                        {                            sortDefList.Add(Builders<TDoc>.Sort.Ascending(sl[0]));                        }                        else if (sl.Length >= 2 && sl[1].ToLower() == "desc")                        {                            sortDefList.Add(Builders<TDoc>.Sort.Descending(sl[0]));                        }                    }                }                var mongoDatabase = GetMongoDatabase();                var colleciton = mongoDatabase.GetCollection<TDoc>(collectionName);
                var sortDef = Builders<TDoc>.Sort.Combine(sortDefList);                ret = Find(collectionName, filter).Sort(sortDef).Skip(skip).Limit(limit).ToListAsync().Result;            }            catch (Exception ex)            {                Logger.Error("Get is error", GetType(), ex);            }            return ret;        }        public IFindFluent<T, T> Find<T>(string collectionName, FilterDefinition<T> filter, FindOptions options = null)        {            var mongoDatabase = GetMongoDatabase();            var colleciton = mongoDatabase.GetCollection<T>(collectionName);
            return colleciton.Find(filter, options);        }    }}