C# mongoDB Driver 使用對象方式最完善查詢語法大全

 #region 查詢方法

        /// <summary>
        ///     獲取單個對象
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="id">objectId</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public T Get<T>(string id, string collectionName = null)
        {
            return GetAsync<T>(id, collectionName).Result;
        }

        /// <summary>
        ///     獲取單個對象
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="expression">篩選條件</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public T Get<T>(Expression<Func<T, bool>> expression, string collectionName = null)
        {
            return GetAsync(expression, collectionName).Result;
        }

        /// <summary>
        ///     獲取單個對象
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="filter">過濾器</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public T Get<T>(FilterDefinition<T> filter, string collectionName = null)
        {
            return GetAsync(filter, collectionName).Result;
        }

        /// <summary>
        ///     獲取單個對象
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <typeparam name="TNewProjection">新實體類型</typeparam>
        /// <param name="expression">篩選條件</param>
        /// <param name="projection">新實體映射</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public TNewProjection Get<T, TNewProjection>(Expression<Func<T, bool>> expression,
            Expression<Func<T, TNewProjection>> projection, string collectionName = null)
        {
            return GetAsync(expression, projection, collectionName).Result;
        }

        /// <summary>
        ///     獲取單個對象
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <typeparam name="TNewProjection">新實體類型</typeparam>
        /// <param name="filter">過濾器</param>
        /// <param name="projection">新實體映射</param>
        /// <param name="collectionName">表名</param>
        /// <returns></returns>
        public TNewProjection Get<T, TNewProjection>(FilterDefinition<T> filter,
            Expression<Func<T, TNewProjection>> projection, string collectionName = null)
        {
            return GetAsync(filter, projection, collectionName).Result;
        }

        /// <summary>
        ///     異步獲取單個對象
        /// </summary>
        /// <param name="id">objectId</param>
        /// <param name="collectionName">表名</param>
        /// <returns></returns>
        public async Task<T> GetAsync<T>(string id, string collectionName)
        {
            return await GetAsync<T>(new BsonDocument("_id", id), collectionName).ConfigureAwait(false);
        }

        /// <summary>
        ///     異步獲取單個對象
        /// </summary>
        /// <param name="expression">篩選條件</param>
        /// <param name="collectionName">表名</param>
        /// <returns></returns>
        public async Task<T> GetAsync<T>(Expression<Func<T, bool>> expression, string collectionName = null)
        {
            var collection = GetCollection<T>(collectionName);
            return await collection.Find(expression).FirstOrDefaultAsync().ConfigureAwait(false);
        }

        /// <summary>
        ///     異步獲取單個對象
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <typeparam name="TNewProjection">新實體類型</typeparam>
        /// <param name="expression">篩選條件</param>
        /// <param name="projection">新實體映射</param>
        /// <param name="collectionName">表名稱</param>
        /// <returns></returns>
        public async Task<TNewProjection> GetAsync<T, TNewProjection>(Expression<Func<T, bool>> expression,
            Expression<Func<T, TNewProjection>> projection, string collectionName = null)
        {
            var collection = GetCollection<T>(collectionName);
            return await collection.Find(expression).Project(projection).FirstOrDefaultAsync().ConfigureAwait(false);
        }

        /// <summary>
        ///     異步獲取單個對象
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <typeparam name="TNewProjection">新實體類型</typeparam>
        /// <param name="filter">過濾器</param>
        /// <param name="projection">新實體映射</param>
        /// <param name="collectionName">表名</param>
        /// <returns></returns>
        public async Task<TNewProjection> GetAsync<T, TNewProjection>(FilterDefinition<T> filter,
            Expression<Func<T, TNewProjection>> projection, string collectionName)
        {
            var collection = GetCollection<T>(collectionName);
            return await collection.Find(filter).Project(projection).FirstOrDefaultAsync().ConfigureAwait(false);
        }

        public async Task<T> GetAsync<T>(FilterDefinition<T> filter, string collectionName = null)
        {
            var collection = GetCollection<T>(collectionName);
            return await collection.Find(filter).FirstOrDefaultAsync().ConfigureAwait(false);
        }

        /// <summary>
        ///     獲取集合
        /// </summary>
        /// <returns></returns>
        public List<T> GetAll<T>(string collectionName = null)
        {
            return GetAllAsync<T>(collectionName).Result;
        }

        /// <summary>
        ///     異步獲取集合
        /// </summary>
        /// <returns></returns>
        public async Task<List<T>> GetAllAsync<T>(string collectionName = null)
        {
            var collection = GetCollection<T>(collectionName);
            return await collection.Find(new BsonDocument()).ToListAsync().ConfigureAwait(false);
        }

        /// <summary>
        ///     查詢
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="expression">篩選條件</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public List<T> Find<T>(Expression<Func<T, bool>> expression, string collectionName = null)
        {
            return FindAsync(expression, collectionName).Result;
        }

        /// <summary>
        ///     查詢
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <typeparam name="TNewProjection">新實體類型</typeparam>
        /// <param name="expression">篩選條件</param>
        /// <param name="projection">新實體映射</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public List<TNewProjection> Find<T, TNewProjection>(Expression<Func<T, bool>> expression,
            Expression<Func<T, TNewProjection>> projection, string collectionName = null)
        {
            return FindAsync(expression, projection, collectionName).Result;
        }

        /// <summary>
        ///     查詢
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="filter">過濾器</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public List<T> Find<T>(FilterDefinition<T> filter, string collectionName = null)
        {
            return FindAsync(filter, collectionName).Result;
        }

        /// <summary>
        ///     查詢
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <typeparam name="TNewProjection">新實體類型</typeparam>
        /// <param name="filter">過濾器</param>
        /// <param name="projection">新實體映射</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public List<TNewProjection> Find<T, TNewProjection>(FilterDefinition<T> filter,
            Expression<Func<T, TNewProjection>> projection, string collectionName = null)
        {
            return FindAsync(filter, projection, collectionName).Result;
        }

        /// <summary>
        ///     獲取記錄數
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public long Count<T>(string collectionName = null)
        {
            return CountAsync<T>(new BsonDocument(), collectionName).Result;
        }

        /// <summary>
        ///     獲取記錄數
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="expression">篩選條件</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public long Count<T>(Expression<Func<T, bool>> expression, string collectionName = null)
        {
            return CountAsync(expression, collectionName).Result;
        }

        /// <summary>
        ///     獲取記錄數
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="filter">過濾器</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public long Count<T>(FilterDefinition<T> filter, string collectionName = null)
        {
            return CountAsync(filter, collectionName).Result;
        }

        /// <summary>
        ///     異步獲取記錄數
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="expression">篩選條件</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public async Task<long> CountAsync<T>(Expression<Func<T, bool>> expression, string collectionName = null)
        {
            var collection = GetCollection<T>(collectionName);
            return await collection.CountAsync(expression).ConfigureAwait(false);
        }

        /// <summary>
        ///     異步獲取記錄數
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="filter">過濾器</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public async Task<long> CountAsync<T>(FilterDefinition<T> filter, string collectionName = null)
        {
            var collection = GetCollection<T>(collectionName);
            return await collection.CountAsync(filter).ConfigureAwait(false);
        }

        /// <summary>
        ///     獲取分頁數據
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="pageIndex">頁次</param>
        /// <param name="pageSize">頁大小</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public List<T> PageList<T>(int pageIndex, int pageSize, string collectionName = null)
        {
            return PageListAsync<T>(pageIndex, pageSize, collectionName).Result;
        }

        /// <summary>
        ///     獲取分頁數據
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <typeparam name="TNewProjection">新實體類型</typeparam>
        /// <param name="pageIndex">頁次</param>
        /// <param name="pageSize">頁大小</param>
        /// <param name="projection">新實體映射</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public List<TNewProjection> PageList<T, TNewProjection>(int pageIndex, int pageSize,
            Expression<Func<T, TNewProjection>> projection, string collectionName)
        {
            return PageListAsync(pageIndex, pageSize, projection, collectionName).Result;
        }

        /// <summary>
        ///     獲取分頁數據
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="pageIndex">頁次</param>
        /// <param name="pageSize">頁大小</param>
        /// <param name="where">篩選條件</param>
        /// <param name="sort">排序條件</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public List<T> PageList<T>(int pageIndex, int pageSize, Expression<Func<T, bool>> where,
            SortDefinition<T> sort, string collectionName = null)
        {
            return PageListAsync(pageIndex, pageSize, where, sort, collectionName).Result;
        }

        /// <summary>
        ///     獲取分頁數據
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <typeparam name="TNewProjection">新實體類型</typeparam>
        /// <param name="pageIndex">頁次</param>
        /// <param name="pageSize">頁大小</param>
        /// <param name="where">篩選條件</param>
        /// <param name="sort">排序條件</param>
        /// <param name="projection">新實體映射</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public List<TNewProjection> PageList<T, TNewProjection>(int pageIndex, int pageSize,
            Expression<Func<T, bool>> where, SortDefinition<T> sort, Expression<Func<T, TNewProjection>> projection,
            string collectionName = null)
        {
            return PageListAsync(pageIndex, pageSize, where, sort, projection, collectionName).Result;
        }

        /// <summary>
        ///     獲取分頁數據
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="pageIndex">頁次</param>
        /// <param name="pageSize">頁大小</param>
        /// <param name="filter">篩選條件</param>
        /// <param name="sort">排序條件</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public List<T> PageList<T>(int pageIndex, int pageSize, FilterDefinition<T> filter,
            SortDefinition<T> sort, string collectionName)
        {
            return PageListAsync(pageIndex, pageSize, filter, sort, collectionName).Result;
        }

        /// <summary>
        ///     獲取分頁數據
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <typeparam name="TNewProjection">新實體類型</typeparam>
        /// <param name="pageIndex">頁次</param>
        /// <param name="pageSize">頁大小</param>
        /// <param name="filter">過濾器</param>
        /// <param name="sort">排序條件</param>
        /// <param name="projection">新實體映射</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public List<TNewProjection> PageList<T, TNewProjection>(int pageIndex, int pageSize,
            FilterDefinition<T> filter,
            SortDefinition<T> sort, Expression<Func<T, TNewProjection>> projection, string collectionName = null)
        {
            return PageListAsync(pageIndex, pageSize, filter, sort, projection, collectionName).Result;
        }

        /// <summary>
        ///     異步獲取分頁數據
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="pageIndex">頁次</param>
        /// <param name="pageSize">頁大小</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public async Task<List<T>> PageListAsync<T>(int pageIndex, int pageSize, string collectionName)
        {
            var collection = GetCollection<T>(collectionName);
            return
                await
                    collection.Find(new BsonDocument())
                        .Skip((pageIndex - 1) * pageSize)
                        .Limit(pageSize)
                        .ToListAsync()
                        .ConfigureAwait(false);
        }

        /// <summary>
        ///     異步獲取分頁數據
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <typeparam name="TNewProjection">新實體類型</typeparam>
        /// <param name="pageIndex">頁次</param>
        /// <param name="pageSize">頁大小</param>
        /// <param name="projection">新實體映射</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public async Task<List<TNewProjection>> PageListAsync<T, TNewProjection>(int pageIndex, int pageSize,
            Expression<Func<T, TNewProjection>> projection, string collectionName = null)
        {
            var collection = GetCollection<T>(collectionName);
            return
                await
                    collection.Find(new BsonDocument())
                        .Project(projection)
                        .Skip((pageIndex - 1) * pageSize)
                        .Limit(pageSize)
                        .ToListAsync()
                        .ConfigureAwait(false);
        }

        public async Task<List<T>> PageListAsync<T>(int pageIndex, int pageSize, FilterDefinition<T> filter,
            SortDefinition<T> sort, string collectionName)
        {
            var collection = GetCollection<T>(collectionName);
            return
                await
                    collection.Find(filter)
                        .Sort(sort)
                        .Skip((pageIndex - 1) * pageSize)
                        .Limit(pageSize)
                        .ToListAsync()
                        .ConfigureAwait(false);
        }

        /// <summary>
        ///     異步獲取分頁數據
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <typeparam name="TNewProjection">新實體類型</typeparam>
        /// <param name="pageIndex">頁次</param>
        /// <param name="pageSize">頁大小</param>
        /// <param name="filter">過濾器</param>
        /// <param name="sort">排序條件</param>
        /// <param name="projection">新實體映射</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public async Task<List<TNewProjection>> PageListAsync<T, TNewProjection>(int pageIndex, int pageSize,
            FilterDefinition<T> filter, SortDefinition<T> sort, Expression<Func<T, TNewProjection>> projection,
            string collectionName)
        {
            var collection = GetCollection<T>(collectionName);
            return
                await
                    collection.Find(filter)
                        .Project(projection)
                        .Sort(sort)
                        .Skip((pageIndex - 1) * pageSize)
                        .Limit(pageSize)
                        .ToListAsync()
                        .ConfigureAwait(false);
        }

        /// <summary>
        ///     異步獲取分頁數據
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="pageIndex">頁次</param>
        /// <param name="pageSize">頁大小</param>
        /// <param name="where">篩選條件</param>
        /// <param name="sort">排序條件</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public async Task<List<T>> PageListAsync<T>(int pageIndex, int pageSize, Expression<Func<T, bool>> where,
            SortDefinition<T> sort, string collectionName)
        {
            var collection = GetCollection<T>(collectionName);
            return
                await
                    collection.Find(where)
                        .Sort(sort)
                        .Skip((pageIndex - 1) * pageSize)
                        .Limit(pageSize)
                        .ToListAsync()
                        .ConfigureAwait(false);
        }

        /// <summary>
        ///     異步獲取分頁數據
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <typeparam name="TNewProjection">新實體類型</typeparam>
        /// <param name="pageIndex">頁次</param>
        /// <param name="pageSize">頁大小</param>
        /// <param name="where">篩選條件</param>
        /// <param name="sort">排序條件</param>
        /// <param name="projection">新實體映射</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public async Task<List<TNewProjection>> PageListAsync<T, TNewProjection>(int pageIndex, int pageSize,
            Expression<Func<T, bool>> where, SortDefinition<T> sort, Expression<Func<T, TNewProjection>> projection,
            string collectionName)
        {
            var collection = GetCollection<T>(collectionName);
            return
                await
                    collection.Find(where)
                        .Project(projection)
                        .Sort(sort)
                        .Skip((pageIndex - 1) * pageSize)
                        .Limit(pageSize)
                        .ToListAsync()
                        .ConfigureAwait(false);
        }

        /// <summary>
        ///     異步查詢
        /// </summary>
        /// <param name="expression">篩選條件</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public async Task<List<T>> FindAsync<T>(Expression<Func<T, bool>> expression,
            string collectionName = null)
        {
            var collection = GetCollection<T>(collectionName);
            return await collection.Find(expression).ToListAsync().ConfigureAwait(false);
        }

        /// <summary>
        ///     異步查詢
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <typeparam name="TNewProjection">新實體類型</typeparam>
        /// <param name="expression">查詢條件</param>
        /// <param name="projection">新實體映射</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public async Task<List<TNewProjection>> FindAsync<T, TNewProjection>(
            Expression<Func<T, bool>> expression,
            Expression<Func<T, TNewProjection>> projection, string collectionName)
        {
            var collection = GetCollection<T>(collectionName);
            return await collection.Find(expression).Project(projection).ToListAsync().ConfigureAwait(false);
        }

        /// <summary>
        ///     異步查詢
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="filter">過濾器</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public async Task<List<T>> FindAsync<T>(FilterDefinition<T> filter, string collectionName)
        {
            var collection = GetCollection<T>(collectionName);
            return await collection.Find(filter).ToListAsync().ConfigureAwait(false);
        }

        /// <summary>
        ///     異步查詢
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <typeparam name="TNewProjection">新實體類型</typeparam>
        /// <param name="filter">過濾器</param>
        /// <param name="projection">新實體映射</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public async Task<List<TNewProjection>> FindAsync<T, TNewProjection>(FilterDefinition<T> filter,
            Expression<Func<T, TNewProjection>> projection, string collectionName = null)
        {
            var collection = GetCollection<T>(collectionName);
            return await collection.Find(filter).Project(projection).ToListAsync().ConfigureAwait(false);
        }

        /// <summary>
        /// 聚合查詢
        /// </summary>
        /// <param name="collectionName"></param>
        /// <param name="pipelineStage"></param>
        /// <returns></returns>
        private List<T> AggregateQuery<T>(IEnumerable<IPipelineStageDefinition> pipelineStage)
        {

            var pipeline = new PipelineStagePipelineDefinition<T, T>(pipelineStage);
            var result = _collection.Aggregate(pipeline);
            return result.ToList();
        }
        /// <summary>
        /// 聚合查詢
        /// </summary>
        /// <param name="collectionName"></param>
        /// <param name="pipelineStage"></param>
        /// <returns></returns>
        private TO Aggregate<T,TO>(IEnumerable<IPipelineStageDefinition> pipelineStage)
        {
            var pipeline = new PipelineStagePipelineDefinition<T, TO>(pipelineStage);
            var result = _collection.Aggregate(pipeline);
            return result.FirstOrDefault();
        }
        private List<TO> AggregateQuery<T,TO>(IEnumerable<IPipelineStageDefinition> pipelineStage)
        {

            var pipeline = new PipelineStagePipelineDefinition<T, TO>(pipelineStage);
            var result = _collection.Aggregate(pipeline);
            return result.ToList();
        }
        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="TG">group by字段類型</typeparam>
        /// <typeparam name="TO">輸出類型</typeparam>
        /// <param name="match"></param>
        /// <param name="groupby"></param>
        /// <param name="groupValue"></param>
        /// <returns></returns>
        public List<TO> AggregateQuery<T,TG, TO>(Expression<Func<T, bool>> match,
            Expression<Func<T, TG>> groupby,
            Expression<Func<IGrouping<TG, T>, TO>> groupValue)
        {
            var pipelineStageDefinitions = new IPipelineStageDefinition[]
            {
                PipelineStageDefinitionBuilder.Match(match),
                PipelineStageDefinitionBuilder.Group(groupby,groupValue)
            };
            return AggregateQuery<TO>(pipelineStageDefinitions);
        }

 

