MongoDBHelper 操作类

 /// <summary>
    /// MongoDb基类
    /// </summary>
    /// <typeparam name="TEntity"></typeparam>
    public class MongoDbBase<TEntity>
    {
        private int _companyId;
        /// <summary>
        /// 公司ID
        /// </summary>
        public int CompanyID
        {
            get
            {
                return _companyId;
            }
            set
            {
                _companyId = value;
            }
        }
        private IMongoCollection<TEntity> _collection;
        /// <summary>
        /// 集合连接对象
        /// </summary>
        public IMongoCollection<TEntity> Collection => _collection;
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="companyID"></param>
        public MongoDbBase(int companyID)
        {
            _companyId = companyID;
            _collection = MongoDbHelper<TEntity>.GetCollection($"{typeof(TEntity).Name}_{companyID}");
        }

        /// <summary>
        /// 数量
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        public virtual long Count(Expression<Func<TEntity, bool>> filter) => Collection.Count(filter);

        /// <summary>
        /// 创建索引
        /// </summary>
        /// <param name="keys"></param>
        /// <param name="options"></param>
        /// <returns></returns>
        public virtual string CreateIndex(IndexKeysDefinition<TEntity> keys, CreateIndexOptions options = null) => Collection.Indexes.CreateOne(keys, options);

        /// <summary>
        /// 创建索引
        /// </summary>
        /// <param name="models"></param>
        /// <returns></returns>
        public virtual IEnumerable<string> CreateMany(IEnumerable<CreateIndexModel<TEntity>> models) => Collection.Indexes.CreateMany(models);

        /// <summary>
        /// 去重查询字段
        /// </summary>
        /// <typeparam name="TField"></typeparam>
        /// <param name="field"></param>
        /// <param name="filter"></param>
        /// <returns></returns>
        public virtual List<TField> Distinct<TField>(Expression<Func<TEntity, TField>> field, Expression<Func<TEntity, bool>> filter) => Collection.Distinct(field, filter).ToList();

        #region <BulkWrite>
        /// <summary>
        /// 事物
        /// </summary>
        /// <param name="requests"></param>
        public virtual BulkWriteResult<TEntity> BulkWrite(IEnumerable<WriteModel<TEntity>> requests)
        {
            BulkWriteOptions options = new BulkWriteOptions() { IsOrdered = false };
            return Collection.BulkWrite(requests, options);
        }

        /// <summary>
        /// 事物
        /// </summary>
        /// <param name="requests"></param>
        public virtual Task<BulkWriteResult<TEntity>> BulkWriteAsync(IEnumerable<WriteModel<TEntity>> requests)
        {
            BulkWriteOptions options = new BulkWriteOptions() { IsOrdered = false };
            return Collection.BulkWriteAsync(requests, options);
        }
        #endregion

        #region <Insert>
        /// <summary>
        /// 插入一条数据
        /// </summary>
        /// <param name="item"></param>
        public virtual void InsertOne(TEntity item) => Collection.InsertOne(item);
        /// <summary>
        /// 异步插入一条数据
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public virtual Task InsertOneAsync(TEntity item) => Collection.InsertOneAsync(item);
        /// <summary>
        /// 批量插入数据
        /// </summary>
        /// <param name="list"></param>
        public virtual void InsertMany(IEnumerable<TEntity> list)
        {
            InsertManyOptions options = new InsertManyOptions() { IsOrdered = false };
            Collection.InsertMany(list, options);
        }
        /// <summary>
        /// 异步批量插入数据
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public virtual Task InsertManyAsync(IEnumerable<TEntity> list)
        {
            InsertManyOptions options = new InsertManyOptions() { IsOrdered = false };
            return Collection.InsertManyAsync(list, options);
        }
        #endregion

        #region <Update>
        /// <summary>
        /// 更新一条数据
        /// </summary>
        /// <param name="filter"></param>
        /// <param name="update"></param>
        /// <returns></returns>
        public virtual UpdateResult UpdateOne(Expression<Func<TEntity, bool>> filter, UpdateDefinition<TEntity> update) => Collection.UpdateOne(filter, update);
        /// <summary>
        /// 异步更新一条数据
        /// </summary>
        /// <param name="filter"></param>
        /// <param name="update"></param>
        /// <returns></returns>
        public virtual Task<UpdateResult> UpdateOneAsync(Expression<Func<TEntity, bool>> filter, UpdateDefinition<TEntity> update) => Collection.UpdateOneAsync(filter, update);
        /// <summary>
        /// 批量更新数据
        /// </summary>
        /// <param name="filter"></param>
        /// <param name="update"></param>
        /// <returns></returns>
        public virtual UpdateResult UpdateMany(Expression<Func<TEntity, bool>> filter, UpdateDefinition<TEntity> update) => Collection.UpdateMany(filter, update);
        /// <summary>
        /// 异步批量更新数据
        /// </summary>
        /// <param name="filter"></param>
        /// <param name="update"></param>
        /// <returns></returns>
        public virtual Task<UpdateResult> UpdateManyAsync(Expression<Func<TEntity, bool>> filter, UpdateDefinition<TEntity> update)
        {
            return Collection.UpdateManyAsync(filter, update);
        }
        #endregion

        #region <Delete>
        /// <summary>
        /// 删除一条数据
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        public virtual DeleteResult DeleteOne(Expression<Func<TEntity, bool>> filter) => Collection.DeleteOne(filter);
        /// <summary>
        /// 异步删除一条数据
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        public virtual Task<DeleteResult> DeleteOneAsync(Expression<Func<TEntity, bool>> filter) => Collection.DeleteOneAsync(filter);
        /// <summary>
        /// 批量删除数据
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        public virtual DeleteResult DeleteMany(Expression<Func<TEntity, bool>> filter)
        {
            return Collection.DeleteMany(filter);
        }
        /// <summary>
        /// 异步批量删除数据
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        public virtual Task<DeleteResult> DeleteManyAsync(Expression<Func<TEntity, bool>> filter)
        {
            return Collection.DeleteManyAsync(filter);
        }
        #endregion

        #region <Replace>
        /// <summary>
        /// 替换一条数据
        /// </summary>
        /// <param name="filter"></param>
        /// <param name="replacement"></param>
        /// <returns></returns>
        public virtual ReplaceOneResult ReplaceOne(Expression<Func<TEntity, bool>> filter, TEntity replacement)
        {
            return Collection.ReplaceOne(filter, replacement);
        }
        /// <summary>
        /// 异步替换一条数据
        /// </summary>
        /// <param name="filter"></param>
        /// <param name="replacement"></param>
        /// <returns></returns>
        public virtual Task<ReplaceOneResult> ReplaceOneAsync(Expression<Func<TEntity, bool>> filter, TEntity replacement)
        {
            return Collection.ReplaceOneAsync(filter, replacement);
        }
        /// <summary>
        /// 查找并替换一条数据
        /// </summary>
        /// <param name="filter"></param>
        /// <param name="replacement"></param>
        /// <returns></returns>
        public virtual TEntity FindOneAndReplace(Expression<Func<TEntity, bool>> filter, TEntity replacement)
        {
            return Collection.FindOneAndReplace(filter, replacement);
        }
        /// <summary>
        /// 异步查找并替换一条数据
        /// </summary>
        /// <param name="filter"></param>
        /// <param name="replacement"></param>
        /// <returns></returns>
        public virtual Task<TEntity> FindOneAndReplaceAsync(Expression<Func<TEntity, bool>> filter, TEntity replacement)
        {
            return Collection.FindOneAndReplaceAsync(filter, replacement);
        }
        #endregion

        #region <Find>
        /// <summary>
        /// Id查询
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public virtual TEntity FindById(string id)
        {
            return Collection.Find(Builders<TEntity>.Filter.Eq("_id", new ObjectId(id))).Limit(1).FirstOrDefault();
        }
        /// <summary>
        /// Id查询
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public virtual TEntity FindById(ObjectId id)
        {
            return Collection.Find(Builders<TEntity>.Filter.Eq("_id", id)).Limit(1).FirstOrDefault();
        }
        /// <summary>
        /// 查找并更新一条数据
        /// </summary>
        /// <param name="filter"></param>
        /// <param name="update"></param>
        /// <returns></returns>
        public virtual TEntity FindOneAndUpdate(Expression<Func<TEntity, bool>> filter, UpdateDefinition<TEntity> update)
        {
            return Collection.FindOneAndUpdate(filter, update);
        }
        /// <summary>
        /// 异步查找并更新一条数据
        /// </summary>
        /// <param name="filter"></param>
        /// <param name="update"></param>
        /// <returns></returns>
        public virtual Task<TEntity> FindOneAndUpdateAsync(Expression<Func<TEntity, bool>> filter, UpdateDefinition<TEntity> update)
        {
            return Collection.FindOneAndUpdateAsync(filter, update);
        }
        /// <summary>
        /// 根据条件查询数据
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        public virtual TEntity FindOne(Expression<Func<TEntity, bool>> filter)
        {
            return Collection.Find(filter).FirstOrDefault();
        }
        /// <summary>
        /// 根据条件查询数据
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        public virtual List<TEntity> Find(Expression<Func<TEntity, bool>> filter)
        {
            return Collection.Find(filter).ToList();
        }
        /// <summary>
        /// 根据条件查询数据
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        public virtual IFindFluent<TEntity, TEntity> FindData(Expression<Func<TEntity, bool>> filter)
        {
            return Collection.Find(filter);
        }
        /// <summary>
        /// 根据条件查询数据
        /// </summary>
        /// <param name="filter"></param>
        /// <param name="topSize"></param>
        /// <returns></returns>
        public virtual List<TEntity> Find(Expression<Func<TEntity, bool>> filter, int topSize)
        {
            return Collection.Find(filter).Limit(topSize).ToList();
        }
        /// <summary>
        /// 根据条件查询数据
        /// </summary>
        /// <param name="filter"></param>
        /// <param name="topSize"></param>
        /// <param name="field"></param>
        /// <param name="sort"></param>
        /// <returns></returns>
        public virtual List<TEntity> Find(Expression<Func<TEntity, bool>> filter, int topSize, Expression<Func<TEntity, object>> field, MongoDBSort sort = MongoDBSort.Asc)
        {
            if (sort == MongoDBSort.Asc)
                return Collection.Find(filter).SortBy(field).Limit(topSize).ToList();
            else
                return Collection.Find(filter).SortByDescending(field).Limit(topSize).ToList();
        }
        /// <summary>
        /// 异步查询数据
        /// </summary>
        /// <param name="filter"></param>
        /// <returns></returns>
        public virtual Task<List<TEntity>> FindAsnyc(Expression<Func<TEntity, bool>> filter)
        {
            return Collection.Find(filter).ToListAsync();
        }
        /// <summary>
        /// 分页查询数据
        /// </summary>
        /// <param name="filter"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="field"></param>
        /// <param name="sort"></param>
        /// <returns></returns>
        public virtual Pager<TEntity> Find(Expression<Func<TEntity, bool>> filter, int pageIndex, int pageSize, Expression<Func<TEntity, object>> field, MongoDBSort sort = MongoDBSort.Asc)
        {
            int count = (int)Collection.Count(filter);
            int startIndex = (pageIndex - 1) * pageSize;
            List<TEntity> list = new List<TEntity>();
            if (sort == MongoDBSort.Asc)
                list = Collection.Find(filter).SortBy(field).Skip(startIndex).Limit(pageSize).ToList();
            else
                list = Collection.Find(filter).SortByDescending(field).Skip(startIndex).Limit(pageSize).ToList();
            Pager<TEntity> pager = new Pager<TEntity>()
            {
                CurrentPage = pageIndex,
                PageSize = pageSize,
                Rows = list,
                TotalRows = count
            };
            return pager;
        }
        #endregion
    }