public  interface IDataBaseCore
    {
    }
public class BasicData : IDataBaseCore
    {
    }

public class Filter
    {
        public string Key { set; get; }

        public string Value { set; get; }

    }


/// <summary> /// 数据Context接口 /// </summary> public interface IDataContext<T> where T : class { /// <summary> /// 客户端数据连接访问器 /// </summary> T DbContext { set; get; } }
 public interface IDataBase<T> : IDataContext<MongoClient> where T : IDataBaseCore
    {
        /// <summary>
        /// 数据库
        /// </summary>
        IMongoDatabase DataBase { get;}
    }
public class MongodbContext<T> : IDataBase<T> where T : IDataBaseCore
    {
        public MongodbContext()
        {

        }

        public MongoClient DbContext { set; get; } = new MongoClient(new ConfigSetting().Mongodb);

        public IMongoDatabase DataBase { get => DbContext.GetDatabase(typeof(T).Name); }

        #region 具体的表操作
        /// <summary>
        /// 系统菜单
        /// </summary>
        public IMongoCollection<SysMenu> SysMenus { get => DbSet<SysMenu>(); }

        /// <summary>
        /// 用户
        /// </summary>
        public IMongoCollection<User> Users { set; get; }

        #endregion

        public IMongoCollection<K> DbSet<K>() where K : ICore => DataBase.GetCollection<K>(typeof(K).Name);

    }

monogodb链接对象是自托管不用考虑链接释放问题,当然做成单利的也是可以的  原本typeof(K).Name 这里是写的是nameof(K)发现无法得到真实传递K的Name名称 直接解释成了字符串K。