#endregion

        #region 插入方法

        /// <summary>
        ///     插入
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="value">對象</param>
        /// <param name="collectionName">集合名稱</param>
        public void Insert<T>(T value, string collectionName = null)
        {
            InsertAsync(value, collectionName).Wait();
        }

        /// <summary>
        ///     異步插入
        /// </summary>
        /// <param name="value">對象</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public async Task InsertAsync<T>(T value, string collectionName = null)
        {
            var collection = GetCollection<T>(collectionName);
            await collection.InsertOneAsync(value).ConfigureAwait(false);
        }

        /// <summary>
        ///     批量插入
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="values">對象集合</param>
        /// <param name="collectionName">集合名稱</param>
        public void BatchInsert<T>(IEnumerable<T> values, string collectionName = null)
        {
            BatchInsertAsync(values, collectionName).Wait();
        }

        /// <summary>
        ///     異步批量插入
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="values">對象集合</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public async Task BatchInsertAsync<T>(IEnumerable<T> values, string collectionName = null)
        {
            var collection = GetCollection<T>(collectionName);
            await collection.InsertManyAsync(values).ConfigureAwait(false);
        }

        #endregion

        #region 更新方法

        /// <summary>
        ///     覆蓋更新
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="value">對象</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public ReplaceOneResult Update<T>(T value, string collectionName = null)
        {
            return UpdateAsync(value, collectionName).Result;
        }

        /// <summary>
        ///     局部更新
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="id">記錄ID</param>
        /// <param name="update">更新條件</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public UpdateResult Update<T>(ObjectId id, UpdateDefinition<T> update, string collectionName = null)
        {
            return UpdateAsync(new BsonDocument("_id", id), update, collectionName).Result;
        }

        /// <summary>
        ///     局部更新
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="expression">篩選條件</param>
        /// <param name="update">更新條件</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public UpdateResult Update<T>(Expression<Func<T, bool>> expression, UpdateDefinition<T> update,
            string collectionName = null)
        {
            return UpdateAsync(expression, update, collectionName).Result;
        }
        /// <summary>
        ///     局部更新
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="expression">篩選條件</param>
        /// <param name="update">更新條件</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public UpdateResult UpdateMany<T>(Expression<Func<T, bool>> expression, UpdateDefinition<T> update,
            string collectionName = null)
        {
            return UpdateManyAsync(expression, update, collectionName).Result;
        }

        public UpdateResult Update<T>(FilterDefinition<T> expression, UpdateDefinition<T> update,
            string collectionName = null)
        {
            return UpdateAsync(expression, update, collectionName).Result;
        }

        /// <summary>
        ///     異步局部更新（僅更新一條記錄）
        ///     <para><![CDATA[expression 參數示例：x => x.Id == 1 && x.Age > 18 && x.Gender == 0]]></para>
        ///     <para><![CDATA[entity 參數示例：y => new T{ RealName = "Ray", Gender = 1}]]></para>
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="expression">篩選條件</param>
        /// <param name="entity">更新條件</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public UpdateResult Update<T>(Expression<Func<T, bool>> expression, Expression<Action<T>> entity,
            string collectionName = null)
        {
            return UpdateAsync(expression, entity, collectionName).Result;
        }

        /// <summary>
        ///     異步局部更新（僅更新一條記錄）
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="filter">過濾器</param>
        /// <param name="update">更新條件</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public async Task<UpdateResult> UpdateAsync<T>(FilterDefinition<T> filter, UpdateDefinition<T> update,
            string collectionName = null)
        {
            var collection = GetCollection<T>(collectionName);
            return await collection.UpdateOneAsync(filter, update).ConfigureAwait(false);
        }

        /// <summary>
        ///     異步局部更新（僅更新一條記錄）
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="expression">篩選條件</param>
        /// <param name="update">更新條件</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public async Task<UpdateResult> UpdateAsync<T>(Expression<Func<T, bool>> expression,
            UpdateDefinition<T> update, string collectionName = null)
        {
            var collection = GetCollection<T>(collectionName);
            return await collection.UpdateOneAsync(expression, update).ConfigureAwait(false);
        }
        /// <summary>
        /// 異步局部更新（僅更新多條記錄）
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="expression">篩選條件</param>
        /// <param name="update">更新條件</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public async Task<UpdateResult> UpdateManyAsync<T>(Expression<Func<T, bool>> expression,
            UpdateDefinition<T> update, string collectionName = null)
        {
            var collection = GetCollection<T>(collectionName);
            return await collection.UpdateManyAsync(expression, update).ConfigureAwait(false);
        }

        /// <summary>
        ///     異步局部更新（僅更新一條記錄）
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="expression">篩選條件</param>
        /// <param name="entity">更新條件</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public async Task<UpdateResult> UpdateAsync<T>(Expression<Func<T, bool>> expression,
            Expression<Action<T>> entity, string collectionName = null)
        {
            var fieldList = new List<UpdateDefinition<T>>();

            var param = entity.Body as MemberInitExpression;
            if (param != null)
            {
                foreach (var item in param.Bindings)
                {
                    var propertyName = item.Member.Name;
                    object propertyValue = null;
                    var memberAssignment = item as MemberAssignment;
                    if (memberAssignment == null) continue;
                    if (memberAssignment.Expression.NodeType == ExpressionType.Constant)
                    {
                        var constantExpression = memberAssignment.Expression as ConstantExpression;
                        if (constantExpression != null)
                            propertyValue = constantExpression.Value;
                    }
                    else
                    {
                        propertyValue = Expression.Lambda(memberAssignment.Expression, null).Compile().DynamicInvoke();
                    }

                    if (propertyName != "_id") //實體鍵_id不允許更新
                    {
                        fieldList.Add(Builders<T>.Update.Set(propertyName, propertyValue));
                    }
                }
            }
            var collection = GetCollection<T>(collectionName);
            return
                await collection.UpdateOneAsync(expression, Builders<T>.Update.Combine(fieldList)).ConfigureAwait(false);
        }

        /// <summary>
        ///     異步覆蓋更新
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="value">對象</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public async Task<ReplaceOneResult> UpdateAsync<T>(T value, string collectionName)
        {
            var collection = GetCollection<T>(collectionName);
            return await
                collection.ReplaceOneAsync(
                    new BsonDocument("_id", new ObjectId(typeof(T).GetProperty("Id").GetValue(value).ToString())),
                    value).ConfigureAwait(false);
        }

        #endregion

        #region 刪除方法

        /// <summary>
        ///     刪除指定對象
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="id">對象Id</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public DeleteResult Delete<T>(ObjectId id, string collectionName = null)
        {
            return DeleteAsync<T>(id, collectionName).Result;
        }

        /// <summary>
        ///     刪除指定對象
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="expression">查詢條件</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public DeleteResult Delete<T>(Expression<Func<T, bool>> expression, string collectionName = null)
        {
            return DeleteAsync(expression, collectionName).Result;
        }

        /// <summary>
        ///     異步刪除指定對象
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="id">對象Id</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public async Task<DeleteResult> DeleteAsync<T>(ObjectId id, string collectionName = null)
        {
            var collection = GetCollection<T>(collectionName);
            return await collection.DeleteOneAsync(new BsonDocument("_id", id)).ConfigureAwait(false);
        }

        /// <summary>
        ///     異步刪除指定對象
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="expression">查詢條件</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public async Task<DeleteResult> DeleteAsync<T>(Expression<Func<T, bool>> expression,
            string collectionName = null)
        {
            var collection = GetCollection<T>(collectionName);
            return await collection.DeleteOneAsync(expression).ConfigureAwait(false);
        }

        /// <summary>
        ///     批量刪除對象
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="ids">ID集合</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public DeleteResult BatchDelete<T>(IEnumerable<ObjectId> ids, string collectionName = null)
        {
            return BatchDeleteAsync<T>(ids, collectionName).Result;
        }

        /// <summary>
        ///     批量刪除對象
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="filter">過濾器</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public DeleteResult BatchDelete<T>(FilterDefinition<T> filter, string collectionName = null)
        {
            return BatchDeleteAsync(filter, collectionName).Result;
        }

        /// <summary>
        ///     批量刪除對象
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="expression">篩選條件</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public DeleteResult BatchDelete<T>(Expression<Func<T, bool>> expression, string collectionName = null)
        {
            return BatchDeleteAsync(expression, collectionName).Result;
        }

        /// <summary>
        ///     異步批量刪除對象
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="ids">ID集合</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public async Task<DeleteResult> BatchDeleteAsync<T>(IEnumerable<ObjectId> ids,
            string collectionName = null)
        {
            var filter = Builders<T>.Filter.In("_id", ids);
            var collection = GetCollection<T>(collectionName);
            return await collection.DeleteManyAsync(filter).ConfigureAwait(false);
        }

        /// <summary>
        ///     異步批量刪除對象
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="filter">過濾器</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public async Task<DeleteResult> BatchDeleteAsync<T>(FilterDefinition<T> filter,
            string collectionName = null)
        {
            var collection = GetCollection<T>(collectionName);
            return await collection.DeleteManyAsync(filter).ConfigureAwait(false);
        }

        /// <summary>
        ///     異步批量刪除對象
        /// </summary>
        /// <typeparam name="T">數據庫實體類型</typeparam>
        /// <param name="expression">篩選條件</param>
        /// <param name="collectionName">集合名稱</param>
        /// <returns></returns>
        public async Task<DeleteResult> BatchDeleteAsync<T>(Expression<Func<T, bool>> expression,
            string collectionName = null)
        {
            var collection = GetCollection<T>(collectionName);
            return await collection.DeleteManyAsync(expression).ConfigureAwait(false);
        }

        #endregion

 

  內嵌數組增加元素操作

