Mongo帮助类（DotNet版本）

最新推荐文章于 2021-03-30 13:04:57 发布
最新推荐文章于 2021-03-30 13:04:57 发布
阅读量224 收藏
点赞数
文章标签： 数据库 c#
原文链接：http://www.cnblogs.com/HubertBiyo/p/9285225.html
版权

该帮助类是针对 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);        }    }}

 

转载于:https://www.cnblogs.com/HubertBiyo/p/9285225.html

weixin_30326741
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C#/.Net操作MongoDBHelper类
weixin_30484739的博客
07-03 677
先 NuGet两个程序集 1:MongoDB.Driver、 2:MongoDB.Bson namespace ConsoleApp1{ /// <summary> /// MongoDb帮助类 /// </summary> /// <summary> /// MongoDb帮助类 /// </summary>...
Mongo2Go：Mongo2Go-用于集成测试的MongoDB（.NET Core）
02-04
Linux构建（Ubuntu Trusty） Windows内部版本（Windows Server 2016） Mongo2Go是最新的MongoDB二进制文件的托管包装。 它针对.NET Standard 1.6 （对于旧版环境为.NET 4.6 ），并且可与Windows，Linux和macOS一起...
MongoDB 工具助手类（.NET）
weixin_33843947的博客
03-24 107
在开发过程中，需要用到MongoDB，本身MongoDB自己对类的封装就特别好了。为了更加符合我们平时的开发使用，我现在进行了一个简单的封装操作。 连接数据库类：MongoDBContext using System; using System.Collections.Generic; using System.Linq; using System.Text; using Syst...
MongoDbHelper 帮助类(上)
weixin_30706507的博客
11-13 65
在网上搜索mongodbHelper的帮助类时，出来的东西都大同小异，再此摘录一下。 这些代码也看了一遍，总是感觉重复的代码太多了，在后续的文章中又整合了一下，请看下篇，欢迎指正！ 1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.T...
asp.net core 集成 MongoDB 链接数据库+helper帮助类+增删改查
代码笔记
03-17 1086
原文：https://www.cnblogs.com/guolianyu/p/9775776.html roboo 3T教程：https://www.cnblogs.com/tugenhua0707/p/9250673.html
dotnet core链接mongodb代码实例
12-23
`MongoDB.Bson`包含了用于序列化和反序列化BSON（Binary JSON）数据的类，而`MongoDB.Driver`则是.NET Core与MongoDB通信的核心库。因此，在C#代码文件顶部，我们需要包含以下两行： ```csharp using MongoDB.Bson;...
mongodb-query-helper-for-dotnet
07-13
） 将LINQ 查询转换为在 MongoDB 中运行的JavaScript代码考虑这个 LINQ 查询： var query = from p in mongo.People where p.Age > 20 && p.Name.Length >= 2 orderby p.Age descending select p;打电话 Console....
MongoRepository：官方MongoDB C＃驱动程序之上的存储库抽象层
01-28
// The Entity base-class is provided by MongoRepository // for all entities you want to use in MongoDb public class Customer : Entity { public string FirstName { get ; set ; } public string ...
NoSQLBooster4MongoCleaner：NoSQLBooster4Mongo Cleaner用于删除本地任何安装信息
02-03
这款工具的主要目的是帮助用户清理本地环境中关于NoSQLBooster4Mongo的安装信息，确保数据库管理系统的干净整洁。 MongoDB是一种流行的NoSQL数据库，它以其非关系型数据模型、高可扩展性和高性能而受到青睐。然而，...
.net平台（C#）MongoDB最新版操作类
06-12
.net平台（C#）MongoDB最新版操作类 MongoDB操作类源码包括添加、修改、删除和查询（包括分页）等同步及异步操作类完整的代码。 本项目是以最新版的MVC结合MongoDB呈现，对MongoDB有兴趣的朋友很有参考价值。 可以直接拿到自己的项目直接开发，可以少走弯路。
基于c#的Mongodb帮助类源码 含一个分页效率测试
05-06
基于c#的Mongodb数据库的增删改查的帮助类，并且里面有一个Skip-Limit分页与Where-Limit分页的效率对比
[总结].net操作MongoDb通用基础类1：
weixin_34360651的博客
02-06 72
public class MongoDBHelper { //定义Mongo服务 private MongoServer mongo = null; //获取databaseName对应的数据库，不存在则自动创建 private MongoDatabase mongoDatabase;...
【MongoDB学习-在.NET中的简单操作类】
weixin_30439131的博客
10-20 93
1.新建MVC项目， 管理NuGet包，进入下载MongDB.net库文件 2.新增项目DAL数据访问层，引用以下库文件： 3.C# 访问MongoDB通用方法类： [csharp]view plaincopy print? usingMongoDB.Driver; usingSystem; namespaceD...
mongodb帮助类
wsh_mar的专栏
07-20 1277
using System; 02.using System.Collections.Generic; 03.using System.Linq; 04.using System.Text; 05.using MongoDB.Driver; 06.using MongoDB.Bson; 07.namespace WindowsFormsApplication1
C# mongodb帮助类
dz45693的专栏
08-09 2655
这是在C#连接MongoDB的帮助类，所使用的驱动是在Vs2015的Nuget管理器中下载的mongodb驱动。 下载第一个，会自动下载下面的两个，不要删除。   在配置文件中配置连接字符串connStr和数据库名称dbName： &lt;appSettings&gt; &lt;add key="webpages:Version" value="3.0.0.0"/&gt; ...
C# Linq详解
热门推荐
月夜何干
03-30 1万+
LINQ 查询简介TOC LINQ 通过提供处理各种数据源和数据格式的数据的一致模型，简化了这一情况。 在 LINQ 查询中，始终会用到对象。 可以使用相同的基本编码模式来查询和转换 XML 文档、SQL 数据库、ADO.NET 数据集、.NET 集合中的数据以及 LINQ 提供程序可用的任何其他格式的数据。 查询操作的三个部分 所有 LINQ 查询操作都由以下三个不同的操作组成： 获取数据源 创建查询 执行查询。 下面的示例演示如何用源代码表示查询操作的三个部分。 为方便起见，此示例将一个整数数组用作数
Serilog记录MongoDB日志报错：requires the binary sub type to be UuidLegacy, not UuidStandard
diaohunang4905的博客
07-28 212
Serilog Serilog是.NET开源结构化日志类库 开源地址：https://github.com/serilog 官网：https://serilog.net/ Serilog能做什么： 记录代码中的BUG和错误 更快的找到生产环境中的问题 深入的了解系统运行表现 想对Serilog多点了解，请查阅[译]Serilog Tutorial，翻译的很棒。 重现Error出现的场...
适用于app.config与web.config的ConfigUtil读写工具类 基于MongoDb官方C#驱动封装MongoDbCsharpHelper类（CRUD类） 基于ASP.NE...
04-21 550
适用于app.config与web.config的ConfigUtil读写工具类 之前文章：《两种读写配置文件的方案(app.config与web.config通用)》，现在重新整理一个更完善的版本，增加批量读写以及指定配置文件路径，代码如下： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15...
实现一个MONGO操作类
最新发布
08-28
### 回答1： 好的，下面是实现 MongoDB 操作的类的一个示例： ``` import pymongo class MongoOperator: def __init__(self, host, port, username, password, db_name): """ 初始化连接信息 """ self.host = host self.port = port self.username = username self.password = password self.db_name = db_name self.client = None self.db = None def connect(self): """ 连接到 MongoDB 服务器 """ self.client = pymongo.MongoClient(self.host, self.port) self.db = self.client[self.db_name] # 如果设置了用户名和密码，则需要进行身份认证 if self.username and self.password: self.db.authenticate(self.username, self.password) def close(self): """ 关闭与 MongoDB 服务器的连接 """ self.client.close() def insert_one(self, collection_name, doc): """ 向集合中插入一条文档 """ collection = self.db[collection_name] result = collection.insert_one(doc) return result.inserted_id def insert_many(self, collection_name, docs): """ 向集合中插入多条文档 """ collection = self.db[collection_name] result = collection.insert_many(docs) return result.inserted_ids def find_one(self, collection_name, filter, projection=None): """ 从集合中查询一条文档 """ collection = self.db[collection_name] if projection: return collection.find_one(filter, projection) else: return collection.find_one(filter) def find(self, collection_name, filter, projection=None): """ 从集合中查询多条文档 """ collection = self.db[collection_name] if projection: return collection.find(filter, projection) else: return collection.find(filter) def update_one(self, collection_name, filter, update): """ 更新集合中的一条文档 """ collection = self.db[collection_name] result = collection.update_one(filter, update) ### 回答2： 实现一个Mongo操作类可以辅助我们更方便地对MongoDB进行数据操作。首先，我们需要引入MongoDB官方提供的mongoDB Driver for Node.js。然后，我们可以定义一个Mongo类，该类包含连接MongoDB并操作数据的一些方法。 ``` const { MongoClient } = require('mongodb'); class Mongo { constructor(url, dbName) { this.url = url; this.dbName = dbName; this.client = new MongoClient(url, { useNewUrlParser: true, useUnifiedTopology: true }); this.db = null; } async connect() { try { await this.client.connect(); this.db = this.client.db(this.dbName); console.log('Connected to MongoDB successfully'); } catch (error) { console.error('Failed to connect to MongoDB', error); } } async insertOne(collectionName, document) { try { await this.db.collection(collectionName).insertOne(document); console.log('Document inserted successfully'); } catch (error) { console.error('Failed to insert document', error); } } async findOne(collectionName, query) { try { const result = await this.db.collection(collectionName).findOne(query); console.log('Found document:', result); return result; } catch (error) { console.error('Failed to find document', error); return null; } } // 其他操作方法，如updateOne、deleteOne等等可以类似地实现 async disconnect() { try { await this.client.close(); console.log('Disconnected from MongoDB'); } catch (error) { console.error('Failed to close MongoDB connection', error); } } } module.exports = Mongo; ``` 以上是一个简单的Mongo操作类的实现，通过这个类我们可以连接MongoDB数据库、插入文档、查询文档等操作。我们在构造函数中传入MongoDB的URL和数据库名称，然后可以调用`connect()`方法来连接数据库，操作完数据后可以调用`disconnect()`方法来断开数据库连接。 ### 回答3： 实现一个 MONGO 操作类可以通过以下步骤进行： 首先，需要引入 MongoDB 官方提供的驱动程序，可以使用 Pymongo。在 Python 中使用 Pymongo 操作 MongoDB 数据库非常方便。 然后，可以创建一个 MONGO 操作类，该类可以包含以下方法： 1. 连接数据库方法：可以在该方法中使用 Pymongo 提供的 MongoClient 连接到 MongoDB 数据库。可以传入连接参数，如数据库的 IP 地址和端口号。 2. 选择数据库方法：可以在该方法中选择要操作的数据库。可以利用连接数据库方法返回的 MongoClient 对象的属性来选择数据库。 3. 选择集合方法：可以在该方法中选择要操作的集合。可以使用 MongoClient 对象的属性选择集合。 4. 插入文档方法：可以在该方法中插入文档到指定的集合中。可以使用集合对象的 insert_one 或 insert_many 方法来插入文档。 5. 查询文档方法：可以在该方法中查询指定条件的文档。可以使用集合对象的 find 方法来查询文档。 6. 更新文档方法：可以在该方法中更新符合条件的文档。可以使用集合对象的 update_one 或 update_many 方法来更新文档。 7. 删除文档方法：可以在该方法中删除符合条件的文档。可以使用集合对象的 delete_one 或 delete_many 方法来删除文档。 8. 断开数据库方法：可以在该方法中断开与 MongoDB 数据库的连接。可以使用 MongoClient 对象的 close 方法来断开连接。 通过以上步骤，就可以实现一个 MONGO 操作类，该类可以用于连接、选择数据库、选择集合、插入文档、查询文档、更新文档和删除文档等操作。利用该类，可以更加方便地对 MongoDB 数据库进行操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值