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. ThinkPHP3.2.3版本验证码异步第二次验证时失败的问题解决

    最近在用TP3.2.3做一个小项目,纠结于验证码验证问题,重点在于二次验证,举个例子就是常见的登录页面上有个验证码输入框,当用户输入验证码并且鼠标点击在这个输入框之外时候,触发onblur事件,然后a ...

  2. poptest老李谈数据库优化总结

    poptest老李谈数据库优化总结   poptest是国内唯一一家培养测试开发工程师的培训机构,以学员能胜任自动化测试,性能测试,测试工具开发等工作为目标.如果对课程感兴趣,请大家咨询qq:9088 ...

  3. display与visibility的使用(区别)

    display:none;隐藏元素,且此元素无物理位置: visibility:hidden;隐藏元素,但元素的物理位置依然存在: 因为display:none导致页面上无此元素的空间,js就获取不到 ...

  4. wireshark filter manualpage

    NAME wireshark-filter - Wireshark filter syntax and reference SYNOPSIS wireshark [other options] [ - ...

  5. WebService基础学习(一)—基础知识

    一.WebService 1.什么是WebService      Web Service(WEB服务)能够快捷和方便地综合结合各种系统.商务和任何应用平台.利用最新的Web Service 标准能够 ...

  6. jmeter 登录并发 (此文章有待修改)

    1.先通过录制通过取样器找到所需要的请求.并新建添加至线程组,也可以根据以下样式找到所需请求.复制添加至线程组 寻找请求 添加后 2.添加CSV配置元件 3.填写CSV参数 4.修改参数.这是格式:& ...

  7. POJ 2585 Window Pains 题解

    链接:http://poj.org/problem?id=2585 题意: 某个人有一个屏幕大小为4*4的电脑,他很喜欢打开窗口,他肯定打开9个窗口,每个窗口大小2*2.并且每个窗口肯定在固定的位置上 ...

  8. 使用HttpClient进行Get方式通信

    下载apache包 http://hc.apache.org/downloads.cgi 比较eclipse自带api,简单,易上手 实例: package zw1; import java.io.I ...

  9. JSON对象、JSON字符串的相互转换

    JSON对象.JSON字符串的相互转换 json的格式: 第一种方式: 单一的json字符串,转换成json对象时,需要 eval('(' + json + ')');这样的格式,中间需要加括号 va ...

  10. 03(3) 基于GMM-HMM的SR基础

    1.GMM-HMM的训练 1)训练GSM-HMM (1)确定HMM拓扑结构 (2)初始化HMM模型参数 (3)在所有的utterances中计算所需的统计量 (4)使用公式更新模型参数 (5)不收敛, ...