（一） Update.Set()方法 替換內嵌數組（不推薦使用）

此方法主要使用操作符[$set]，它的思路是先將內嵌文檔的父元素查找出來，然后對子文檔數組進行增刪改操作，最后將子文檔數組重新替換。此方式性能較低，除非涉及到大批量更改，否則不推薦使用。

  #region 方法一. 查出sensor再更新Records, $set操作 - 隨機插入100個元素(不推薦)
    // 查詢需修改的sensorNode對象
    var sensor = await _sensorNodes.Find(s => s.Id == _sensorNodeId).FirstOrDefaultAsync();
    // 往Records里面增加隨機元素
    sensor.Records.AddRange(GetRandomRecord(100));
    // 構建update Bson, 將原有Records替換為新的Records
    var update = Builders<SensorNode>.Update.Set(d => d.Records, sensor.Records);
    // 使用Update方法
    await _sensorNodes.UpdateOneAsync(s => s.Id == _sensorNodeId, update);
    #endregion

 

（二）Update.Push()方法 直接將元素壓入內嵌數組（推薦）

此方法主要使用操作符[$push]來增加元素到子文檔數組，性能好，推薦使用。

// 構建update Bson ,添加一條記錄使用Push方法
var updateOne = Builders<SensorNode>.Update.Push(d => d.Records, GetRandomRecord(1).First());
// 更新
await _sensorNodes.UpdateOneAsync(s => s.Id == _sensorNodeId, updateMany);

 

