MongoDB官网驱动仓库封装

public  interface IMongoRepositoryBase
    {
         ///   <summary>
         ///  新增一条数据
         ///   </summary>
         ///   <typeparam name="T"></typeparam>
         ///   <param name="model"></param>
         void Insert<T>(T model)  where T :  class;
         ///   <summary>
         ///  批量新增数据
         ///   </summary>
         ///   <typeparam name="T"> 泛型 </typeparam>
         ///   <param name="list"> 泛型集合 </param>
         void Insert<T>(IList<T> list)  where T :  class;



         ///   <summary>
         ///  更新一条数据
         ///   </summary>
         ///   <typeparam name="T"> 泛型 </typeparam>
         ///   <param name="model"> 实体类 </param>
         ///   <param name="where"> 查询条件 </param>
         bool Update<T>(T model, Expression<Func<T,  bool>>  where)  where T :  class;

         ///   <summary>
         ///  删除数据
         ///   </summary>
         ///   <typeparam name="T"></typeparam>
         ///   <param name="where"></param>
         bool Delete<T>(Expression<Func<T,  bool>>  where)  where T :  class;

         ///   <summary>
         ///  根据条件，获取一条记录
         ///   </summary>
         ///   <typeparam name="T"> 返回值类型 </typeparam>
         ///   <param name="where"></param>
         ///   <returns></returns>
        T GetModel<T>(Expression<Func<T,  bool>>  where)  where T :  class;

         ///   <summary>
         ///  获取列表
         ///   </summary>
         ///   <typeparam name="T"></typeparam>
         ///   <param name="where"></param>
         ///   <returns></returns>
        IList<T> GetList<T>(Expression<Func<T,  bool>>  where)  where T :  class;

         ///   <summary>
         ///  获取列表
         ///   </summary>
         ///   <typeparam name="T"></typeparam>
         ///   <param name="orderBy"></param>
         ///   <returns></returns>
        IList<T> GetList<T>(Expression<Func<T,  object>> orderBy)  where T :  class;
         ///   <summary>
         ///  获取带排序的列表
         ///   </summary>
         ///   <typeparam name="T"> 数据类型 </typeparam>
         ///   <param name="where"> 查询条件 </param>
         ///   <param name="orderBy"> 排序 </param>
         ///   <returns></returns>
        IList<T> GetList<T>(Expression<Func<T,  bool>>  where, Expression<Func<T,  object>> orderBy)  where T :  class;

         ///   <summary>
         ///  获取分页
         ///   </summary>
         ///   <typeparam name="T"></typeparam>
         ///   <param name="pageIndex"></param>
         ///   <param name="pageSize"></param>
         ///   <param name="where"></param>
         ///   <param name="orderby"></param>
         ///   <returns></returns>
        IList<T> GetList<T>( int pageIndex,  int pageSize, Expression<Func<T,  bool>>  where, Expression<Func<T,  object>>  orderby)  where T :  class;


         ///   <summary>
         ///  获取总记录数
         ///   </summary>
         ///   <typeparam name="T"></typeparam>
         ///   <param name="where"></param>
         ///   <returns></returns>
         long GetTotalCount<T>(Expression<Func<T,  bool>>  where)  where T :  class;

    }

  public  class MongoRepositoryBase : IMongoRepositoryBase
    {
         ///   <summary>
         ///  数据库
         ///   </summary>
         private IMongoDatabase db {  get;  set; }

         ///   <summary>
         ///  表名
         ///   </summary>
         private  string collectionName {  get;  set; }


         public MongoRepositoryBase( string collectionName)
        {
             this.db = MongoDBConnection.GetMongoDatabase();

             this.collectionName = collectionName;
        }


         ///   <summary>
         ///  新增一条数据
         ///   </summary>
         ///   <typeparam name="T"></typeparam>
         ///   <param name="model"></param>
         public  void Insert<T>(T model)  where T :  class
        {
             // 获取链表
             var collection = db.GetCollection<T>(collectionName);
             // 向链表中批量写入数据
            collection.InsertOneAsync(model);
        }



         ///   <summary>
         ///  批量新增数据
         ///   </summary>
         ///   <typeparam name="T"> 泛型 </typeparam>
         ///   <param name="list"> 泛型集合 </param>
         ///   <param name="collectionName"> 表名 </param>
         public  void Insert<T>(IList<T> list)  where T :  class
        {
             // 获取链表
             var collection = db.GetCollection<T>(collectionName);
             // 向链表中批量写入数据
            collection.InsertManyAsync(list);
        }


         ///   <summary>
         ///  更新一条数据
         ///   </summary>
         ///   <typeparam name="T"> 泛型 </typeparam>
         ///   <param name="model"> 实体类 </param>
         ///   <param name="collectionName"> 表名 </param>
         ///   <param name="where"> 查询条件 </param>
         public  bool Update<T>(T model, Expression<Func<T,  bool>>  where)  where T :  class
        {
             // 获取链表
             var collection = db.GetCollection<T>(collectionName);
             // 要更新的字段集合
             var fieldList =  new List<UpdateDefinition<T>>();

             foreach ( var property  in  typeof(T).GetProperties(BindingFlags.Instance | BindingFlags.Public))
            {
                 if (property.Name !=  " Id ") // 更新集中不能有实体键_id
                {
                    fieldList.Add(Builders<T>.Update.Set(property.Name, property.GetValue(model)));
                }
            }

             return collection.UpdateOneAsync( where, Builders<T>.Update.Combine(fieldList)).Result.ModifiedCount >  0 ?  true :  false;
        }

         public  bool Delete<T>(Expression<Func<T,  bool>>  where)  where T :  class
        {
             // 获取链表
             var collection = db.GetCollection<T>(collectionName);

             return collection.DeleteOneAsync( where).Result.DeletedCount >  0 ?  true :  false;

        }

         ///   <summary>
         ///  根据条件，获取一条记录
         ///   </summary>
         ///   <typeparam name="T"> 返回值类型 </typeparam>
         ///   <param name="collectionName"> 表名 </param>
         ///   <param name="where"></param>
         ///   <returns></returns>
         public T GetModel<T>(Expression<Func<T,  bool>>  where)  where T :  class
        {

             // 获取链表
             var collection = db.GetCollection<T>(collectionName);

             return collection.Find( where).FirstOrDefaultAsync().Result;
        }

         ///   <summary>
         ///  获取列表
         ///   </summary>
         ///   <typeparam name="T"></typeparam>
         ///   <returns></returns>
         public IList<T> GetList<T>()  where T :  class
        {
             // 获取链表
             var collection = db.GetCollection<T>(collectionName);

             return collection.Find( new BsonDocument()).ToListAsync().Result;
        }

         ///   <summary>
         ///  获取列表
         ///   </summary>
         ///   <typeparam name="T"></typeparam>
         ///   <param name="orderBy"></param>
         ///   <returns></returns>
         public IList<T> GetList<T>(Expression<Func<T,  object>> orderBy)  where T :  class
        {
             // 获取链表
             var collection = db.GetCollection<T>(collectionName);

             return collection.Find( new BsonDocument()).SortByDescending(orderBy).ToListAsync().Result;
        }

         ///   <summary>
         ///  获取列表
         ///   </summary>
         ///   <typeparam name="T"></typeparam>
         ///   <param name="where"></param>
         ///   <returns></returns>
         public IList<T> GetList<T>(Expression<Func<T,  bool>>  where)  where T :  class
        {
             // 获取链表
             var collection = db.GetCollection<T>(collectionName);

             return collection.Find( where).ToListAsync().Result;
        }

         ///   <summary>
         ///  获取带排序的列表
         ///   </summary>
         ///   <typeparam name="T"> 数据类型 </typeparam>
         ///   <param name="where"> 查询条件 </param>
         ///   <param name="orderBy"> 排序 </param>
         ///   <returns></returns>
         public IList<T> GetList<T>(Expression<Func<T,  bool>>  where, Expression<Func<T,  object>> orderBy)  where T :  class
        {
             // 获取链表
             var collection = db.GetCollection<T>(collectionName);

             return collection.Find( where).SortByDescending(orderBy).ToListAsync().Result;
        }


         ///   <summary>
         ///  获取分页
         ///   </summary>
         ///   <typeparam name="T"></typeparam>
         ///   <param name="pageIndex"></param>
         ///   <param name="pageSize"></param>
         ///   <param name="where"></param>
         ///   <param name="orderby"></param>
         ///   <returns></returns>
         public IList<T> GetList<T>( int pageIndex,  int pageSize, Expression<Func<T,  bool>>  where, Expression<Func<T,  object>>  orderby)  where T :  class
        {
             // 获取链表
             var collection = db.GetCollection<T>(collectionName);

             var skip = (pageIndex -  1) * pageSize;

             return collection.Find( where).SortByDescending( orderby).Skip(skip).Limit(pageSize).ToListAsync().Result;
        }


         ///   <summary>
         ///  获取总记录数
         ///   </summary>
         ///   <typeparam name="T"></typeparam>
         ///   <param name="where"></param>
         ///   <returns></returns>
         public  long GetTotalCount<T>(Expression<Func<T,  bool>>  where)  where T :  class
        {
             // 获取链表
             var collection = db.GetCollection<T>(collectionName);

             if ( where !=  null)
            {
                 return collection.CountAsync( where).Result;
            }
             else
            {
                 return collection.CountAsync( new BsonDocument()).Result;
            }
        }
    }