扩展方法

    public static class MongodbExpansion
    {
        /// <summary>
        /// 单个对象添加
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collection"></param>
        /// <param name="entity"></param>
        public static void Add<T>(this IMongoCollection<T> collection, T entity) where T : ICore
            => collection.InsertOne(entity);

        /// <summary>
        /// 单个对象异步操作
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collection"></param>
        /// <param name="entity"></param>
        /// <returns></returns>
        public static async Task AddAsync<T>(this IMongoCollection<T> collection, T entity) where T : ICore
            => await collection.InsertOneAsync(entity);

        /// <summary>
        /// 集合添加
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collection"></param>
        /// <param name="entitys"></param>
        public static void AddRange<T>(this IMongoCollection<T> collection, List<T> entitys) where T : ICore
            => collection.InsertMany(entitys);

        /// <summary>
        /// 集合异步操作
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collection"></param>
        /// <param name="entitys"></param>
        public static void AddRangeAsync<T>(this IMongoCollection<T> collection, List<T> entitys) where T : ICore
           => collection.InsertManyAsync(entitys);
        /// <summary>
        /// entity mongodb需要更新的实体 properts需要更新的集合属性,大小写不限 默认更新整个对象 replace 默认空属性不修改
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collection"></param>
        /// <param name="entity">mongodb需要更新的实体</param>
        /// <param name="properts">需要更新的集合属性,大小写不限 默认更新整个对象 </param>
        /// <param name="replace">默认空属性不修改</param>
        public static void Update<T>(this IMongoCollection<T> collection, T entity, List<string> properts = null, bool replace = false) where T : ICore
        {
            if (entity == null)
                throw new NullReferenceException();

            var type = entity.GetType();
            ///修改的属性集合
            var list = new List<UpdateDefinition<T>>();

            foreach (var propert in type.GetProperties())
            {
                if (propert.Name.ToLower() != "id")
                {
                     || properts.Any(o => o.ToLower() == propert.Name.ToLower()))
                    {
                        var replaceValue = propert.GetValue(entity);
                        if (replaceValue != null)
                            list.Add(Builders<T>.Update.Set(propert.Name, replaceValue));
                        else if (replace)
                            list.Add(Builders<T>.Update.Set(propert.Name, replaceValue));
                    }
                }
            }
            #region 有可修改的属性
            )
            {
                var builders = Builders<T>.Update.Combine(list);

                collection.UpdateOne(o => o.Id == entity.Id, builders);
            }
            #endregion

        }

        /// <summary>
        /// 异步等同Update方法
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collection"></param>
        /// <param name="entity"></param>
        /// <param name="properts"></param>
        /// <param name="replace"></param>
        /// <returns></returns>
        public static async Task UpdateAsync<T>(this IMongoCollection<T> collection, T entity, List<string> properts = null, bool replace = false) where T : ICore
        {
            if (entity == null)
                throw new NullReferenceException();

            var type = entity.GetType();
            ///修改的属性集合
            var list = new List<UpdateDefinition<T>>();

            foreach (var propert in type.GetProperties())
            {
                if (propert.Name.ToLower() != "id")
                {
                     || properts.Any(o => o.ToLower() == propert.Name.ToLower()))
                    {
                        var replaceValue = propert.GetValue(entity);
                        if (replaceValue != null)
                            list.Add(Builders<T>.Update.Set(propert.Name, replaceValue));
                        else if (replace)
                            list.Add(Builders<T>.Update.Set(propert.Name, replaceValue));
                    }
                }
            }
            #region 有可修改的属性
            )
            {
                var builders = Builders<T>.Update.Combine(list);

                await collection.UpdateOneAsync(o => o.Id == entity.Id, builders);
            }
            #endregion

        }

        public static void Remove<T>(this IMongoCollection<T> collection, T entity) where T : ICore
            => collection.DeleteOne(o => o.Id == entity.Id);

        public static void RemoveById<T>(this IMongoCollection<T> collection, string id) where T : ICore
           => collection.DeleteOne(Builders<T>.Filter.Eq("Id", id));

        public static async Task RemoveAsync<T>(this IMongoCollection<T> collection, T entity) where T : ICore
            => await collection.DeleteOneAsync(o => o.Id == entity.Id);

        public static async Task RemoveAsyncById<T>(this IMongoCollection<T> collection, string id) where T : ICore
           => await collection.DeleteOneAsync(Builders<T>.Filter.Eq("Id", id));

        public static FilterDefinition<T> CombineToFilter<T>(this List<FilterDefinition<T>> list)
            => Builders<T>.Filter.And(list);

        public static void RemoveRange<T>(this IMongoCollection<T> collection, List<T> entitys) where T : ICore
        {
            )
                throw new NullReferenceException();
            collection.DeleteMany(Builders<T>.Filter.In("Id", entitys.Select(o => o.Id)));
        }

        public static async Task RemoveRangeAsync<T>(this IMongoCollection<T> collection, List<T> entitys) where T : ICore
        {
            )
                throw new NullReferenceException();
            await collection.DeleteManyAsync(Builders<T>.Filter.In("Id", entitys.Select(o => o.Id)));
        }

        public static T FindDefault<T>(this IMongoCollection<T> collection, string Id) where T : ICore
            => collection.Find(o => o.Id == Id).FirstOrDefault();

        public static IList<T> FindAll<T>(this IMongoCollection<T> collection, bool sort = false) where T : ICore
           => sort ? collection.Find(Builders<T>.Filter.Empty).SortBy(o => o.CreateTime).ToList() : collection.Find(Builders<T>.Filter.Empty).ToList();

        public static IList<T> FindAllSort<T>(this IMongoCollection<T> collection, Expression<Func<T, object>> sort = null) where T : ICore
           => sort == null ? collection.Find(Builders<T>.Filter.Empty).ToList() : collection.Find(Builders<T>.Filter.Empty).SortBy(sort).ToList();

        public static IFindFluent<T, T> FindDefault<T>(this IMongoCollection<T> collection) where T : ICore
           => collection.Find(Builders<T>.Filter.Empty);

        public static IFindFluent<T, T> Where<T>(this IMongoCollection<T> collection, Expression<Func<T, bool>> where) where T : ICore
          => where == null ? collection.Find(Builders<T>.Filter.Empty) : collection.Find(where);

        public static IFindFluent<TDocument, TNewProjection> Select<TDocument, TProjection, TNewProjection>(this IFindFluent<TDocument, TProjection> IQueryable, Expression<Func<TDocument, TNewProjection>> projection)
           => IQueryable.Project(projection);

        public static IFindFluent<TDocument, TNewProjection> PageSize<TDocument, TNewProjection>(this IFindFluent<TDocument, TNewProjection> IQueryable, Search search)
        => IQueryable.Skip((search.Args.PageIndex - ) * search.Args.PageSize).Limit(search.Args.PageSize);
    }

仓储

 public interface IRepository<T> where T : ICore
    {

        /// <summary>
        /// 查询单个对象
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        T FindById(string id);

        /// <summary>
        /// 查询单个对象
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        T FirstOrDefault(System.Linq.Expressions.Expression<Func<T, bool>> where);

        IFindFluent<T, T> FindFiter(FilterDefinition<T> filter);

        /// <summary>
        /// 获取所有
        /// </summary>
        /// <returns></returns>
        IList<T> GetList();

        /// <summary>
        /// 根据条件查询所有
        /// </summary>
        /// <param name="where"></param>
        /// <returns></returns>
        IList<T> GetList(System.Linq.Expressions.Expression<Func<T, bool>> where);

        IList<T> GetListOrderBy();

        /// <summary>
        /// 单个实体
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        void Insert(T entity);

        /// <summary>
        /// 批量添加
        /// </summary>
        /// <param name="entitys"></param>
        /// <returns></returns>
        void BulkInsert(List<T> entitys);

        /// <summary>
        /// 修改单个实体
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        void Update(T entity);

        /// <summary>
        /// 批量修改
        /// </summary>
        /// <param name="entitys"></param>
        /// <returns></returns>
        void BulkUpdate(List<T> entitys);

        Result AddResultEntity(T t);

        Result UpdateResultEntity(T t, List<string> propertys = null, bool replace = false);

        Result RemoveResultEntity(T t);

        FilterDefinition<T> ConverToFilter(Filter filter);

        PageArgs GetPageArgs(Search search);
    }