(三) Update.PushEach()方法 將多個元素壓入內嵌數組（推薦）

此方法使用的也是[$push]操作符，只是在生成BsonDocument時允許接收數組。

#region 方法二. $push操作 - 隨機插入100個元素(推薦)
// 構建update Bson 添加多條記錄使用PushEach方法
var updateMany = Builders<SensorNode>.Update.PushEach(d => d.Records, GetRandomRecord(100));
// 更新
await _sensorNodes.UpdateOneAsync(s => s.Id == _sensorNodeId, updateMany);
#endregion

 

  內嵌數組刪除元素操作

(一) Update.Set()方法 替換內嵌數組（不推薦使用）

此方式思路和增加元素的思路一致，性能較低，不推薦使用。

#region 方法一 . $set方式刪除 - 刪除前5個元素(不推薦)
// 查詢需修改的sensorNode對象
var sensor = await _sensorNodes.Find(s => s.Id == _sensorNodeId).FirstOrDefaultAsync();
// 刪除Record
for (int i = 0; i < 5; i++)
{
    sensor.Records.RemoveAt(i);
}
// 構建update Bson, 將原有Records替換為新的Records
var update = Builders<SensorNode>.Update.Set(d => d.Records, sensor.Records);
// 使用Update方法
await _sensorNodes.UpdateOneAsync(s => s.Id == _sensorNodeId, update);
#endregion

 

