MongoDB之基础学习

一、简介：

 MongoDB是一个分布式基于文件存储的开源数据库系统，可以解决WEB应用高并发以及可扩展的数据存储方案，以文档的形式来存储数据。

二、主要特点：

1.支持分布式。

2.无需预定义表结构，在一个表中可以保存多种格式的数据。

3.支持json格式存储。

4.支持地理信息需索引。

5.操作简单，大数据下性能较高。

三、缺点：

1.关联查询很弱，不适合做报表查询。

2.没有“数据一致性检查”、事务等。

四、应用场景：

1.日志记录系统。

2.监控设备的数据存储。

3.商城商品信息，商家信息。

4.第三方的爬虫数据。

5.缓存数据。

五、基本操作类封装（引用MongoDB.Driver）：

  class MongoDBHelper<T> where T : class, new()
    {
        //服务器操作对象
        private MongoClient client = null;
        //数据库
        private IMongoDatabase database = null;
        //数据表
        private IMongoCollection<T> collection = null;

        /// <summary>
        /// 初始化
        /// </summary>
        /// <param name="connString">链接字符串</param>
        /// <param name="dbName">数据库名</param>
        /// <param name="tableName">表名</param>
        public MongoDBHelper(string connString, string dbName, string tableName)
        {
            client = new MongoClient(connString);
            database = client.GetDatabase(dbName);
            collection = database.GetCollection<T>(tableName);
        }

        /// <summary>
        /// 插入一条数据
        /// </summary>
        /// <param name="t"></param>
        /// <param name="tableName"></param>
        public void InsertOne(T t)
        {
            collection.InsertOne(t);
        }

        /// <summary>
        /// 批量插入
        /// </summary>
        /// <param name="ts"></param>
        public void InsertMany(IList<T> ts)
        {
            collection.InsertMany(ts);
        }

        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="whereFun">筛选条件</param>
        /// <param name="updateFun">要更新的字段</param>
        /// <param name="value">要更新的值</param>
        /// <returns></returns>
        public int Update(Expression<Func<T, bool>> whereFun, Expression<Func<T, object>> updateFun, object value)
        {
            var filter = Builders<T>.Filter.Where(whereFun);
            var update = Builders<T>.Update.Set(updateFun, value);
            UpdateResult result = collection.UpdateMany(filter, update);
            return (int)result.ModifiedCount;
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="whereFun">筛选条件</param>
        /// <returns></returns>
        public int Delete(Expression<Func<T, bool>> whereFun)
        {
            var filter = Builders<T>.Filter.Where(whereFun);
            DeleteResult result = collection.DeleteMany(filter);
            return (int)result.DeletedCount;
        }

        /// <summary>
        /// 查询
        /// </summary>
        /// <param name="whereFun">筛选条件</param>
        /// <returns></returns>
        public IList<T> Query(Expression<Func<T, bool>> whereFun)
        {
            var filter = Builders<T>.Filter.Where(whereFun);
            return collection.Find(filter).ToList();
        }

        /// <summary>
        /// 分页查询
        /// </summary>
        /// <param name="whereFun">筛选条件</param>
        /// <param name="ascFun">指定升序</param>
        /// <param name="descFun">指定降序</param>
        /// <param name="startIndex">跳过的条数</param>
        /// <param name="pageCount">取出的条数</param>
        /// <param name="total">总数</param>
        /// <returns></returns>
        public IList<T> PageQuery(Expression<Func<T, bool>> whereFun, int startIndex, int pageCount, out int total,
            Expression<Func<T, object>> ascFun = null, Expression<Func<T, object>> descFun = null)
        {
            total = 0;
            FindOptions<T, T> findOpt = new FindOptions<T, T>();
            findOpt.Skip = startIndex;
            findOpt.Limit = pageCount;
            if (ascFun != null) findOpt.Sort.Ascending(ascFun);
            if (descFun != null) findOpt.Sort.Descending(descFun);
            var filter = Builders<T>.Filter.Where(whereFun);
            total = (int)collection.Find(filter).Count();
            if (total <= 0) return new List<T>();
            using (var result = collection.FindAsync(filter, findOpt).Result)
            {
                return result.ToList();
            }
        }
    }