实现

   public abstract class Repository<T, K> : IRepository<K> where T : IDataBaseCore where K : ICore
    {
        public Repository()
        {
            if (MongodbContext == null)
                MongodbContext = new MongodbContext<T>();
        }

        protected IMongoCollection<K> Collection { get => MongodbContext.DbSet<K>(); }

        protected FilterDefinition<K> FilterEmpty { set; get; } = Builders<K>.Filter.Empty;

        protected static MGDataChannel.Realize.MongodbContext<T> MongodbContext { set; get; }

        public K FindById(string id)
        => MongodbContext.DbSet<K>().FindDefault(id);

        public K FirstOrDefault(Expression<Func<K, bool>> where)
        => MongodbContext.DbSet<K>().Find(where).FirstOrDefault();

        public IFindFluent<K, K> FindFiter(FilterDefinition<K> filter)
        => MongodbContext.DbSet<K>().Find(filter);

        public async Task<IAsyncCursor<K>> FindFiterAsync(FilterDefinition<K> filter)
        => await MongodbContext.DbSet<K>().FindAsync(filter);

        public virtual IList<K> GetList()
        => MongodbContext.DbSet<K>().Find(Builders<K>.Filter.Empty).ToList();

        public virtual IList<K> GetListOrderBy()
       => MongodbContext.DbSet<K>().Find(Builders<K>.Filter.Empty).SortBy(o => o.CreateTime).ToList();

        public virtual IList<K> GetList(Expression<Func<K, bool>> where)
        => MongodbContext.DbSet<K>().Find(where).ToList();

        public virtual FilterDefinition<K> ConverToFilter(Filter filter)
        {
            if (!string.IsNullOrEmpty(filter.Value))
            {
                if (filter.Key.ToLower() == "id")
                    return Builders<K>.Filter.Eq("Id", filter.Value);
                else if (filter.Key.ToLower() == "name")
                    return Builders<K>.Filter.Where(o => o.Name.Contains(filter.Value.ToString()));
                else if (filter.Key.ToLower() == "stardate")
                    return Builders<K>.Filter.Gte("StarDate", Convert.ToDateTime(filter.Value));//$gte
                else if (filter.Key.ToLower() == "enddate")
                    return Builders<K>.Filter.Lte("EndDate", Convert.ToDateTime(filter.Value));//$gte
            }
            return Builders<K>.Filter.Empty;
        }

        protected virtual FilterDefinition<K> GetFilters(Search search, Func<Filter, FilterDefinition<K>> fun)
        {
            var filters = new List<FilterDefinition<K>>();
            search.Filters.ForEach(o =>
            {
                filters.Add(fun(o));
            });
            )
                return Builders<K>.Filter.Empty;
            ///过滤条件合并
            var filter = filters.CombineToFilter();

            return filter;
        }

        public virtual void Insert(K entity)
        => MongodbContext.DbSet<K>().Add(entity);

        public virtual void BulkInsert(List<K> entitys)
        => MongodbContext.DbSet<K>().AddRange(entitys);

        public virtual void Update(K entity)
        => MongodbContext.DbSet<K>().Update(entity);

        public virtual void Update(K entity, List<string> propertys = null, bool replace = false)
        => MongodbContext.DbSet<K>().Update(entity, propertys, replace);

        public virtual void BulkUpdate(List<K> entitys)
        {
            throw new NotImplementedException();
        }

        public virtual Result AddResultEntity(K t)
        {
            Insert(t);
            return new Result(true, t, "");
        }

        public virtual Result UpdateResultEntity(K t, List<string> propertys = null, bool replace = false)
        {
            Update(t, propertys, replace);
            return new Result(true, t, "");
        }

        public virtual Result RemoveResultEntity(K t)
        {
            throw new NotImplementedException();
        }

        public virtual PageArgs GetPageArgs(Search search)
        {
            ///获取过滤条件
            var filter = this.GetFilters(search, this.ConverToFilter);

            var query = this.FindFiter(filter);

            ///总记录数
            int recordCount = (int)query.Count();

            PageArgs args = new PageArgs(recordCount, search.Args.PageIndex, search.Args.PageSize);

            )
            {
                var data = query.PageSize(search).ToList();
                args.Data = data;
            }
            return args;
        }
    }

此客户端驱动是基于最新的mongodbC#客户端驱动封装的 可能和以前的一些方法不太一样