(二) Update.Pull()方法 Pull刪除一個元素（推薦）

// 假設需要刪除的Record已經被查詢轉換為對象，那么使用Pull方式刪除一個元素
var record = new Record() 
{ Data = 1670941112.0, RecorDateTime = DateTime.Parse("2018-03-16T09:36:14.930Z") };
// 構建Pull刪除Bson
var update = Builders<SensorNode>.Update.Pull(s => s.Records, record);
// 使用Update方法
await _sensorNodes.UpdateOneAsync(s => s.Id == _sensorNodeId, update);

 

（三）Update.PullFilter()方法 刪除過濾器刪除元素（推薦）

#region 方法三. PullFilter方式刪除 - 刪除符合Filter條件的元素(推薦)
// 如果r.Data == 339119843.0，那么從數組中刪除
var update = Builders<SensorNode>.Update.PullFilter(s => s.Records, r => r.Data == 339119843.0);
await _sensorNodes.UpdateOneAsync(s => s.Id == _sensorNodeId, update);
#endregion

 

   內嵌數組修改元素操作

（一） Update.Set() Set先查詢后修改（不推薦）

此方式性能較低，不推薦。

#region 方法一. $set方式修改(將某個元素記錄時間改為最小值) - 先查詢后修改(不推薦)
// 查詢需修改的sensorNode對象
var sensor = await _sensorNodes.Find(s => s.Id == _sensorNodeId).FirstOrDefaultAsync();
// 修改Record值
sensor.Records[0].RecorDateTime = DateTime.MinValue;
// 構建update Bson, 將原有Records替換為新的Records
var update = Builders<SensorNode>.Update.Set(d => d.Records, sensor.Records);
// 使用Update方法
await _sensorNodes.UpdateOneAsync(s => s.Id == _sensorNodeId, update);
#endregion

 

