.NET Core 操作 MongoDB 封裝類

引用包：

MongoDB.Driver（2.10.4）

    /// <summary>
    /// MongoDB連接信息
    /// </summary>
    public class MongoDBHost
    {
        /// <summary>
        /// 連接字符串
        /// </summary>
        public string ConnectionString { get; set; }

        /// <summary>
        /// 庫
        /// </summary>
        public string DataBase { get; set; }

        /// <summary>
        /// 集合(表)
        /// </summary>
        public string Collection { get; set; }

    }

    public class MongoDBClient<T> where T : class
    {
        private MongoDBClient()
        {
        }

        /// <summary>
        /// 獲取集合實例
        /// </summary>
        /// <param name="host">連接字符串，庫，集合</param>
        /// <returns></returns>
        public static IMongoCollection<T> GetCollectionInstance(MongoDBHost host)
        {
            MongoClient client = new MongoClient(host.ConnectionString);
            var dataBase = client.GetDatabase(host.DataBase);
            return dataBase.GetCollection<T>(host.Collection);
        }
    }

    public class MongoDBHelper<T> where T : class, new()
    {
        private MongoDBHelper()
        {
        }

        /// <summary>
        /// 添加一條數據
        /// </summary>
        /// <param name="t">添加的實體</param>
        /// <param name="host">mongodb連接信息</param>
        /// <returns></returns>
        public static bool Add(MongoDBHost host, T t)
        {
            try
            {
                var client = MongoDBClient<T>.GetCollectionInstance(host);
                client.InsertOne(t);
                return true;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 異步添加一條數據
        /// </summary>
        /// <param name="t">添加的實體</param>
        /// <param name="host">mongodb連接信息</param>
        /// <returns></returns>
        public static async Task<bool> AddAsync(MongoDBHost host, T t)
        {
            try
            {
                var client = MongoDBClient<T>.GetCollectionInstance(host);
                await client.InsertOneAsync(t);
                return true;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 批量插入
        /// </summary>
        /// <param name="host">mongodb連接信息</param>
        /// <param name="t">實體集合</param>
        /// <returns></returns>
        public static bool AddList(MongoDBHost host, List<T> t)
        {
            try
            {
                var client = MongoDBClient<T>.GetCollectionInstance(host);
                client.InsertMany(t);
                return true;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 異步批量插入
        /// </summary>
        /// <param name="host">mongodb連接信息</param>
        /// <param name="t">實體集合</param>
        /// <returns></returns>
        public static async Task<bool> AddListAsync(MongoDBHost host, List<T> t)
        {
            try
            {
                var client = MongoDBClient<T>.GetCollectionInstance(host);
                await client.InsertManyAsync(t);
                return true;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 修改一條數據
        /// </summary>
        /// <param name="t">添加的實體</param>
        /// <param name="host">mongodb連接信息</param>
        /// <returns></returns>
        public static UpdateResult Update(MongoDBHost host, T t, string id)
        {
            try
            {
                var client = MongoDBClient<T>.GetCollectionInstance(host);
                //修改條件
                FilterDefinition<T> filter = Builders<T>.Filter.Eq("_id", new ObjectId(id));
                //要修改的字段
                var list = new List<UpdateDefinition<T>>();
                foreach (var item in t.GetType().GetProperties())
                {
                    if (item.Name.ToLower() == "id") continue;
                    list.Add(Builders<T>.Update.Set(item.Name, item.GetValue(t)));
                }
                var updatefilter = Builders<T>.Update.Combine(list);
                return client.UpdateOne(filter, updatefilter);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 異步修改一條數據
        /// </summary>
        /// <param name="t">添加的實體</param>
        /// <param name="host">mongodb連接信息</param>
        /// <returns></returns>
        public static async Task<UpdateResult> UpdateAsync(MongoDBHost host, T t, string id)
        {
            try
            {
                var client = MongoDBClient<T>.GetCollectionInstance(host);
                //修改條件
                FilterDefinition<T> filter = Builders<T>.Filter.Eq("_id", new ObjectId(id));
                //要修改的字段
                var list = new List<UpdateDefinition<T>>();
                foreach (var item in t.GetType().GetProperties())
                {
                    if (item.Name.ToLower() == "id") continue;
                    list.Add(Builders<T>.Update.Set(item.Name, item.GetValue(t)));
                }
                var updatefilter = Builders<T>.Update.Combine(list);
                return await client.UpdateOneAsync(filter, updatefilter);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 批量修改數據
        /// </summary>
        /// <param name="dic">要修改的字段</param>
        /// <param name="host">mongodb連接信息</param>
        /// <param name="filter">修改條件</param>
        /// <returns></returns>
        public static UpdateResult UpdateManay(MongoDBHost host, Dictionary<string, string> dic, FilterDefinition<T> filter)
        {
            try
            {
                var client = MongoDBClient<T>.GetCollectionInstance(host);
                T t = new T();
                //要修改的字段
                var list = new List<UpdateDefinition<T>>();
                foreach (var item in t.GetType().GetProperties())
                {
                    if (!dic.ContainsKey(item.Name)) continue;
                    var value = dic[item.Name];
                    list.Add(Builders<T>.Update.Set(item.Name, value));
                }
                var updatefilter = Builders<T>.Update.Combine(list);
                return client.UpdateMany(filter, updatefilter);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 異步批量修改數據
        /// </summary>
        /// <param name="dic">要修改的字段</param>
        /// <param name="host">mongodb連接信息</param>
        /// <param name="filter">修改條件</param>
        /// <returns></returns>
        public static async Task<UpdateResult> UpdateManayAsync(MongoDBHost host, Dictionary<string, string> dic, FilterDefinition<T> filter)
        {
            try
            {
                var client = MongoDBClient<T>.GetCollectionInstance(host);
                T t = new T();
                //要修改的字段
                var list = new List<UpdateDefinition<T>>();
                foreach (var item in t.GetType().GetProperties())
                {
                    if (!dic.ContainsKey(item.Name)) continue;
                    var value = dic[item.Name];
                    list.Add(Builders<T>.Update.Set(item.Name, value));
                }
                var updatefilter = Builders<T>.Update.Combine(list);
                return await client.UpdateManyAsync(filter, updatefilter);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 刪除一條數據
        /// </summary>
        /// <param name="host">mongodb連接信息</param>
        /// <param name="id">objectId</param>
        /// <returns></returns>
        public static DeleteResult Delete(MongoDBHost host, string id)
        {
            try
            {
                var client = MongoDBClient<T>.GetCollectionInstance(host);
                FilterDefinition<T> filter = Builders<T>.Filter.Eq("_id", new ObjectId(id));
                return client.DeleteOne(filter);
            }
            catch (Exception ex)
            {
                throw ex;
            }

        }

        /// <summary>
        /// 異步刪除一條數據
        /// </summary>
        /// <param name="host">mongodb連接信息</param>
        /// <param name="id">objectId</param>
        /// <returns></returns>
        public static async Task<DeleteResult> DeleteAsync(MongoDBHost host, string id)
        {
            try
            {
                var client = MongoDBClient<T>.GetCollectionInstance(host);
                //修改條件
                FilterDefinition<T> filter = Builders<T>.Filter.Eq("_id", new ObjectId(id));
                return await client.DeleteOneAsync(filter);
            }
            catch (Exception ex)
            {
                throw ex;
            }

        }

        /// <summary>
        /// 刪除一條數據
        /// </summary>
        /// <param name="host">mongodb連接信息</param>
        /// <param name="filter">刪除的條件</param>
        /// <returns></returns>
        public static DeleteResult DeleteMany(MongoDBHost host, FilterDefinition<T> filter)
        {
            try
            {
                var client = MongoDBClient<T>.GetCollectionInstance(host);
                return client.DeleteMany(filter);
            }
            catch (Exception ex)
            {
                throw ex;
            }

        }

        /// <summary>
        /// 異步刪除多條數據
        /// </summary>
        /// <param name="host">mongodb連接信息</param>
        /// <param name="filter">刪除的條件</param>
        /// <returns></returns>
        public static async Task<DeleteResult> DeleteManyAsync(MongoDBHost host, FilterDefinition<T> filter)
        {
            try
            {
                var client = MongoDBClient<T>.GetCollectionInstance(host);
                return await client.DeleteManyAsync(filter);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 根據id查詢一條數據
        /// </summary>
        /// <param name="host">mongodb連接信息</param>
        /// <param name="id">objectid</param>
        /// <param name="field">要查詢的字段，不寫時查詢全部</param>
        /// <returns></returns>
        public static T Get(MongoDBHost host, string id, string[] field = null)
        {
            try
            {
                var client = MongoDBClient<T>.GetCollectionInstance(host);
                FilterDefinition<T> filter = Builders<T>.Filter.Eq("_id", new ObjectId(id));
                //不指定查詢字段
                if (field == null || field.Length == 0)
                {
                    return client.Find(filter).FirstOrDefault<T>();
                }

                //指定查詢字段
                var fieldList = new List<ProjectionDefinition<T>>();
                for (int i = 0; i < field.Length; i++)
                {
                    fieldList.Add(Builders<T>.Projection.Include(field[i].ToString()));
                }
                var projection = Builders<T>.Projection.Combine(fieldList);
                fieldList?.Clear();
                return client.Find(filter).Project<T>(projection).FirstOrDefault<T>();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 異步根據id查詢一條數據
        /// </summary>
        /// <param name="host">mongodb連接信息</param>
        /// <param name="id">objectid</param>
        /// <returns></returns>
        public static async Task<T> GetAsync(MongoDBHost host, string id, string[] field = null)
        {
            try
            {
                var client = MongoDBClient<T>.GetCollectionInstance(host);
                FilterDefinition<T> filter = Builders<T>.Filter.Eq("_id", new ObjectId(id));
                //不指定查詢字段
                if (field == null || field.Length == 0)
                {
                    return await client.Find(filter).FirstOrDefaultAsync();
                }

                //指定查詢字段
                var fieldList = new List<ProjectionDefinition<T>>();
                for (int i = 0; i < field.Length; i++)
                {
                    fieldList.Add(Builders<T>.Projection.Include(field[i].ToString()));
                }
                var projection = Builders<T>.Projection.Combine(fieldList);
                fieldList?.Clear();
                return await client.Find(filter).Project<T>(projection).FirstOrDefaultAsync();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 查詢集合
        /// </summary>
        /// <param name="host">mongodb連接信息</param>
        /// <param name="filter">查詢條件</param>
        /// <param name="field">要查詢的字段,不寫時查詢全部</param>
        /// <param name="sort">要排序的字段</param>
        /// <returns></returns>
        public static List<T> GetList(MongoDBHost host, FilterDefinition<T> filter, string[] field = null, SortDefinition<T> sort = null)
        {
            try
            {
                var client = MongoDBClient<T>.GetCollectionInstance(host);
                //不指定查詢字段
                if (field == null || field.Length == 0)
                {
                    if (sort == null) return client.Find(filter).ToList();
                    //進行排序
                    return client.Find(filter).Sort(sort).ToList();
                }

                //指定查詢字段
                var fieldList = new List<ProjectionDefinition<T>>();
                for (int i = 0; i < field.Length; i++)
                {
                    fieldList.Add(Builders<T>.Projection.Include(field[i].ToString()));
                }
                var projection = Builders<T>.Projection.Combine(fieldList);
                fieldList?.Clear();
                if (sort == null) return client.Find(filter).Project<T>(projection).ToList();
                //排序查詢
                return client.Find(filter).Sort(sort).Project<T>(projection).ToList();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 異步查詢集合
        /// </summary>
        /// <param name="host">mongodb連接信息</param>
        /// <param name="filter">查詢條件</param>
        /// <param name="field">要查詢的字段,不寫時查詢全部</param>
        /// <param name="sort">要排序的字段</param>
        /// <returns></returns>
        public static async Task<List<T>> GetListAsync(MongoDBHost host, FilterDefinition<T> filter, string[] field = null, SortDefinition<T> sort = null)
        {
            try
            {
                var client = MongoDBClient<T>.GetCollectionInstance(host);
                //不指定查詢字段
                if (field == null || field.Length == 0)
                {
                    if (sort == null) return await client.Find(filter).ToListAsync();
                    return await client.Find(filter).Sort(sort).ToListAsync();
                }

                //指定查詢字段
                var fieldList = new List<ProjectionDefinition<T>>();
                for (int i = 0; i < field.Length; i++)
                {
                    fieldList.Add(Builders<T>.Projection.Include(field[i].ToString()));
                }
                var projection = Builders<T>.Projection.Combine(fieldList);
                fieldList?.Clear();
                if (sort == null) return await client.Find(filter).Project<T>(projection).ToListAsync();
                //排序查詢
                return await client.Find(filter).Sort(sort).Project<T>(projection).ToListAsync();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 分頁查詢集合
        /// </summary>
        /// <param name="host">mongodb連接信息</param>
        /// <param name="filter">查詢條件</param>
        /// <param name="pageIndex">頁碼，從1開始</param>
        /// <param name="pageSize">頁數據量</param>
        /// <param name="count">總條數</param>
        /// <param name="field">要查詢的字段,不寫時查詢全部</param>
        /// <param name="sort">要排序的字段</param>
        /// <returns></returns>
        public static List<T> GetList(MongoDBHost host, FilterDefinition<T> filter, int pageIndex, int pageSize, out long count, string[] field = null, SortDefinition<T> sort = null)
        {
            try
            {                                
                var client = MongoDBClient<T>.GetCollectionInstance(host);
                count = client.CountDocuments(filter);
                if (pageIndex < 1 || pageSize < 1)
                {
                    return null;
                }
                //不指定查詢字段
                if (field == null || field.Length == 0)
                {
                    if (sort == null) return client.Find(filter).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();
                    //進行排序
                    return client.Find(filter).Sort(sort).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();
                }

                //指定查詢字段
                var fieldList = new List<ProjectionDefinition<T>>();
                for (int i = 0; i < field.Length; i++)
                {
                    fieldList.Add(Builders<T>.Projection.Include(field[i].ToString()));
                }
                var projection = Builders<T>.Projection.Combine(fieldList);
                fieldList?.Clear();

                //不排序
                if (sort == null) return client.Find(filter).Project<T>(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();

                //排序查詢
                return client.Find(filter).Sort(sort).Project<T>(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();

            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// 異步分頁查詢集合
        /// </summary>
        /// <param name="host">mongodb連接信息</param>
        /// <param name="filter">查詢條件</param>
        /// <param name="pageIndex">頁碼，從1開始</param>
        /// <param name="pageSize">頁數據量</param>
        /// <param name="field">要查詢的字段,不寫時查詢全部</param>
        /// <param name="sort">要排序的字段</param>
        /// <returns></returns>
        public static async Task<List<T>> GetListAsync(MongoDBHost host, FilterDefinition<T> filter, int pageIndex, int pageSize, string[] field = null, SortDefinition<T> sort = null)
        {
            try
            {
                var client = MongoDBClient<T>.GetCollectionInstance(host);
                if (pageIndex < 1 || pageSize < 1)
                {
                    return null;
                }
                //不指定查詢字段
                if (field == null || field.Length == 0)
                {
                    if (sort == null) return await client.Find(filter).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync();
                    //進行排序
                    return await client.Find(filter).Sort(sort).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync();
                }

                //指定查詢字段
                var fieldList = new List<ProjectionDefinition<T>>();
                for (int i = 0; i < field.Length; i++)
                {
                    fieldList.Add(Builders<T>.Projection.Include(field[i].ToString()));
                }
                var projection = Builders<T>.Projection.Combine(fieldList);
                fieldList?.Clear();

                //不排序
                if (sort == null) return await client.Find(filter).Project<T>(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync();

                //排序查詢
                return await client.Find(filter).Sort(sort).Project<T>(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync();

            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

    }

調用代碼：

    [BsonIgnoreExtraElements]   
    public class User 
    {
        [BsonId]
        [BsonRepresentation(BsonType.ObjectId)]
        public string Id { get; set; }

        [BsonElement("username")]
        public string UserName { get; set; }

        [BsonElement("password")]
        public string PassWord { get; set; }
    }



        public void Test1()
        {
            string id = Guid.NewGuid().ToString().Replace("-", string.Empty).Substring(0, 24);
            MongoDBHost host = new MongoDBHost()
            {
                ConnectionString = "mongodb://127.0.0.1:27017",
                DataBase = "test",
                Collection = "user",
            };
            User user = new User()
            {
                Id = id,
                PassWord = "123",
                UserName = "張三"
            };
            MongoDBHelper<User>.Add(host, user);
            user.PassWord = "assda";
            MongoDBHelper<User>.Update(host, user, id);
            var user1 = MongoDBHelper<User>.Get(host, id);
            MongoDBHelper<User>.Delete(host, id);

            //模糊匹配username
            string p= $".*{Regex.Escape("test")}.*";
            var filter = Builders<User>.Filter.Regex("username", new BsonRegularExpression(new Regex(p, RegexOptions.IgnoreCase)));
            var users = MongoDBHelper<User>.GetList(host, filter);
        }