c# 操作monogodb的一些简单封装的更多相关文章

  1. C#操作SQLServer的一个简单封装

    class DBHandler { //SqlConnection数据库连接对象 private SqlConnection localConnection = null; //构造函数中初始化连接对 ...

  2. Golang 对MongoDB的操作简单封装

    使用MongoDB的Go驱动库 mgo,对MongoDB的操作做一下简单封装 初始化 操作没有用户权限的MongoDB var globalS *mgo.Session func init() { s ...

  3. redis数据库操作的C++简单封装

    用c++简单封装了redis的基本操作(hiredis) 接口包括:①链接和断开连接.②设置键值对(set).③查询键值对(get).④删除键值对(del).⑤将所有键显示出来 若任何一处发生错误,返 ...

  4. Android AsyncTask 深度理解、简单封装、任务队列分析、自定义线程池

    前言:由于最近在做SDK的功能,需要设计线程池.看了很多资料不知道从何开始着手,突然发现了AsyncTask有对线程池的封装,so,就拿它开刀,本文将从AsyncTask的基本用法,到简单的封装,再到 ...

  5. FMDB简单封装和使用

    工具:火狐浏览器+SQLite Manager插件 ; Xcode; FMDB库; 效果: 项目地址: https://github.com/sven713/PackFMDB 主要参考这两篇博客: 1 ...

  6. OracleHelper(对增删改查分页查询操作进行了面向对象的封装,对批量增删改操作的事务封装)

    公司的一个新项目使用ASP.NET MVC开发,经理让我写个OracleHelper,我从网上找了一个比较全的OracleHelper类,缺点是查询的时候返回DataSet,数据增删改要写很多代码(当 ...

  7. iOS sqlite 增删改查 简单封装(基于 FMDB)

    /** *  对 sqlite 的使用进行简单封装,仅涉及简单的单表 增删改查 * *  基于 FMDB * *  操作基于 model ,数据库表字段与 model 属性一一对应,对 model 整 ...

  8. ADO简单封装(MFC)

    简单封装了一下,不是很严谨. /************************************************************************/ /* INSTRUC ...

  9. MySQL的C++简单封装

    /* *介绍:MySQL的简单封装,支持流操作输入输出MySQL语句,然而并没有什么软用,大二学生自娱自乐,有不足求指点 *作者:MrEO *日期:2016.3.26 */ 头文件 my_sql.h ...

随机推荐

  1. [笔记]LR和SVM的相同和不同

    之前一篇博客中介绍了Logistics Regression的理论原理:http://www.cnblogs.com/bentuwuying/p/6616680.html. 在大大小小的面试过程中,经 ...

  2. CSS.04 -- 浮动float、overflow、定位position、CSS初始化

    标准流:行内/行内块元素横向有序排列 : 块元素纵向有序排列. 浮动:Float 语法:float:left/right :  设置浮动的元素,脱离标准流 浮动的框可以向左或向右移动,直到它的外边缘碰 ...

  3. 高并发场景之RabbitMQ篇

    上次我们介绍了在单机.集群下高并发场景可以选择的一些方案,传送门:高并发场景之一般解决方案 但是也发现了一些问题,比如集群下使用ConcurrentQueue或加锁都不能解决问题,后来采用Redis队 ...

  4. 测试开发Python培训:自动发布新浪微博-技术篇

    测试开发Python培训:自动发布新浪微博-技术篇   在前面我们教大家如何登陆,大家需要先看自动登陆新浪微博(http://www.cnblogs.com/laoli0201/articles/48 ...

  5. 在hive中直接对timestamp类型取max报错

    之前直接对timestamp类型做max操作, select id,max(updatetime) updatetime from his.tag group by id; 结果查询的结果有的显示为1 ...

  6. 通过php动态传数据到highcharts

    1:在平时工作中,在对数据进行展示的时候,是直接通过后台提供的接口来获取json串,用来展示.今天别人问怎么在本地演示一下请求的动态数据. 2:在本地搭建环境,我用的WampServer,下载地址:h ...

  7. This Handler class should be static or leaks might occur(null) 解决办法 (转)

    原文链接:http://blog.csdn.net/wuleihenbang/article/details/17126371 首先解释下这句话This Handler class should be ...

  8. Ubuntu16.04部署python2和python3共存的Jupyter Notebook

    一.安装python和python-pip sudo apt-get install python python3 python-pip python3-pip sudo pip install -- ...

  9. 学习react,动手实现一个小demo(仿知乎问答)

    学习react也有一周的时间,最近自己做了个仿知乎问答的小demo,项目源码在github上:https://github.com/yang302/reactQa 使用技术:bower+gulp+re ...

  10. 关于sql语句between and的边界问题

    BETWEEN 操作符 操作符 BETWEEN ... AND 会选取介于两个值之间的数据范围.这些值可以是数值.文本或者日期. SQL BETWEEN 语法 SELECT column_name(s ...