（二） Update.Set() 配合過濾器修改（推薦）

在數據庫內部完成過濾和修改，性能高，推薦使用。

#region 方法二. $set方式修改(將Data = 1835821478.0的元素記錄時間改為最大值) - 直接過濾修改(推薦)
// 構造filter 
var filter = Builders<SensorNode>.Filter.Where(s => s.Id == _sensorNodeId) 
& Builders<SensorNode>.Filter.Where(d => d.Records.Any(r => r.Data == 1835821478.0));
// 執行更新
var update = Builders<SensorNode>.Update.Set(d => d.Records[-1].RecorDateTime, DateTime.MaxValue);
await _sensorNodes.UpdateOneAsync(filter, update);
#endregion

 

  內嵌數組查找元素操作(Linq)

對於內嵌數組/文檔的查詢，在.net里建議直接使用Linq或拼接BsonDocument。筆者着重使用Linq方式。

需要先using MongoDB.Driver.Linq,否則Linq無法使用。

（一）Linq查詢一條記錄（推薦）

主要是SelectMany()方法的使用，此方法用於選擇一個數組。

#region SelectMany查詢內嵌數組(查詢Data = 1340695206.0的第一條記錄) - (推薦)
// 轉換為Queryable
var result = await _sensorNodes.AsQueryable()
    // 查找對應的sensorNode
    .Where(s => s.Id == _sensorNodeId)
    // 選擇Records內嵌數組
    .SelectMany(s => s.Records)
    // 查找Data == 1340695206.0的元素
    .Where(r => r.Data == 1340695206.0)
    // 取第一個
    .FirstOrDefaultAsync();
#endregion

 

（二）Linq查詢分頁 (推薦)

主要區別使用SelectMany其它與EF Linq方式差不多

#region SelectMany、Skip、Take內嵌數組排序分頁 - (推薦)
// 頁碼
var index = 4;
// 頁面大小
var size = 10;
// 轉換為Queryable
var page = await _sensorNodes.AsQueryable()
    // 查找對應的sensorNode
    .Where(s => s.Id == _sensorNodeId)
    // 選擇Records內嵌數組
    .SelectMany(s => s.Records)
    // 根據記錄時間排序
    .OrderBy(r => r.RecorDateTime)
    // 跳過 index - 1頁數據
    .Skip((index - 1) * size)
    // 選取一頁數據
    .Take(size)
    // 轉換為集合
    .ToListAsync();
#endregion

 

  使用對象方式進行聚合查詢(Linq)

//獲取總數，一個樣本只獲取一條，where是linq lambda表達式
            Expression<Func<ReportRecord, int>> groupby = g => g.SampleId;
            Expression<Func<MongoAggregateCnt, int>> groupbyCnt = g => 1;
            var conection = MongoDbManager<ReportRecord>.GetInstance()
                .BuildAnnotationDb()
                .GetCollection(ConstVar.ReportTable);
            var pipelineStageDefinitions = new IPipelineStageDefinition[]
            {
                PipelineStageDefinitionBuilder.Match(where),
                PipelineStageDefinitionBuilder.Group(groupby,v => new MongoAggregateCnt{cnt = v.Key}),
                PipelineStageDefinitionBuilder.Group(groupbyCnt,v => new MongoAggregateCnt{cnt = v.Count()})
            };

            var totalO = conection.Aggregate<MongoAggregateCnt>(pipelineStageDefinitions).FirstOrDefault();
            total = totalO?.cnt??0;
     /// <summary>
    /// mongo 聚合總數
    /// </summary>
    public class MongoAggregateCnt
    {
        public int cnt { get; set; }
    }

 

/// <summary>        /// 聚合查詢        /// </summary>        /// <param name="collectionName"></param>        /// <param name="pipelineStage"></param>        /// <returns></returns>        private List<T> AggregateQuery(IEnumerable<IPipelineStageDefinition> pipelineStage)        {
            var pipeline = new PipelineStagePipelineDefinition<T, T>(pipelineStage);            var result = _collection.Aggregate(pipeline);            return result.ToList();        }        /// <summary>        /// 聚合查詢        /// </summary>        /// <param name="collectionName"></param>        /// <param name="pipelineStage"></param>        /// <returns></returns>        private TO Aggregate<TO>(IEnumerable<IPipelineStageDefinition> pipelineStage)        {            var pipeline = new PipelineStagePipelineDefinition<T, TO>(pipelineStage);            var result = _collection.Aggregate(pipeline);            return result.FirstOrDefault();        }        private List<TO> AggregateQuery<TO>(IEnumerable<IPipelineStageDefinition> pipelineStage)        {
            var pipeline = new PipelineStagePipelineDefinition<T, TO>(pipelineStage);            var result = _collection.Aggregate(pipeline);            return result.ToList();        }        /// <summary>        ///         /// </summary>        /// <typeparam name="TG">group by字段類型</typeparam>        /// <typeparam name="TO">輸出類型</typeparam>        /// <param name="match"></param>        /// <param name="groupby"></param>        /// <param name="groupValue"></param>        /// <returns></returns>        public List<TO> AggregateQuery<TG, TO>(Expression<Func<T, bool>> match,            Expression<Func<T, TG>> groupby,            Expression<Func<IGrouping<TG, T>, TO>> groupValue)        {            var pipelineStageDefinitions = new IPipelineStageDefinition[]            {                PipelineStageDefinitionBuilder.Match(match),                PipelineStageDefinitionBuilder.Group(groupby,groupValue)            };            return AggregateQuery<TO>(pipelineStageDefinitions);        }