使用c#对MongoDB进行查询(1) - 莫问今朝· - 博客园

mikel阅读(919)

来源: 使用c#对MongoDB进行查询(1) – 莫问今朝· – 博客园

1.BsonDocument对象

在MongoDB.Bson命名空间下存在一个BsonDocument类,它是MongoDB的文档对象,代表着MongoDB中不规则数据一条条实体模型。可以使用BsonDocument对不规则数据进行操作,这个类型继承了IEnumberable<>类,也就是说又将每一个实体模型看做一个集合,我们可以使用下标方式获取实体模型中的值

复制代码
     //
        // 摘要:
        //     Gets or sets a value by position.
        //
        // 参数:
        //   index:
        //     The position.
        //
        // 返回结果:
        //     The value.
        public override BsonValue this[int index] { get; set; }
        //
        // 摘要:
        //     Gets or sets a value by name.
        //
        // 参数:
        //   name:
        //     The name.
        //
        // 返回结果:
        //     The value.
        public override BsonValue this[string name] { get; set; }
        //
        // 摘要:
        //     Gets the value of an element or a default value if the element is not found.
        //
        // 参数:
        //   name:
        //     The name of the element.
        //
        //   defaultValue:
        //     The default value to return if the element is not found.
        //
        // 返回结果:
        //     Teh value of the element or a default value if the element is not found.
        [Obsolete("Use GetValue(string name, BsonValue defaultValue) instead.")]
        public virtual BsonValue this[string name, BsonValue defaultValue] { get; }
复制代码

  2.连接配置

复制代码
 //连接地址
        private static string conn = "mongodb://192.168.11.51:40000";
        //数据库名称
        private static string dbName = "yan";
        //集合名称
        private static string colName = "Demo";
        //连接服务端
       static  MongoClient client = new MongoClient(conn);
        //获取指定数据库
       static IMongoDatabase db = client.GetDatabase(dbName);
        //获取指定集合   BsonDocument数据库文档对象
       static  IMongoCollection<BsonDocument> coll = db.GetCollection<BsonDocument>(colName);
复制代码

3.插入数据

复制代码
  var doc = new[]
            {
                new BsonDocument{
                    { "DepartmentName","开发部"},
                    { "People",new  BsonArray
                        {
                            new BsonDocument{ { "Name", "狗娃" },{"Age",20 } },
                             new BsonDocument{ { "Name", "狗剩" },{"Age",22 } },
                              new BsonDocument{ { "Name", "铁蛋" },{"Age",24 } }
                        }
                    },
                    {"Sum",18 },
                      { "dim_cm", new BsonArray { 14, 21 } }


                },
                 new BsonDocument{
                    { "DepartmentName","测试部"},
                    { "People",new  BsonArray
                        {
                            new BsonDocument{ { "Name", "张三" },{"Age",11 } },
                             new BsonDocument{ { "Name", "李四" },{"Age",34 } },
                              new BsonDocument{ { "Name", "王五" },{"Age",33 } }
                        }
                    }
                     ,
                     { "Sum",4 }
                     ,
                       { "dim_cm", new BsonArray { 14, 21 } }

                },
                  new BsonDocument{
                    { "DepartmentName","运维部"},
                    { "People",new  BsonArray
                        {
                            new BsonDocument{ { "Name", "闫" },{"Age",20 } },
                             new BsonDocument{ { "Name", "王" },{"Age",22 } },
                              new BsonDocument{ { "Name", "赵" },{"Age",24 } }
                        }
                    },
                     { "Sum",2 },
                       { "dim_cm", new BsonArray { 22.85, 30 } }

                }
            };

            coll.InsertMany(doc);
复制代码

4.查询

4.1 查询部门是开发部的信息

复制代码
 //创建约束生成器
            FilterDefinitionBuilder<BsonDocument> builderFilter = Builders<BsonDocument>.Filter;
            //约束条件
            FilterDefinition<BsonDocument> filter = builder.Eq("DepartmentName", "开发部");
            //获取数据
            var result = coll.Find<BsonDocument>(filter).ToList();
            foreach (var item in result)
            {
                //取出整条值
                Console.WriteLine(item.AsBsonValue);
            }
复制代码

 4.2 获取Sum大于4的数据

复制代码
 //创建约束生成器
            FilterDefinitionBuilder<BsonDocument> builderFIlter = Builders<BsonDocument>.Filter;
            //约束条件
            FilterDefinition<BsonDocument> filter = builder.Gt("Sum", 4);
            var result = coll.Find<BsonDocument>(filter).ToList();
            foreach (var item in result)
            {
                //取出整条值
                Console.WriteLine(item.AsBsonValue);
            }
复制代码

   4.3 And约束  

复制代码
 //创建约束生成器
            FilterDefinitionBuilder<BsonDocument> builderFilter = Builders<BsonDocument>.Filter;
            //约束条件
            FilterDefinition<BsonDocument> filter = builder.And(builder.Gt("Sum", "2"), builder.Eq("DepartmentName", "运维"));
            var result = coll.Find<BsonDocument>(filter).ToList();
            foreach (var item in result)
            {
                //取出整条值
                Console.WriteLine(item.AsBsonValue);
            }
复制代码

  4.4查询指定值

复制代码
  //创建约束生成器
            FilterDefinitionBuilder<BsonDocument> builderFilter = Builders<BsonDocument>.Filter;
            ProjectionDefinitionBuilder<BsonDocument> builderProjection = Builders<BsonDocument>.Projection;
            //Include 包含某元素    Exclude  不包含某元素
            ProjectionDefinition<BsonDocument> projection = builderProjection.Include("DepartmentName").Exclude("_id");
            var result = coll.Find<BsonDocument>(builderFilter.Empty).Project(projection).ToList();
            foreach (var item in result)
            {
                //取出整条值
                Console.WriteLine(item.AsBsonValue);
            }
复制代码

4.5 排序

复制代码
 //创建生成器
            FilterDefinitionBuilder<BsonDocument> builderFilter = Builders<BsonDocument>.Filter;
            //排序生成器
            SortDefinitionBuilder<BsonDocument> builderSort = Builders<BsonDocument>.Sort;
            //排序约束   Ascending 正序    Descending 倒序
            SortDefinition<BsonDocument> sort = builderSort.Ascending("Sum");
            var result = coll.Find<BsonDocument>(builderFilter.Empty).Sort(sort).ToList();
            foreach (var item in result)
            {
                //取出整条值
                Console.WriteLine(item.AsBsonValue);
            }
复制代码

  4.6 In查询

复制代码
  //创建生成器
            FilterDefinitionBuilder<BsonDocument> builderFilter = Builders<BsonDocument>.Filter;
            FilterDefinition<BsonDocument> filter = builderFilter.In("DepartmentName", new[] { "测试部", "开发部" });
            var result = coll.Find<BsonDocument>(filter).ToList();
            foreach (var item in result)
            {
                //取出整条值
                Console.WriteLine(item.AsBsonValue);
            }
复制代码

   4.7  分页查询

复制代码
 //创建生成器
            FilterDefinitionBuilder<BsonDocument> builderFilter = Builders<BsonDocument>.Filter;
            //分页   Skip 跳过  Limit查询多少
            var result = coll.Find<BsonDocument>(builderFilter.Empty).Skip(1).Limit(1).ToList();
            foreach (var item in result)
            {
                //取出整条值
                Console.WriteLine(item.AsBsonValue);
            }
复制代码

  4.8查询总条目数

 //创建生成器
            FilterDefinitionBuilder<BsonDocument> builderFilter = Builders<BsonDocument>.Filter;
            //总条目数
            var result = coll.Find<BsonDocument>(builderFilter.Empty).Count();

 4.9Linq查询

复制代码
 //创建生成器//linq
            var result = from y in coll.AsQueryable() select new { DepartmentName = y["DepartmentName"], id = y["_id"] };
            foreach (var item in result)
            {

                Console.WriteLine("DepartmentName:" + item.DepartmentName + "====Id:"+item.id);
            }
复制代码

   4.10分组查询

复制代码
 //创建生成器
            FilterDefinitionBuilder<BsonDocument> builderFilter = Builders<BsonDocument>.Filter;
            //分组
            var result = from y in coll.AsQueryable()  group y by  y["DepartmentName"] into s select new { DepartmentName = s.Key, Count = s.Count() };
            foreach (var item in result)
            {

                Console.WriteLine("DepartmentName:" + item.DepartmentName + "====Count:"+item.Count);
            }
复制代码

  4.11连表查询

复制代码
 //linq
            //连表查询   在这里是自己连自己
            var result = from u in coll.AsQueryable() join o in coll.AsQueryable() on u["_id"] equals o["_id"] select new { DepartmentName1 = u["DepartmentName"], DepartmentName2 = u["DepartmentName"] };
            foreach (var item in result)
            {

                Console.WriteLine("DepartmentName1:" + item.DepartmentName1 + "====DepartmentName2:" + item.DepartmentName2);
            }
复制代码

 

c#驱动操作mongodb辅助类MongoDBHelper - AndyQ - 博客园

mikel阅读(1145)

FilterDefinition

来源: c#驱动操作mongodb辅助类MongoDBHelper – AndyQ – 博客园

C#驱动操作mongodb辅助类MongoDBHelper

复制代码
using MongoDB.Bson;
using MongoDB.Driver;
using System;
using System.Collections.Generic;
 
/*
https://docs.mongodb.com/manual/tutorial/update-documents/
https://docs.mongodb.com/manual/tutorial/perform-two-phase-commits/
https://docs.mongodb.com/manual/reference/command/dropDatabase/index.html
https://docs.mongodb.com/manual/reference/command/listCommands/
*/
 
namespace MongoDbHelper
{
    public class MongoDBHelper
    {
        private string databaseName = string.Empty;
        private IMongoClient client = null;
        private IMongoDatabase database = null;
 
        public MongoDBHelper(string connectionString)
        {
            client = new MongoClient(connectionString);
        }
 
        public MongoDBHelper(string connectionString, string databaseName)
        {
            client = new MongoClient(connectionString);
            database = client.GetDatabase(databaseName);
        }
 
        public string DatabaseName
        {
            get { return databaseName; }
            set
            {
                databaseName = value;
                database = client.GetDatabase(databaseName);
            }
        }
 
        /// <summary>
        /// 执行命令,命令请参考MongoCommand,命令太多,不一一展示,传入的就是里面的字符串,有些命令执行需要连接到admin表
        /// </summary>
        /// <param name="cmdText"></param>
        /// <returns></returns>
        public BsonDocument RunCommand(string cmdText)
        {
            return database.RunCommand<BsonDocument>(cmdText);
        }
 
        public IList<BsonDocument> GetDatabase()
        {
            return client.ListDatabases().ToList();
        }
 
        #region SELECT
        /// <summary>
        /// 判断文档存在状态
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="filterexist"></param>
        /// <returns></returns>
        public bool IsExistDocument<T>(string documentname, FilterDefinition<T> filter)
        {
            return database.GetCollection<T>(documentname).Count(filter) > 0;
        }
 
        /// <summary>
        /// 通过条件得到查询的结果个数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="filter"></param>
        /// <returns></returns>
        public long GetCount<T>(string documentname, FilterDefinition<T> filter)
        {
            return database.GetCollection<T>(documentname).Count(filter);
        }
 
        /// <summary>
        /// 通过系统id(ObjectId)获取一个对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        public T GetDocumentById<T>(string documentname, string id)
        {
            ObjectId oid = ObjectId.Parse(id);
            var filter = Builders<T>.Filter.Eq("_id", oid);
            var result = database.GetCollection<T>(documentname).Find(filter);
            return result.FirstOrDefault();
        }
 
        /// <summary>
        /// 通过系统id(ObjectId)获取一个对象同时过滤字段
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="id"></param>
        /// <param name="fields"></param>
        /// <returns></returns>
        public T GetDocumentById<T>(string documentname, string id, ProjectionDefinition<T> fields)
        {
            ObjectId oid = ObjectId.Parse(id);
            var filter = Builders<T>.Filter.Eq("_id", oid);
            return database.GetCollection<T>(documentname).Find(filter).Project<T>(fields).FirstOrDefault();
        }
 
        /// <summary>
        /// 通过指定的条件获取一个对象,如果有多条,只取第一条,同时过滤字段
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="filter"></param>
        /// <param name="fields"></param>
        /// <returns></returns>
        public T GetDocumentByUserFilter<T>(string documentname, FilterDefinition<T> filter, ProjectionDefinition<T> fields)
        {
            return database.GetCollection<T>(documentname).Find(filter).Project<T>(fields).FirstOrDefault();
        }
 
        /// <summary>
        /// 获取全部文档
        /// </summary>
        /// <typeparam name="T"></typeparam>       
        /// <param name="documentname"></param>
        /// <returns></returns>
        public IList<T> GetAllDocuments<T>(string documentname)
        {
            var filter = Builders<T>.Filter.Empty;
            return database.GetCollection<T>(documentname).Find(filter).ToList();
        }
 
        /// <summary>
        /// 获取全部文档同时过滤字段
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="fields">要获取的字段</param>
        /// <returns></returns>
        public IList<T> GetAllDocuments<T>(string documentname, ProjectionDefinition<T> fields)
        {
            var filter = Builders<T>.Filter.Empty;
            return database.GetCollection<T>(documentname).Find(filter).Project<T>(fields).ToList();
        }
 
        /// <summary>
        /// 通过一个条件获取对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="property">字段名</param>
        /// <param name="value">字段值</param>
        /// <returns></returns>
        public IList<T> GetDocumentsByFilter<T>(string documentname, string property, string value)
        {
            FilterDefinition<T> filter = Builders<T>.Filter.Eq(property, value);
            return database.GetCollection<T>(documentname).Find(filter).ToList();
        }
 
        /// <summary>
        /// 通过条件获取对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="filter"></param>
        /// <returns></returns>
        public IList<T> GetDocumentsByFilter<T>(string documentname, FilterDefinition<T> filter)
        {
            return database.GetCollection<T>(documentname).Find(filter).ToList();
        }
 
        /// <summary>
        /// 通过条件获取对象,同时过滤字段
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="property">字段名</param>
        /// <param name="value">字段值</param>
        /// <param name="fields">要获取的字段</param>
        /// <returns></returns>
        public IList<T> GetDocumentsByFilter<T>(string documentname, string property, string value, ProjectionDefinition<T> fields)
        {
            FilterDefinition<T> filter = Builders<T>.Filter.Eq(property, value);
            return database.GetCollection<T>(documentname).Find(filter).Project<T>(fields).ToList();
        }
 
        /// <summary>
        /// 通过条件获取对象,同时过滤数据和字段
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="filter">过滤器</param>
        /// <param name="fields">要获取的字段</param>
        /// <returns></returns>
        public IList<T> GetDocumentsByFilter<T>(string documentname, FilterDefinition<T> filter, ProjectionDefinition<T> fields)
        {
            return database.GetCollection<T>(documentname).Find(filter).Project<T>(fields).ToList();
        }
 
        /// <summary>
        /// 通过条件获取分页的文档并排序
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="filter"></param>
        /// <param name="sort"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        public IList<T> GetPagedDocumentsByFilter<T>(string documentname, FilterDefinition<T> filter, ProjectionDefinition<T> fields, SortDefinition<T> sort, int pageIndex, int pageSize)
        {
            IList<T> result = new List<T>();
            if (pageIndex != 0 && pageSize != 0)
            {
                result = database.GetCollection<T>(documentname).Find(filter).Project<T>(fields).Sort(sort).Skip(pageSize * (pageIndex - 1)).Limit(pageSize).ToList();
            }
            else
            {
                result = database.GetCollection<T>(documentname).Find(filter).Project<T>(fields).Sort(sort).ToList();
            }
            return result;
        }
 
        /// <summary>
        /// 通过条件获取分页的文档并排序
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="filter"></param>
        /// <param name="sort"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        public IList<T> GetPagedDocumentsByFilter<T>(string documentname, FilterDefinition<T> filter, SortDefinition<T> sort, int pageIndex, int pageSize)
        {
            IList<T> result = new List<T>();
            if (pageIndex != 0 && pageSize != 0)
            {
                result = database.GetCollection<T>(documentname).Find(filter).Sort(sort).Skip(pageSize * (pageIndex - 1)).Limit(pageSize).ToList();
            }
            else
            {
                result = database.GetCollection<T>(documentname).Find(filter).Sort(sort).ToList();
            }
            return result;
        }
 
        /// <summary>
        /// 通过条件获取分页的文档
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="filter"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        public IList<T> GetPagedDocumentsByFilter<T>(string documentname, FilterDefinition<T> filter, int pageIndex, int pageSize)
        {
            IList<T> result = new List<T>();
            if (pageIndex != 0 && pageSize != 0)
            {
                result = database.GetCollection<T>(documentname).Find(filter).Skip(pageSize * (pageIndex - 1)).Limit(pageSize).ToList();
            }
            else
            {
                result = database.GetCollection<T>(documentname).Find(filter).ToList();
            }
            return result;
        }
 
        /// <summary>
        /// 获取分页的文档
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        public IList<T> GetPagedDocumentsByFilter<T>(string documentname, SortDefinition<T> sort, int pageIndex, int pageSize)
        {
            IList<T> result = new List<T>();
            var filter = Builders<T>.Filter.Empty;
            if (pageIndex != 0 && pageSize != 0)
            {
                result = database.GetCollection<T>(documentname).Find(filter).Sort(sort).Skip(pageSize * (pageIndex - 1)).Limit(pageSize).ToList();
            }
            else
            {
                result = database.GetCollection<T>(documentname).Find(filter).Sort(sort).ToList();
            }
            return result;
        }
 
        /// <summary>
        /// 获取分页的文档
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        public IList<T> GetPagedDocumentsByFilter<T>(string documentname, int pageIndex, int pageSize)
        {
            IList<T> result = new List<T>();
            var filter = Builders<T>.Filter.Empty;
            if (pageIndex != 0 && pageSize != 0)
            {
                result = database.GetCollection<T>(documentname).Find(filter).Skip(pageSize * (pageIndex - 1)).Limit(pageSize).ToList();
            }
            else
            {
                result = database.GetCollection<T>(documentname).Find(filter).ToList();
            }
            return result;
        }
        #endregion
 
        #region INSERT
 
        /// <summary>
        /// 新增
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="document"></param>
        /// <param name="filter"></param>
        /// <returns></returns>
        public void Insert<T>(string documentName, T document)
        {
            try
            {
                database.GetCollection<T>(documentName).InsertOne(document);
            }
            catch (MongoWriteException me)
            {
                MongoBulkWriteException mbe = me.InnerException as MongoBulkWriteException;
                if (mbe != null && mbe.HResult == -2146233088)
                    throw new Exception("插入重复的键!");
                throw new Exception(mbe.Message);
            }
            catch (Exception ep)
            {
                throw ep;
            }
        }
 
        /// <summary>
        /// 新增多个文档
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="documents"></param>
        /// <returns></returns>
        public void InsertMany<T>(string documentname, IList<T> documents)
        {
            try
            {
                database.GetCollection<T>(documentname).InsertMany(documents);
            }
            catch (MongoWriteException me)
            {
                MongoBulkWriteException mbe = me.InnerException as MongoBulkWriteException;
                if (mbe != null && mbe.HResult == -2146233088)
                    throw new Exception("插入重复的键!");
                throw new Exception(mbe.Message);
            }
            catch (Exception ep)
            {
                throw ep;
            }
        }
        #endregion
 
        #region UPDATE
        /// <summary>
        /// 修改
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="filterexist"></param>
        /// <param name="id"></param>
        /// <param name="oldinfo"></param>
        /// <returns></returns>
        public void UpdateReplaceOne<T>(string documentname, string id, T oldinfo)
        {
            ObjectId oid = ObjectId.Parse(id);
            var filter = Builders<T>.Filter.Eq("_id", oid);
            database.GetCollection<T>(documentname).ReplaceOne(filter, oldinfo);
        }
 
        /// <summary>
        /// 只能替换一条,如果有多条的话
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="filter"></param>
        /// <param name="oldinfo"></param>
        public void UpdateReplaceOne<T>(string documentname, FilterDefinition<T> filter, T oldinfo)
        {
            database.GetCollection<T>(documentname).ReplaceOne(filter, oldinfo);
        }
 
        /// <summary>
        /// 更新指定属性值,按ID就只有一条,替换一条
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="id"></param>
        /// <param name="setvalue"></param>
        /// <returns></returns>
        public void Update<T>(string documentname, string id, string property, string value)
        {
            ObjectId oid = ObjectId.Parse(id);
            var filter = Builders<T>.Filter.Eq("_id", oid);
            var update = Builders<T>.Update.Set(property, value);
            database.GetCollection<T>(documentname).UpdateOne(filter, update);
        }
 
        public void Update<T>(string documentname, FilterDefinition<T> filter, UpdateDefinition<T> update)
        {
            database.GetCollection<T>(documentname).UpdateOne(filter, update);
        }
 
        public void UpdateMany<T>(string documentname, FilterDefinition<T> filter, UpdateDefinition<T> update)
        {
            database.GetCollection<T>(documentname).UpdateMany(filter, update);
        }
 
        #endregion
 
        #region DELETE
        /// <summary>
        /// 删除一个文档
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        public void Delete<T>(string documentname, string id)
        {
            ObjectId oid = ObjectId.Parse(id);
            var filterid = Builders<T>.Filter.Eq("_id", oid);
            database.GetCollection<T>(documentname).DeleteOne(filterid);
        }
 
        public void Delete<T>(string documentname, string property, string value)
        {
            FilterDefinition<T> filter = Builders<T>.Filter.Eq(property, value);
            database.GetCollection<T>(documentname).DeleteOne(filter);
        }
 
        /// <summary>
        /// 通过一个属性名和属性值删除多个文档
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        public void DeleteMany<T>(string documentname, string property, string value)
        {
            FilterDefinition<T> filter = Builders<T>.Filter.Eq(property, value);
            database.GetCollection<T>(documentname).DeleteMany(filter);
        }
 
        /// <summary>
        /// 通过一个属性名和属性值删除多个文档
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="filter"></param>
        /// <returns></returns>
        public void DeleteMany<T>(string documentname, FilterDefinition<T> filter)
        {
            database.GetCollection<T>(documentname).DeleteMany(filter);
        }
        #endregion
 
        /// <summary>
        /// 有些命令要求你连到系统库上才能执行
        /// You need to link to the admin table if you want to run system command;eg:listDatabases ,the following url show you the details
        /// https://docs.mongodb.com/manual/reference/command/listCommands/
        /// </summary>
        public sealed class MongoCommand
        {
            public const string ListDatabases = "{listDatabases:1}";
            public const string ListCommands = "{ listCommands: 1 }";
        }
    }
}
复制代码

 

MongoDB 工具助手类(.NET) - jiangys - 博客园

mikel阅读(730)

来源: MongoDB 工具助手类(.NET) – jiangys – 博客园

在开发过程中,需要用到MongoDB,本身MongoDB自己对类的封装就特别好了。为了更加符合我们平时的开发使用,我现在进行了一个简单的封装操作。

连接数据库类:MongoDBContext

复制代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Configuration;

using MongoDB.Bson;
using MongoDB.Driver;
using MongoDB.Driver.Builders;
using MongoDB.Driver.Linq;

namespace XXXXX.MongoDB
{
    public class MongoDBContext
    {
        // 数据库链接
        private readonly MongoDatabase database;

        public MongoDBContext()
            : this(ConfigurationManager.AppSettings["DefaultMongoDBConnection"], ConfigurationManager.AppSettings["DefaultMonoDbDatabase"])
        {
        }

        /// <summary>
        /// 构造函数。根据指定连接字符串和数据库名
        /// </summary>
        /// <param name="connectionString">连接字符串</param>
        /// <param name="dbName">数据库名</param>
        public MongoDBContext(string connectionString, string dbName)
        {
            if (string.IsNullOrEmpty(connectionString))
            {
                throw new ArgumentNullException("connectionString is null");
            }

            if (string.IsNullOrEmpty(dbName))
            {
                throw new ArgumentNullException("dbName is null");
            }

            var client = new MongoClient(connectionString);
            var server = client.GetServer();
            this.database = server.GetDatabase(dbName);
        }

        /// <summary>
        /// 获取当前连接数据库的指定集合【依据类型】
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public MongoCollection<T> Collection<T>()
        {
            return database.GetCollection<T>(typeof(T).Name);
        }
    }
}
复制代码

服务操作类:MongoDBService

复制代码
using MongoDB.Driver.Builders;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace XXXXX.MongoDB
{

    public class MongoDBService<T> : IMongoDBService<T> where T : class,new()
    {
        MongoDBContext mc = new MongoDBContext();

        /// <summary>
        /// 查询符合条件的集合
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        public IEnumerable<T> GetList()
        {
            var query = Query<T>.Where(o => true);
            return mc.Collection<T>().Find(query);
        }

        /// <summary>
        /// 查询符合条件的集合
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        public IEnumerable<T> GetList(Expression<Func<T, bool>> whereLambda)
        {
            var query = Query<T>.Where(whereLambda);
            return mc.Collection<T>().Find(query);
        }

        /// <summary>
        /// 查询一条记录
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        public T GetOne(Expression<Func<T, bool>> whereLambda)
        {
            var query = GetList(whereLambda).FirstOrDefault();
            return query;
        }

        /// <summary>
        /// 增加
        /// </summary>
        /// <param name="entity"></param>
        public void Insert(T entity)
        {
            mc.Collection<T>().Insert(entity);
        }

        /// <summary>
        /// 批量增加
        /// </summary>
        /// <param name="entitys"></param>
        public void InsertAll(IEnumerable<T> entitys)
        {
            mc.Collection<T>().InsertBatch(entitys);
        }

        /// <summary>
        /// 更新一个实体
        /// </summary>
        /// <param name="entity"></param>
        public void Update(T entity)
        {
            mc.Collection<T>().Save(entity);
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="whereLambda"></param>
        public void Remove(Expression<Func<T, bool>> whereLambda)
        {
            var query = Query<T>.Where(whereLambda);
            mc.Collection<T>().Remove(query);
        }
    }
}
复制代码

上面方法封装完后,我们就可以直接使用了。使用很简单,比如,我有一个ActivityModel实体,使用时,如下:

复制代码
        public void activityTest()
        {
            var activityDb = new MongoDBService<ActivityModel>();
            var activityList = activityDb.GetList().ToList();
            var activity = activityDb.GetOne(o => o.Id==ObjectId.Parse("54d9aecd89f0bd14d81a63a7"));
            var xxx = activity.To();
        }
复制代码

 

双十一来了,别让你的mongodb宕机了 - 一线码农 - 博客园

mikel阅读(846)

来源: 双十一来了,别让你的mongodb宕机了 – 一线码农 – 博客园

 

好久没过来吹牛了,前段时间一直赶项目,没有时间来更新博客,项目也终于赶完了,接下来就要面临双十一这场惊心动魄的处女秀考验,

我们项目中会有一个wcf集群,而集群地址则放在mongodb中,所以mongodb的核心地位可想而知,如果mongodb挂掉,整个项目也就陷入

瘫痪,想让mongodb不宕机,最简单的方法就是要做双机热备,跟传统的关系型数据库的双机热备模式一样,一个主服务器,一个备份服务器,

一个仲裁服务器。如果热备集群中的主服务器宕掉,会有仲裁服务器参与投票来选出一台作为主服务器,我想这个大家都比较清楚,下面我们来

实战一下,最后会奉献源代码。

 

一:搭建mongodb热备集群

1. 准备工作

为了做到最简化搭建,我就做一个主,一个备,一个仲裁就好了,然后最简化配置信息都放在mongodb.conf文件中,如下图:

 

从上图中可以看到,三个mongodb,我建立了对应的三个文件夹来存放对应的三个db,其中“主服务器”的端口为27000,“备服务器“的端口为

27001,”仲裁服务器“端口为27002。 具体mongodb.conf内容如下:

 

2. 开启 “主服务器” 【27000】

 

3.  开启 “备服务器” 【27001】

 

4.  开启 “仲裁服务器” 【27002】

 

现在三台服务器都开启起来了,细心的你会发现,三个控制台都有这么一段英文单词” replSet info you may need to run replSetInitiate“。。。

既然都这么说了,我现在就去run这个func。

 

复制代码
db.runCommand({
    "replSetInitiate":{
        "_id":"datamip",
        "members":[
            {
                "_id":1,
                "host":"127.0.0.1:27000"
            },
            {
                "_id":2,
                "host":"127.0.0.1:27001"
            }
        ]
    }
})
复制代码

 

配置完了之后,然后我们把“仲裁服务器【27002】”加入到“datamip”这个双机热备分集群中。

 

rs.addArb( { host: "127.0.0.1:27002"} )

 

这个命令可以参考下官网的介绍:https://docs.mongodb.com/manual/reference/command/replSetInitiate/   好了,现在大致配置好了,接下

来我们用rs.Status()来查看下当前“主,备,仲裁”的分布情况。

 

从图中你应该看到了【27000】成为了主服务器,【27001】成为了备服务器,【27002】成为了仲裁服务器,到目前为止,搭建完成,是不是有

一个很爽的感觉呢???

 

三:使用驱动

既然mongodb的双机热备已经做好了,我们驱动也必须支持,这样我们才能够嗨,对伐???其实在配置中使用也很简单,里面有一个

MongoClientSettings,你需要配置一下”ReplicaSetName“和”Servers“列表即可,核心代码如下:

复制代码
 1         static MongoDBHelper()
 2         {
 3             var ips = connectionString.Split(';');
 4 
 5             var servicesList = new List<MongoServerAddress>();
 6 
 7             foreach (var ip in ips)
 8             {
 9                 var host = ip.Split(':')[0];
10                 var port = Convert.ToInt32(ip.Split(':')[1]);
11 
12                 servicesList.Add(new MongoServerAddress(host, port));
13             }
14 
15             setting = new MongoClientSettings();
16             setting.ReplicaSetName = "datamip";
17 
18             //集群中的服务器列表
19             setting.Servers = servicesList;
20         }
复制代码

 

其中ips的信息是配置在app.config中。

 <appSettings>
    <add key="mongodbServerList" value="127.0.0.1:27000;127.0.0.1:27001;127.0.0.1:27002"/>
  </appSettings>

 

然后我简单的封装了下mongodb。

复制代码
  1 namespace DataMipCRM.Common
  2 {
  3     public class MongoDBHelper<T>
  4     {
  5         private static readonly string connectionString = ConfigurationManager.AppSettings["mongodbServerList"];
  6 
  7         static MongoClientSettings setting = null;
  8         MongoServer server = null;
  9 
 10         public string tableName = "person";
 11 
 12         public string databaseName = "test";
 13 
 14         static MongoDBHelper()
 15         {
 16             var ips = connectionString.Split(';');
 17 
 18             var servicesList = new List<MongoServerAddress>();
 19 
 20             foreach (var ip in ips)
 21             {
 22                 var host = ip.Split(':')[0];
 23                 var port = Convert.ToInt32(ip.Split(':')[1]);
 24 
 25                 servicesList.Add(new MongoServerAddress(host, port));
 26             }
 27 
 28             setting = new MongoClientSettings();
 29             setting.ReplicaSetName = "datamip";
 30 
 31             //集群中的服务器列表
 32             setting.Servers = servicesList;
 33         }
 34 
 35         public MongoDBHelper(string databaseName, string tableName)
 36         {
 37             this.databaseName = databaseName;
 38             this.tableName = tableName;
 39 
 40             server = new MongoClient(setting).GetServer();
 41         }
 42 
 43         public bool Remove(Expression<Func<T, bool>> func)
 44         {
 45             try
 46             {
 47                 var database = server.GetDatabase(databaseName);
 48 
 49                 var collection = database.GetCollection<T>(tableName);
 50 
 51                 var query = Query<T>.Where(func);
 52 
 53                 var result = collection.Remove(query);
 54 
 55                 return result.Response["ok"].AsInt32 > 0 ? true : false;
 56             }
 57             catch (Exception ex)
 58             {
 59                 return false;
 60             }
 61         }
 62 
 63         public bool RemoveAll()
 64         {
 65             try
 66             {
 67                 var database = server.GetDatabase(databaseName);   //mongodb中的数据库
 68 
 69                 var collection = database.GetCollection<T>(tableName);
 70 
 71                 var result = collection.RemoveAll();
 72 
 73                 return result.Response["ok"].AsInt32 > 0 ? true : false;
 74             }
 75             catch (Exception ex)
 76             {
 77                 return false;
 78             }
 79         }
 80 
 81         #region 单条插入
 82         /// <summary>
 83         /// 单条插入
 84         /// </summary>
 85         /// <typeparam name="T"></typeparam>
 86         /// <param name="t"></param>
 87         public bool Insert(T t)
 88         {
 89             try
 90             {
 91                 var database = server.GetDatabase(databaseName);   //mongodb中的数据库
 92 
 93                 var collection = database.GetCollection<T>(tableName);
 94 
 95                 var result = collection.Insert(t);
 96                 return result.DocumentsAffected > 0;
 97             }
 98             catch (Exception ex)
 99             {
100                 return false;
101             }
102         }
103         #endregion
104 
105         #region 单条覆盖,如果不存在插入,如果存在覆盖
106         /// <summary>
107         /// 单条覆盖,如果不存在插入,如果存在覆盖
108         /// </summary>
109         /// <typeparam name="T"></typeparam>
110         /// <param name="t"></param>
111         public bool Save(T t)
112         {
113             try
114             {
115                 var database = server.GetDatabase(databaseName);   //mongodb中的数据库
116 
117                 var collection = database.GetCollection<T>(tableName);
118                 var result = collection.Save(t);
119                 return result.DocumentsAffected > 0;
120             }
121             catch (Exception ex)
122             {
123                 return false;
124             }
125         }
126         #endregion
127 
128         #region 批量插入
129         /// <summary>
130         /// 批量插入
131         /// </summary>
132         /// <typeparam name="T"></typeparam>
133         /// <param name="t"></param>
134         public bool Insert(IEnumerable<T> t)
135         {
136             try
137             {
138                 var database = server.GetDatabase(databaseName);   //mongodb中的数据库
139 
140                 var collection = database.GetCollection<T>(tableName);
141 
142                 collection.InsertBatch(t);
143 
144                 return true;
145             }
146             catch (Exception ex)
147             {
148                 return false;
149             }
150         }
151         #endregion
152 
153         #region 批量查询
154 
155         public List<T> Search(Expression<Func<T, bool>> func, bool forcemaster = false)
156         {
157             var list = new List<T>();
158 
159             try
160             {
161                 //是否强制使用 “主服务器”
162                 if (forcemaster)
163                 {
164                     var database = server.GetDatabase(databaseName);   //mongodb中的数据库
165 
166                     var collection = database.GetCollection<T>(tableName);
167                     list = collection.Find(Query<T>.Where(func)).ToList();
168                 }
169                 else
170                 {
171                     var database = server.GetDatabase(databaseName);    //mongodb中的数据库
172 
173                     var collection = database.GetCollection<T>(tableName);
174 
175                     list = collection.Find(Query<T>.Where(func)).ToList();
176                 }
177             }
178             catch (Exception ex)
179             {
180                 throw;
181             }
182 
183             return list;
184         }
185 
186         #endregion
187 
188         #region 单条查询
189         /// <summary>
190         /// 单条查询
191         /// </summary>
192         public T SearchOne(Expression<Func<T, bool>> func, bool forcemaster = false)
193         {
194             T t = default(T);
195 
196             try
197             {
198                 if (forcemaster)
199                 {
200                     var database = server.GetDatabase(databaseName);   //mongodb中的数据库
201 
202                     var collection = database.GetCollection<T>(tableName);
203 
204                     t = collection.FindOne(Query<T>.Where(func));
205                 }
206                 else
207                 {
208                     var database = server.GetDatabase(databaseName);   //mongodb中的数据库
209 
210                     var collection = database.GetCollection<T>(tableName);
211 
212                     t = collection.FindOne(Query<T>.Where(func));
213                 }
214 
215                 return t;
216             }
217             catch (Exception ex)
218             {
219                 return t;
220             }
221         }
222         #endregion
223 
224         /// <summary>
225         /// 查询所有数据
226         /// </summary>
227         /// <returns></returns>
228         public List<T> SearchAll()
229         {
230             var list = new List<T>();
231 
232             try
233             {
234                 var database = server.GetDatabase(databaseName);    //mongodb中的数据库
235 
236                 var collection = database.GetCollection<T>(tableName);
237 
238                 list = collection.FindAll().ToList();
239 
240                 return list;
241             }
242             catch (Exception ex)
243             {
244                 return list;
245             }
246         }
247     }
248 }
复制代码

 

四:测试一下

1. 首先向mongodb中插入一条记录,dbname=mydb, tablename=test,插入后我们用mongodUVE看一下数据:

复制代码
 1 namespace ConsoleApplication2
 2 {
 3     class Program
 4     {
 5         static void Main(string[] args)
 6         {
 7             MongoDBHelper<MongodbCustomerModel> helper = new MongoDBHelper<MongodbCustomerModel>("mydb", "test");
 8 
 9             helper.Save(new MongodbCustomerModel()
10             {
11                 SendLastTime = DateTime.Now,
12                 ShopID = 1
13             });
14         }
15     }
16 
17     public class MongodbCustomerModel
18     {
19         public ObjectId _id { get; set; }
20 
21         public int ShopID { get; set; }
22 
23         public DateTime SendLastTime { get; set; }
24     }
25 }
复制代码

 

2. 然后我把【27000】 这个primary关闭掉,通过rs.Status看看“主备情况”。

 

3. 接下来,我们继续用mongodbHelper执行一下search,看是否能捞取到数据,如果可以,说明一台机器挂了没关系,这个“主备集群”还是活的。

 

是不是很牛逼的感觉,虽然挂了一台,我的客户端程序还是可以继续从mognodb中获取到刚才插入的数据,好了,大概就说这么多,洗洗睡了,

 

mongoDB操作命令及mongoDB的helper - 三人成虎 - 博客园

mikel阅读(794)

来源: mongoDB操作命令及mongoDB的helper – 三人成虎 – 博客园

此项目已开源,开源地址是:

http://mongodbhelper-csharp.googlecode.com/svn/trunk/

 

mongodb的helper

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MongoDB.Driver;
using MongoDB.Bson;
using MongoDB.Driver.Builders;
namespace MongoDBHelper
{
    /// <summary>
    /// mongodb的封装类。
    /// add by yancong2008@gmail.com 2011.05.14
    /// </summary>
    public sealed class MongoDBHelper
    //public sealed class MongoDBHelper<T>
    //where T :class
    {
        public static readonly string connectionString_Default = System.Configuration.ConfigurationManager.AppSettings["ConnectionString_mongoDB"];
        public static readonly string database_Default = System.Configuration.ConfigurationManager.AppSettings["Database_mongoDB"];
        #region 新增
        public static SafeModeResult InsertOne<T>(string collectionName, T entity)
        {
            return MongoDBHelper.InsertOne<T>(MongoDBHelper.connectionString_Default, MongoDBHelper.database_Default, collectionName, entity);
        }
        public static SafeModeResult InsertOne<T>(string connectionString, string databaseName, string collectionName, T entity)
        {
            SafeModeResult result = new SafeModeResult();
            if (null == entity)
            {
                return null;
            }
            MongoServer server = MongoServer.Create(connectionString);
            //获取数据库或者创建数据库(不存在的话)。
            MongoDatabase database = server.GetDatabase(databaseName);
            using (server.RequestStart(database))//开始连接数据库。
            {
                MongoCollection<BsonDocument> myCollection = database.GetCollection<BsonDocument>(collectionName);
                result = myCollection.Insert(entity);
            }
            return result;
        }
        public static IEnumerable<SafeModeResult> InsertAll<T>(string collectionName, IEnumerable<T> entitys)
        {
            return MongoDBHelper.InsertAll<T>(MongoDBHelper.connectionString_Default, MongoDBHelper.database_Default, collectionName, entitys);
        }
        public static IEnumerable<SafeModeResult> InsertAll<T>(string connectionString, string databaseName, string collectionName, IEnumerable<T> entitys)
        {
            IEnumerable<SafeModeResult> result = null;
            if (null == entitys)
            {
                return null;
            }
            MongoServer server = MongoServer.Create(connectionString);
            //获取数据库或者创建数据库(不存在的话)。
            MongoDatabase database = server.GetDatabase(databaseName);
            using (server.RequestStart(database))//开始连接数据库。
            {
                MongoCollection<BsonDocument> myCollection = database.GetCollection<BsonDocument>(collectionName);
                result = myCollection.InsertBatch(entitys);
            }
            return result;
        }
        #endregion
        #region 修改
        public static SafeModeResult UpdateOne<T>(string collectionName, T entity)
        {
            return MongoDBHelper.UpdateOne<T>(MongoDBHelper.connectionString_Default, MongoDBHelper.database_Default, collectionName, entity);
        }
        public static SafeModeResult UpdateOne<T>(string connectionString, string databaseName, string collectionName, T entity)
        {
            MongoServer server = MongoServer.Create(connectionString);
            //获取数据库或者创建数据库(不存在的话)。
            MongoDatabase database = server.GetDatabase(databaseName);
            SafeModeResult result;
            using (server.RequestStart(database))//开始连接数据库。
            {
                MongoCollection<BsonDocument> myCollection = database.GetCollection<BsonDocument>(collectionName);
                result = myCollection.Save(entity);
            }
            return result;
        }
        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collectionName"></param>
        /// <param name="query">条件查询。 调用示例:Query.Matches("Title", "感冒") 或者 Query.EQ("Title", "感冒") 或者Query.And(Query.Matches("Title", "感冒"),Query.EQ("Author", "yanc")) 等等</param>
        /// <param name="update">更新设置。调用示例:Update.Set("Title", "yanc") 或者 Update.Set("Title", "yanc").Set("Author", "yanc2") 等等</param>
        /// <returns></returns>
        public static SafeModeResult UpdateAll<T>(string collectionName, IMongoQuery query, IMongoUpdate update)
        {
            return MongoDBHelper.UpdateAll<T>(MongoDBHelper.connectionString_Default, MongoDBHelper.database_Default, collectionName, query, update);
        }
        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="connectionString"></param>
        /// <param name="databaseName"></param>
        /// <param name="collectionName"></param>
        /// <param name="query">条件查询。 调用示例:Query.Matches("Title", "感冒") 或者 Query.EQ("Title", "感冒") 或者Query.And(Query.Matches("Title", "感冒"),Query.EQ("Author", "yanc")) 等等</param>
        /// <param name="update">更新设置。调用示例:Update.Set("Title", "yanc") 或者 Update.Set("Title", "yanc").Set("Author", "yanc2") 等等</param>
        /// <returns></returns>
        public static SafeModeResult UpdateAll<T>(string connectionString, string databaseName, string collectionName, IMongoQuery query, IMongoUpdate update)
        {
            SafeModeResult result;
            if (null == query || null == update)
            {
                return null;
            }
            MongoServer server = MongoServer.Create(connectionString);
            //获取数据库或者创建数据库(不存在的话)。
            MongoDatabase database = server.GetDatabase(databaseName);
            using (server.RequestStart(database))//开始连接数据库。
            {
                MongoCollection<BsonDocument> myCollection = database.GetCollection<BsonDocument>(collectionName);
                result = myCollection.Update(query, update, UpdateFlags.Multi);
            }
            return result;
        }
        #endregion
        #region 删除
        public static SafeModeResult Delete(string collectionName, string _id)
        {
            return MongoDBHelper.Delete(MongoDBHelper.connectionString_Default, MongoDBHelper.database_Default, collectionName, _id);
        }
        public static SafeModeResult Delete(string connectionString, string databaseName, string collectionName, string _id)
        {
            SafeModeResult result;
            ObjectId id;
            if (!ObjectId.TryParse(_id, out id))
            {
                return null;
            }
            MongoServer server = MongoServer.Create(connectionString);
            //获取数据库或者创建数据库(不存在的话)。
            MongoDatabase database = server.GetDatabase(databaseName);
            using (server.RequestStart(database))//开始连接数据库。
            {
                MongoCollection<BsonDocument> myCollection = database.GetCollection<BsonDocument>(collectionName);
                result = myCollection.Remove(Query.EQ("_id", id));
            }
            return result;
        }
        public static SafeModeResult DeleteAll(string collectionName)
        {
            return MongoDBHelper.DeleteAll(MongoDBHelper.connectionString_Default, MongoDBHelper.database_Default, collectionName, null);
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="collectionName"></param>
        /// <param name="query">条件查询。 调用示例:Query.Matches("Title", "感冒") 或者 Query.EQ("Title", "感冒") 或者Query.And(Query.Matches("Title", "感冒"),Query.EQ("Author", "yanc")) 等等</param>
        /// <returns></returns>
        public static SafeModeResult DeleteAll(string collectionName, IMongoQuery query)
        {
            return MongoDBHelper.DeleteAll(MongoDBHelper.connectionString_Default, MongoDBHelper.database_Default, collectionName, query);
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="connectionString"></param>
        /// <param name="databaseName"></param>
        /// <param name="collectionName"></param>
        /// <param name="query">条件查询。 调用示例:Query.Matches("Title", "感冒") 或者 Query.EQ("Title", "感冒") 或者Query.And(Query.Matches("Title", "感冒"),Query.EQ("Author", "yanc")) 等等</param>
        /// <returns></returns>
        public static SafeModeResult DeleteAll(string connectionString, string databaseName, string collectionName, IMongoQuery query)
        {
            MongoServer server = MongoServer.Create(connectionString);
            //获取数据库或者创建数据库(不存在的话)。
            MongoDatabase database = server.GetDatabase(databaseName);
            SafeModeResult result;
            using (server.RequestStart(database))//开始连接数据库。
            {
                MongoCollection<BsonDocument> myCollection = database.GetCollection<BsonDocument>(collectionName);
                if (null == query)
                {
                    result = myCollection.RemoveAll();
                }
                else
                {
                    result = myCollection.Remove(query);
                }
            }
            return result;
        }
        #endregion
        #region 获取单条信息
        public static T GetOne<T>(string collectionName, string _id)
        {
            return MongoDBHelper.GetOne<T>(MongoDBHelper.connectionString_Default, MongoDBHelper.database_Default, collectionName, _id);
        }
        public static T GetOne<T>(string connectionString, string databaseName, string collectionName, string _id)
        {
            T result = default(T);
            ObjectId id;
            if (!ObjectId.TryParse(_id, out id))
            {
                return default(T);
            }
            MongoServer server = MongoServer.Create(connectionString);
            //获取数据库或者创建数据库(不存在的话)。
            MongoDatabase database = server.GetDatabase(databaseName);
            using (server.RequestStart(database))//开始连接数据库。
            {
                MongoCollection<BsonDocument> myCollection = database.GetCollection<BsonDocument>(collectionName);
                result = myCollection.FindOneAs<T>(Query.EQ("_id", id));
            }
            return result;
        }
        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collectionName"></param>
        /// <param name="query">条件查询。 调用示例:Query.Matches("Title", "感冒") 或者 Query.EQ("Title", "感冒") 或者Query.And(Query.Matches("Title", "感冒"),Query.EQ("Author", "yanc")) 等等</param>
        /// <returns></returns>
        public static T GetOne<T>(string collectionName, IMongoQuery query)
        {
            return GetOne<T>(MongoDBHelper.connectionString_Default, MongoDBHelper.database_Default, collectionName, query);
        }
        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="connectionString"></param>
        /// <param name="databaseName"></param>
        /// <param name="collectionName"></param>
        /// <param name="query">条件查询。 调用示例:Query.Matches("Title", "感冒") 或者 Query.EQ("Title", "感冒") 或者Query.And(Query.Matches("Title", "感冒"),Query.EQ("Author", "yanc")) 等等</param>
        /// <returns></returns>
        public static T GetOne<T>(string connectionString, string databaseName, string collectionName, IMongoQuery query)
        {
            MongoServer server = MongoServer.Create(connectionString);
            //获取数据库或者创建数据库(不存在的话)。
            MongoDatabase database = server.GetDatabase(databaseName);
            T result = default(T);
            using (server.RequestStart(database))//开始连接数据库。
            {
                MongoCollection<BsonDocument> myCollection = database.GetCollection<BsonDocument>(collectionName);
                if (null == query)
                {
                    result = myCollection.FindOneAs<T>();
                }
                else
                {
                    result = myCollection.FindOneAs<T>(query);
                }
            }
            return result;
        }
        #endregion
        #region 获取多个
        public static List<T> GetAll<T>(string collectionName)
        {
            return MongoDBHelper.GetAll<T>(MongoDBHelper.connectionString_Default, MongoDBHelper.database_Default, collectionName);
        }
        /// <summary>
        /// 如果不清楚具体的数量,一般不要用这个函数。
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collectionName"></param>
        /// <returns></returns>
        public static List<T> GetAll<T>(string connectionString, string databaseName, string collectionName)
        {
            MongoServer server = MongoServer.Create(connectionString);
            //获取数据库或者创建数据库(不存在的话)。
            MongoDatabase database = server.GetDatabase(databaseName);
            List<T> result = new List<T>();
            using (server.RequestStart(database))//开始连接数据库。
            {
                MongoCollection<BsonDocument> myCollection = database.GetCollection<BsonDocument>(collectionName);
                foreach (T entity in myCollection.FindAllAs<T>())
                {
                    result.Add(entity);
                }
            }
            return result;
        }
        public static List<T> GetAll<T>(string collectionName, int count)
        {
            return MongoDBHelper.GetAll<T>(collectionName, count, nullnull);
        }
        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collectionName"></param>
        /// <param name="count"></param>
        /// <param name="query">条件查询。 调用示例:Query.Matches("Title", "感冒") 或者 Query.EQ("Title", "感冒") 或者Query.And(Query.Matches("Title", "感冒"),Query.EQ("Author", "yanc")) 等等</param>
        /// <returns></returns>
        public static List<T> GetAll<T>(string collectionName, int count, IMongoQuery query)
        {
            return MongoDBHelper.GetAll<T>(collectionName, count, query, null);
        }
        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collectionName"></param>
        /// <param name="count"></param>
        /// <param name="sortBy">排序用的。调用示例:SortBy.Descending("Title") 或者 SortBy.Descending("Title").Ascending("Author")等等</param>
        /// <returns></returns>
        public static List<T> GetAll<T>(string collectionName, int count, IMongoSortBy sortBy)
        {
            return MongoDBHelper.GetAll<T>(collectionName, count, null, sortBy);
        }
        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collectionName"></param>
        /// <param name="count"></param>
        /// <param name="query">条件查询。 调用示例:Query.Matches("Title", "感冒") 或者 Query.EQ("Title", "感冒") 或者Query.And(Query.Matches("Title", "感冒"),Query.EQ("Author", "yanc")) 等等</param>
        /// <param name="sortBy">排序用的。调用示例:SortBy.Descending("Title") 或者 SortBy.Descending("Title").Ascending("Author")等等</param>
        /// <param name="fields">只返回所需要的字段的数据。调用示例:"Title" 或者 new string[] { "Title", "Author" }等等</param>
        /// <returns></returns>
        public static List<T> GetAll<T>(string collectionName, int count, IMongoQuery query, IMongoSortBy sortBy, params string[] fields)
        {
            PagerInfo pagerInfo = new PagerInfo();
            pagerInfo.Page = 1;
            pagerInfo.PageSize = count;
            return MongoDBHelper.GetAll<T>(MongoDBHelper.connectionString_Default, MongoDBHelper.database_Default, collectionName, query, pagerInfo, sortBy, fields);
        }
        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collectionName"></param>
        /// <param name="query">条件查询。 调用示例:Query.Matches("Title", "感冒") 或者 Query.EQ("Title", "感冒") 或者Query.And(Query.Matches("Title", "感冒"),Query.EQ("Author", "yanc")) 等等</param>
        /// <param name="pagerInfo"></param>
        /// <returns></returns>
        public static List<T> GetAll<T>(string collectionName, IMongoQuery query, PagerInfo pagerInfo)
        {
            return MongoDBHelper.GetAll<T>(MongoDBHelper.connectionString_Default, MongoDBHelper.database_Default, collectionName, query, pagerInfo, null);
        }
        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collectionName"></param>
        /// <param name="query">条件查询。 调用示例:Query.Matches("Title", "感冒") 或者 Query.EQ("Title", "感冒") 或者Query.And(Query.Matches("Title", "感冒"),Query.EQ("Author", "yanc")) 等等</param>
        /// <param name="pagerInfo"></param>
        /// <param name="sortBy">排序用的。调用示例:SortBy.Descending("Title") 或者 SortBy.Descending("Title").Ascending("Author")等等</param>
        /// <returns></returns>
        public static List<T> GetAll<T>(string collectionName, IMongoQuery query, PagerInfo pagerInfo, IMongoSortBy sortBy)
        {
            return MongoDBHelper.GetAll<T>(MongoDBHelper.connectionString_Default, MongoDBHelper.database_Default, collectionName, query, pagerInfo, sortBy);
        }
        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collectionName"></param>
        /// <param name="query">条件查询。 调用示例:Query.Matches("Title", "感冒") 或者 Query.EQ("Title", "感冒") 或者Query.And(Query.Matches("Title", "感冒"),Query.EQ("Author", "yanc")) 等等</param>
        /// <param name="pagerInfo"></param>
        /// <param name="fields">只返回所需要的字段的数据。调用示例:"Title" 或者 new string[] { "Title", "Author" }等等</param>
        /// <returns></returns>
        public static List<T> GetAll<T>(string collectionName, IMongoQuery query, PagerInfo pagerInfo, params string[] fields)
        {
            return MongoDBHelper.GetAll<T>(MongoDBHelper.connectionString_Default, MongoDBHelper.database_Default, collectionName, query, pagerInfo, null, fields);
        }
        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collectionName"></param>
        /// <param name="query">条件查询。 调用示例:Query.Matches("Title", "感冒") 或者 Query.EQ("Title", "感冒") 或者Query.And(Query.Matches("Title", "感冒"),Query.EQ("Author", "yanc")) 等等</param>
        /// <param name="pagerInfo"></param>
        /// <param name="sortBy">排序用的。调用示例:SortBy.Descending("Title") 或者 SortBy.Descending("Title").Ascending("Author")等等</param>
        /// <param name="fields">只返回所需要的字段的数据。调用示例:"Title" 或者 new string[] { "Title", "Author" }等等</param>
        /// <returns></returns>
        public static List<T> GetAll<T>(string collectionName, IMongoQuery query, PagerInfo pagerInfo, IMongoSortBy sortBy, params string[] fields)
        {
            return MongoDBHelper.GetAll<T>(MongoDBHelper.connectionString_Default, MongoDBHelper.database_Default, collectionName, query, pagerInfo, sortBy, fields);
        }
        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="connectionString"></param>
        /// <param name="databaseName"></param>
        /// <param name="collectionName"></param>
        /// <param name="query">条件查询。 调用示例:Query.Matches("Title", "感冒") 或者 Query.EQ("Title", "感冒") 或者Query.And(Query.Matches("Title", "感冒"),Query.EQ("Author", "yanc")) 等等</param>
        /// <param name="pagerInfo"></param>
        /// <param name="sortBy">排序用的。调用示例:SortBy.Descending("Title") 或者 SortBy.Descending("Title").Ascending("Author")等等</param>
        /// <param name="fields">只返回所需要的字段的数据。调用示例:"Title" 或者 new string[] { "Title", "Author" }等等</param>
        /// <returns></returns>
        public static List<T> GetAll<T>(string connectionString, string databaseName, string collectionName, IMongoQuery query, PagerInfo pagerInfo, IMongoSortBy sortBy, params string[] fields)
        {
            MongoServer server = MongoServer.Create(connectionString);
            //获取数据库或者创建数据库(不存在的话)。
            MongoDatabase database = server.GetDatabase(databaseName);
            List<T> result = new List<T>();
            using (server.RequestStart(database))//开始连接数据库。
            {
                MongoCollection<BsonDocument> myCollection = database.GetCollection<BsonDocument>(collectionName);
                MongoCursor<T> myCursor;
                if (null == query)
                {
                    myCursor = myCollection.FindAllAs<T>();
                }
                else
                {
                    myCursor = myCollection.FindAs<T>(query);
                }
                if (null != sortBy)
                {
                    myCursor.SetSortOrder(sortBy);
                }
                if (null != fields)
                {
                    myCursor.SetFields(fields);
                }
                foreach (T entity in myCursor.SetSkip((pagerInfo.Page - 1) * pagerInfo.PageSize).SetLimit(pagerInfo.PageSize))//.SetSkip(100).SetLimit(10)是指读取第一百条后的10条数据。
                {
                    result.Add(entity);
                }
            }
            return result;
        }
        #endregion
        #region 索引
        public static void CreateIndex(string collectionName, params string[] keyNames)
        {
            MongoDBHelper.CreateIndex(MongoDBHelper.connectionString_Default, MongoDBHelper.database_Default, collectionName, keyNames);
        }
        public static void CreateIndex(string connectionString, string databaseName, string collectionName, params string[] keyNames)
        {
            SafeModeResult result = new SafeModeResult();
            if (null == keyNames)
            {
                return;
            }
            MongoServer server = MongoServer.Create(connectionString);
            //获取数据库或者创建数据库(不存在的话)。
            MongoDatabase database = server.GetDatabase(databaseName);
            using (server.RequestStart(database))//开始连接数据库。
            {
                MongoCollection<BsonDocument> myCollection = database.GetCollection<BsonDocument>(collectionName);
                if (!myCollection.IndexExists(keyNames))
                {
                    myCollection.EnsureIndex(keyNames);
                }
            }
        }
        #endregion
    }
}

 

mongoDB操作命令,摘自官方helper

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
help                         show help
show dbs                     show database names
show collections             show collections in current database
show users                   show users in current database
show profile                 show most recent system.profile entries with time >= 1ms
use <db name>                set curent database to <db name>
db.addUser (username, password)
db.removeUser(username)
db.cloneDatabase(fromhost)
db.copyDatabase(fromdb, todb, fromhost)
db.createCollection(name, { size : ..., capped : ..., max : ... } )
db.getName()
db.dropDatabase()
// runs the collstats] command on each collection in the database
db.printCollectionStats()
db.currentOp() displays the current operation in the db
db.killOp() kills the current operation in the db
db.getProfilingLevel()
db.setProfilingLevel(level) 0=off 1=slow 2=all
db.getReplicationInfo()
db.printReplicationInfo()
db.printSlaveReplicationInfo()
db.repairDatabase()
db.version() current version of the server
db.shutdownServer()
db.foo.drop() drop the collection
db.foo.dropIndex(name)
db.foo.dropIndexes()
db.foo.getIndexes()
db.foo.ensureIndex(keypattern,options) - options object has these possible
fields: name, unique, dropDups
db.foo.find( [query] , [fields]) - first parameter is an optional
query filter. second parameter
is optional
set of fields to return.
e.g. db.foo.find(
{ x : 77 } ,
{ name : 1 , x : 1 } )
db.foo.find(...).count()
db.foo.find(...).limit(n)
db.foo.find(...).skip(n)
db.foo.find(...).sort(...)
db.foo.findOne([query])
db.foo.getDB() get DB object associated with collection
db.foo.count()
db.foo.group( { key : ..., initial: ..., reduce : ...[, cond: ...] } )
db.foo.renameCollection( newName ) renames the collection
db.foo.stats()
db.foo.dataSize()
db.foo.storageSize() - includes free space allocated to this collection
db.foo.totalIndexSize() - size in bytes of all the indexes
db.foo.totalSize() - storage allocated for all data and indexes
db.foo.validate() (slow)
db.foo.insert(obj)
db.foo.update(query, object[, upsert_bool])
db.foo.save(obj)
db.foo.remove(query) - remove objects matching query
remove({}) will remove all

C# Mongodb 封装类 - 我很好123 - 博客园

mikel阅读(1381)

来源: C# Mongodb 封装类 – 我很好123 – 博客园

1.  依赖包 MongoDB.Driver; MongoDB.Json; MongoDB.Bson;

2. 上代码

 

复制代码
  1 using MongoDB.Driver;
  2 using System;
  3 using System.Collections.Generic;
  4 using System.Text;
  5 
  6 using System.Linq;
  7 using System.Linq.Expressions;
  8 using System.Reflection;
  9 using MongoDB.Driver.Linq;
 10 
 11 namespace Common
 12 {
 13 
 14 
 15     public class MongodbHelper
 16     {
 17         protected static MongoClient client;
 18 
 19         public MongodbHelper()
 20         {
 21             client = new MongoClient("mongodb://localhost:27017");
 22         }
 23         static MongodbHelper()
 24         {
 25             client = new MongoClient("mongodb://localhost:27017");
 26         }
 27         /// <summary>
 28         /// 获取 Collection 信息
 29         /// </summary>
 30         /// <typeparam name="T">实体类型</typeparam>
 31         /// <param name="collName">Collection 名称</param>
 32         /// <param name="dbName">DBase名称</param>
 33         /// <returns></returns>
 34         public static MyCollection<T> GetCollection<T>(string collName, string dbName)
 35         {
 36             MyCollection<T> mycollection = new MyCollection<T>();
 37             IMongoDatabase database = client.GetDatabase(dbName);
 38             IMongoCollection<T> collection = database.GetCollection<T>(collName);
 39             mycollection.collection = collection;
 40             return mycollection;
 41         }
 42     }
 43 
 44     public class MyCollection<T>
 45     {
 46         public IMongoCollection<T> collection;
 47 
 48         /// <summary>
 49         /// 查询数据 延迟加载 后期可以使用Linq  Lambda处理数据
 50         /// </summary>
 51         /// <returns></returns>
 52         public IMongoQueryable<T> QueryData()
 53         {
 54             var list = collection.AsQueryable<T>();
 55             return list;
 56         }
 57         /// <summary>
 58         /// 查询所有数据
 59         /// </summary>
 60         /// <param name="expression"></param>
 61         /// <returns></returns>
 62         public List<T> QueryData(Expression<Func<T, bool>> expression)
 63         {
 64             var list = collection.AsQueryable().Where(expression);
 65             return list.ToList<T>();
 66         }
 67 
 68         /// <summary>
 69         /// 分页查询
 70         /// </summary>
 71         /// <param name="expressio"></param>
 72         /// <param name="pageInfo"></param>
 73         /// <returns></returns>
 74         public PageInfo<T> QueryData(Expression<Func<T, bool>> expressio, PageInfo<T> pageInfo)
 75         {
 76             List<T> list = null;
 77             pageInfo.Totoal = collection.AsQueryable<T>().Count();
 78             pageInfo.PageNum = (int)Math.Ceiling(pageInfo.Totoal / pageInfo.PageSize * 0.1);
 79             if (pageInfo == null || pageInfo.IsAll == true)
 80                 if (expressio != null)
 81                     list = collection.AsQueryable<T>().Where(expressio).ToList();
 82                 else list = collection.AsQueryable<T>().ToList();
 83             else if (expressio != null)
 84             {
 85                 list = collection.AsQueryable<T>().Where(expressio).Skip(pageInfo.PageSize * (pageInfo.PageIndex - 1)).Take(pageInfo.PageSize).ToList();
 86             }
 87             else
 88             {
 89                 list = collection.AsQueryable<T>().Skip(pageInfo.PageSize * (pageInfo.PageIndex - 1)).Take(pageInfo.PageSize).ToList();
 90             }
 91             pageInfo.Data = list;
 92             return pageInfo;
 93         }
 94 
 95         /// <summary>
 96         /// 新增一条数据(文档)
 97         /// </summary>
 98         /// <param name="ts"></param>
 99         public void AddDoc(T ts)
100         {
101             collection.InsertOne(ts);
102         }
103         /// <summary>
104         /// 批量新增多个文档
105         /// </summary>
106         /// <param name="ts"></param>
107         public void AddDocs(List<T> ts)
108         {
109             collection.InsertMany(ts);
110         }
111         /// <summary>
112         /// 更新文档  不存在就新增
113         /// </summary>
114         /// <param name="filter"></param>
115         /// <param name="t"></param>
116         public void UpdateDoc(Expression<Func<T, bool>> filter, T t)
117         {
118             // FilterDefinition<T> filter = null;
119             //  UpdateDefinition<T> update = Builders<T>.Update.ToBsonDocument();//   null;// Builders<T>.Update.
120             var newData = BuildQueryOption(t);
121             UpdateResult result = collection.UpdateOne(filter, newData, new UpdateOptions { IsUpsert = true });
122         }
123         /// <summary>
124         /// 删除文档   
125         /// </summary>
126         /// <param name="predicate"></param>
127         public void Detele(Expression<Func<T, bool>> predicate)
128         {
129             var result = collection.DeleteMany(predicate);//.ConfigureAwait(false);
130                                                           // return result.DeletedCount;
131         }
132         /// <summary>
133         /// 利用反射创建 更新字段 (这里没有处理空)
134         /// </summary>
135         /// <param name="doc"></param>
136         /// <returns></returns>
137         private UpdateDefinition<T> BuildQueryOption(T doc)
138         {
139             var update = Builders<T>.Update;
140             var updates = new List<UpdateDefinition<T>>();
141 
142             var t = doc.GetType();
143             var proper = t.GetProperties();
144             foreach (PropertyInfo info in proper)
145             {
146                 var value = info.GetValue(doc);
147                 if (value != null)
148                 {
149                     updates.Add(update.Set(info.Name, info.GetValue(doc)));
150                 }
151 
152             }
153             // update.Combine(updates);
154             return update.Combine(updates);
155         }
156     }
157     /// <summary>
158     /// 分页信息
159     /// </summary>
160     /// <typeparam name="T"></typeparam>
161     public class PageInfo<T>
162     {
163         public bool IsAll { get; set; } = false;
164         public int PageSize { get; set; } = 100;
165         public int PageIndex { get; set; } = 1;
166         public long Totoal { get; set; }
167 
168         public int PageNum { get; set; }
169 
170         public List<T> Data { get; set; }
171     }
172 }
复制代码

3. 测试方法

复制代码
using Common;
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Text;

namespace ZhiHuHot
{
    public class TestMongo
    {

        public void GetHot()
        {
            MyCollection<HotInfo> collection = MongodbHelper.GetCollection<HotInfo>("ZhiHuHot", "ZhiHu");

            Expression<Func<HotInfo, bool>> predicate = null;

            predicate = a => a.HotID.Equals(391481443);

            PageInfo<HotInfo> hots = collection.QueryData(null, new PageInfo<HotInfo>());
        }
    }
}
复制代码

 

C#使用MongoDB数据库的帮助类_qq_32733803的博客-CSDN博客

mikel阅读(753)

来源: C#使用MongoDB数据库的帮助类_qq_32733803的博客-CSDN博客

1 添加NUGET包
2 在config中添加
3 创建连接类
 internal static class DbConfigParams
{
private static string _conntionString = ConfigurationManager.AppSettings[“MongoDBConn”];
        /// <summary>
/// 获取 数据库连接串
/// </summary>
public static string ConntionString
{
get { return _conntionString; }
}
        private static string _dbName = ConfigurationManager.AppSettings[“MongoDBName”];
        /// <summary>
/// 获取 数据库名称
/// </summary>
public static string DbName
{
get { return _dbName; }
}
        /// <summary>
/// 获取 数据库连接串+数据库名称
/// </summary>
public static string conString
{
get { return _conntionString + “/” + _dbName; }
}
    }
4 创建帮助类
  /// <summary>
/// MongoDb 数据库操作类
/// </summary>
public class MongoDBHelper<T> where T : BaseEntity
{
/// <summary>
/// 数据库对象
/// </summary>
private IMongoDatabase database;
/// <summary>
/// 连接字符串
/// </summary>
static string _conString = DbConfigParams.conString;
/// <summary>
/// 构造函数
/// </summary>
/// <param name=”conString”>连接字符串</param>
public MongoDBHelper()
{
var url = new MongoUrl(_conString);
MongoClientSettings mcs = MongoClientSettings.FromUrl(url);
mcs.MaxConnectionLifeTime = TimeSpan.FromMilliseconds(1000);
var client = new MongoClient(mcs);
this.database = client.GetDatabase(url.DatabaseName);
}
/// <summary>
/// 创建集合对象
/// </summary>
/// <param name=”collName”>集合名称</param>
///<returns>集合对象</returns>
private IMongoCollection<T> GetColletion(String collName)
{
return database.GetCollection<T>(collName);
}
        #region 增加
/// <summary>
/// 插入对象
/// </summary>
/// <param name=”collName”>集合名称</param>
/// <param name=”t”>插入的对象</param>
public void Insert(String collName, T t)
{
var coll = GetColletion(collName);
coll.InsertOne(t);
}
/// <summary>
/// 批量插入
/// </summary>
/// <param name=”collName”>集合名称</param>
/// <param name=”ts”>要插入的对象集合</param>
public void InsertBath(String collName, IEnumerable<T> ts)
{
var coll = GetColletion(collName);
coll.InsertMany(ts);
}
#endregion
        #region 删除
/// <summary>
/// 按BsonDocument条件删除
/// </summary>
/// <param name=”collName”>集合名称</param>
/// <param name=”document”>文档</param>
/// <returns></returns>
//public Int64 Delete(String collName, QueryDocument document)
//{
//    var coll = GetColletion(collName);
//    var result = coll.DeleteMany(document);
//    return result.DeletedCount;
//}
/// <summary>
/// 按json字符串删除
/// </summary>
/// <param name=”collName”>集合名称</param>
/// <param name=”json”>json字符串</param>
/// <returns></returns>
public Int64 Delete(String collName, String json)
{
var coll = GetColletion(collName);
var result = coll.DeleteMany(json);
return result.DeletedCount;
}
/// <summary>
/// 按条件表达式删除
/// </summary>
/// <param name=”collName”>集合名称</param>
/// <param name=”predicate”>条件表达式</param>
/// <returns></returns>
//public Int64 Delete(String collName, Expression<Func<T, Boolean>> predicate)
//{
//    var coll = GetColletion(collName);
//    var result = coll.DeleteMany(predicate);
//    return result.DeletedCount;
//}
/// <summary>
/// 按检索条件删除
/// 建议用Builders<T>构建复杂的查询条件
/// </summary>
/// <param name=”collName”>集合名称</param>
/// <param name=”filter”>条件</param>
/// <returns></returns>
public Int64 Delete(String collName, FilterDefinition<T> filter)
{
var coll = GetColletion(collName);
var result = coll.DeleteMany(filter);
return result.DeletedCount;
}
        #endregion
        #region 修改
/// <summary>
/// 修改文档
/// </summary>
/// <param name=”collName”>集合名称</param>
/// <param name=”filter”>修改条件</param>
/// <param name=”update”>修改结果</param>
/// <param name=”upsert”>是否插入新文档(filter条件满足就更新,否则插入新文档)</param>
/// <returns></returns>
public Int64 Update(String collName, Expression<Func<T, Boolean>> filter, UpdateDefinition<T> update, Boolean upsert = false)
{
var coll = GetColletion(collName);
var result = coll.UpdateMany(filter, update, new UpdateOptions { IsUpsert = upsert });
return result.ModifiedCount;
}
/ <summary>
/ 用新对象替换新文档-更新批量
/ </summary>
/ <param name=”collName”>集合名称</param>
/ <param name=”filter”>修改条件</param>
/ <param name=”t”>新对象</param>
/ <param name=”upsert”>是否插入新文档(filter条件满足就更新,否则true插入新文档)</param>
/ <returns>修改影响文档数</returns>
//public Int64 UpdateT(String collName, FilterDefinition<T> filter, T t, Boolean upsert = false)
//{
//    var coll = GetColletion(collName);
//    BsonDocument document = t.ToBsonDocument<T>();
//    document.Remove(“_id”);
//    UpdateDocument update = new UpdateDocument(“$set”, document);
//    var result = coll.UpdateMany(filter, update, new UpdateOptions { IsUpsert = upsert });
//    return result.ModifiedCount;
//}
/ <summary>
/ 用新对象替换新文档-更新单个
/ </summary>
/ <param name=”collName”>集合名称</param>
/ <param name=”filter”>修改条件</param>
/ <param name=”t”>新对象</param>
/ <param name=”upsert”>是否插入新文档(filter条件满足就更新,否则true插入新文档)</param>
/ <returns>修改影响文档数</returns>
//public Int64 UpdateOne(String collName, FilterDefinition<T> filter, T t, Boolean upsert = false)
//{
//    var coll = GetColletion(collName);
//    BsonDocument document = t.ToBsonDocument<T>();
//    document.Remove(“_id”);
//    UpdateDocument update = new UpdateDocument(“$set”, document);
//    var result = coll.UpdateOne(filter, update, new UpdateOptions { IsUpsert = upsert });
//    return result.ModifiedCount;
//}
#endregion
        #region 查询
        /// <summary>
/// 查询,复杂查询直接用Linq处理
/// </summary>
/// <param name=”collName”>集合名称</param>
/// <returns>要查询的对象</returns>
private IQueryable<T> GetQueryable(String collName)
{
var coll = GetColletion(collName);
return coll.AsQueryable<T>();
}
/// <summary>
/// 根据条件表达式返回可查询的记录源
/// </summary>
/// <param name=”query”>查询条件</param>
/// <param name=”sortPropertyName”>排序表达式</param>
/// <param name=”isDescending”>如果为true则为降序,否则为升序</param>
/// <returns></returns>
private IFindFluent<T, T> GetQueryable(String collName, FilterDefinition<T> query, string sortPropertyName, bool isDescending = true)
{
IMongoCollection<T> collection = GetColletion(collName);
IFindFluent<T, T> queryable = collection.Find(query);
var sort = isDescending ? Builders<T>.Sort.Descending(sortPropertyName) : Builders<T>.Sort.Ascending(sortPropertyName);
return queryable.Sort(sort);
}
/// <summary>
/// 根据条件表达式返回可查询的记录源
/// </summary>
/// <param name=”match”>查询条件</param>
/// <param name=”orderByProperty”>排序表达式</param>
/// <param name=”isDescending”>如果为true则为降序,否则为升序</param>
/// <returns></returns>
private IQueryable<T> GetQueryable<TKey>(String collName, Expression<Func<T, bool>> match, Expression<Func<T, TKey>> orderByProperty, bool isDescending = true)
{
IMongoCollection<T> collection = GetColletion(collName);
IQueryable<T> query = collection.AsQueryable();
            if (match != null)
{
query = query.Where(match);
}
            if (orderByProperty != null)
{
query = isDescending ? query.OrderByDescending(orderByProperty) : query.OrderBy(orderByProperty);
}
else
{
// query = query.OrderBy(sortPropertyName, isDescending);
}
return query;
}
/// <summary>
/// 根据条件查询数据库,并返回对象集合
/// </summary>
/// <param name=”match”>条件表达式</param>
/// <param name=”sortPropertyName”>排序字段</param>
/// <param name=”isDescending”>如果为true则为降序,否则为升序</param>
/// <returns></returns>
public IList<T> Find(String collName, Expression<Func<T, bool>> match, string sortPropertyName, bool isDescending = true)
{
return GetQueryable(collName, match, sortPropertyName, isDescending).ToList();
}
/// <summary>
/// 根据条件查询数据库,并返回对象集合
/// </summary>
/// <param name=”query”>条件表达式</param>
/// <param name=”sortPropertyName”>排序字段</param>
/// <param name=”isDescending”>如果为true则为降序,否则为升序</param>
/// <returns></returns>
public IList<T> Find(String collName, FilterDefinition<T> query, string sortPropertyName, bool isDescending = true)
{
return GetQueryable(collName, query, sortPropertyName, isDescending).ToList();
}
/// <summary>
/// 根据条件查询数据库,并返回对象集合
/// </summary>
/// <param name=”match”>条件表达式</param>
/// <param name=”orderByProperty”>排序表达式</param>
/// <param name=”isDescending”>如果为true则为降序,否则为升序</param>
/// <returns></returns>
public IList<T> Find<TKey>(String collName, Expression<Func<T, bool>> match, Expression<Func<T, TKey>> orderByProperty, bool isDescending = true)
{
return GetQueryable<TKey>(collName, match, orderByProperty, isDescending).ToList();
}
/// <summary>
/// 根据条件查询数据库,如果存在返回第一个对象
/// </summary>
/// <param name=”filter”>条件表达式</param>
/// <returns>存在则返回指定的第一个对象,否则返回默认值</returns>
public T FindSingle(String collName, FilterDefinition<T> filter)
{
var coll = GetColletion(collName);
return coll.Find(filter).FirstOrDefault();
}
/ <summary>
/ 根据条件查询数据库,并返回对象集合(用于分页数据显示)
/ </summary>
/ <param name=”query”>条件表达式</param>
/ <param name=”info”>分页实体</param>
/ <returns>指定对象的集合</returns>
//public IList<T> FindWithPager(string collName, FilterDefinition<T> query, PagerInfo info, string orderByProperty, bool isDescending = true)
//{
//    int pageindex = (info.CurrenetPageIndex < 1) ? 1 : info.CurrenetPageIndex;
//    int pageSize = (info.PageSize <= 0) ? 20 : info.PageSize;
//    int excludedRows = (pageindex – 1) * pageSize;
//    var find = GetQueryable(collName, query, orderByProperty, isDescending);
//    info.RecordCount = (int)find.Count();
//    return find.Skip(excludedRows).Limit(pageSize).ToList();
//}
/// <summary>
/// 根据条件查询数据库,并返回对象集合(用于分页数据显示)
/// </summary>
/// <param name=”match”>条件表达式</param>
/// <param name=”info”>分页实体</param>
/// <returns>指定对象的集合</returns>
//public IList<T> FindWithPager(String collName, Expression<Func<T, bool>> match, PagerInfo info, string orderByProperty, bool isDescending = true)
//{
//    int pageindex = (info.CurrenetPageIndex < 1) ? 1 : info.CurrenetPageIndex;
//    int pageSize = (info.PageSize <= 0) ? 20 : info.PageSize;
        //    int excludedRows = (pageindex – 1) * pageSize;
        //    IQueryable<T> query = GetQueryable(collName,match, orderByProperty, isDescending);
//    info.RecordCount = query.Count();
        //    return query.Skip(excludedRows).Take(pageSize).ToList();
//}
#endregion
}
    /// <summary>
/// 实体基类,方便生成_id
/// </summary>
public class BaseEntity
{
[BsonRepresentation(BsonType.ObjectId)]
public String Id { get; set; }
/// <summary>
/// 给对象初值
/// </summary>
public BaseEntity()
{
this.Id = ObjectId.GenerateNewId().ToString();
}
}

Challenges when upgrading from meteor 1.6 to meteor 1.7 | by Michael Lazarski | Medium

mikel阅读(614)

来源: Challenges when upgrading from meteor 1.6 to meteor 1.7 | by Michael Lazarski | Medium

Error 1: `Identifier ‘InheritPrototype’ has already been declared`

W20180702-12:59:21.872(2)? (STDERR) let InheritPrototype;
W20180702-12:59:21.872(2)? (STDERR)     ^
W20180702-12:59:21.872(2)? (STDERR) 
W20180702-12:59:21.873(2)? (STDERR) SyntaxError: Identifier 'InheritPrototype' has already been declared
W20180702-12:59:21.873(2)? (STDERR)     at createScript (vm.js:80:10)
W20180702-12:59:21.873(2)? (STDERR)     at Object.runInThisContext (vm.js:139:10)

This is one has todo with meteor packages and api modules.

You have the following in a meteor package:

api.addFiles('lib/main.js', [ 'client', 'server' ]);api.mainModule('lib/main.js', ['client', 'server']);

This will produce the error message because the same file is loaded twice.

Solution:

Most often you can just remove the api.addFiles line and everything should be okay but you have to make sure that this is really the case. Also don’t forget to bump the versionFrom to `api.versionsFrom(‘1.7’);` and your package version.

Error 2: Broken persistent session package

TypeError: Cannot read property 'apply' of undefined
 at ReactiveDict.PersistentSession.old_get (u2622_persistent-session.js?hash=57db38c11edeebc31dce68f5b5be8581c20a2286:241)
 at ReactiveDict._psGet [as get] (u2622_persistent-session.js?hash=57db38c11edeebc31dce68f5b5be8581c20a2286:244)
 at blaze.js?hash=a1ff2d6d5ecd59ee11e2ba260b8650a9d1140f59:1934
 at Function.Template._withTemplateInstanceFunc (blaze.js?hash=a1ff2d6d5ecd59ee11e2ba260b8650a9d1140f59:3744)
 at blaze.js?hash=a1ff2d6d5ecd59ee11e2ba260b8650a9d1140f59:1932
 at Object.Blaze._withCurrentView (blaze.js?hash=a1ff2d6d5ecd59ee11e2ba260b8650a9d1140f59:2271)
 at viewAutorun (blaze.js?hash=a1ff2d6d5ecd59ee11e2ba260b8650a9d1140f59:1931)
 at Computation._compute (tracker.js:308)
 at new Computation (tracker.js:206)

This will happen when you use the u2622:persistent-session .

Solution:

meteor remove u2622:persistent-session
meteor add cultofcoders:persistent-session

Pretty easy 😉

Error 3: Missing dependencies in package.js

So it looks that with 1.7 meteor is even more strikt when it comes to package dependencies. When for example your missing _ you will no get this error:

W20180702-14:05:42.877(2)? (STDERR) TypeError: _.each is not a function

This can also happen after the meteor build was successful and when your loading the page or running functions. So i would suggest that you to a full app test after upgrading.

Solution:

You have to add _ to your package or what ever dependency is missing.

api.use([
    'ecmascript',
    'underscore',
]);

在.NET Core中使用MongoDB明细教程(1):驱动基础及文档插入 - 依乐祝 - 博客园

mikel阅读(835)

来源: 在.NET Core中使用MongoDB明细教程(1):驱动基础及文档插入 – 依乐祝 – 博客园

MongoDB,被归类为NoSQL数据库,是一个以类JSON格式存储数据的面向文档的数据库系统.MongoDB在底层以名为bson的二进制编码格式表示JSON文档,MongoDB bson实现是轻量级、快速和高度可遍历的。这意味着MongoDB为用户提供了JSON文档的易用性和灵活性,以及轻量级二进制格式的速度和丰富性。其实在我看来在很多场景中MongoDb都可以取代关系型数据库。

作者:依乐祝
原文地址:https://www.cnblogs.com/yilezhu/p/13493195.html

在本教程系列中,我将向您展示如何使用.NET驱动程序提供的CRUD函数在.NET应用程序中使用MongoDB。MongoDB驱动允许您使用来自不同编程语言的MongoDB。在本系列教程中,我们将使用C#驱动程序.

准备工作

在开始之前,我们需要打开VisualStudio并创建一个新项目。我将在本教程中使用一个控制台项目。为了演示我们需要安装对应的NuGet包。这里我们需要三个NuGet包,即:

  1. MongoDB.Bson独立的BSON库,它处理POCOS到BSON类型的转换(这是MongoDB的文件格式),反之亦然。
  2. MongoDB.Driver.Core:–它本身就是一个驱动程序,具有驱动程序的核心组件(如如何连接到mongod实例,连接池),用于从.net到MongoDB的通信,并且它依赖于MongoDB.Bson.
  3. MongoDB.Driver*依赖于Driver.Core这反过来又依赖于MongoDB.Bson。它更容易在核心组件驱动程序上使用api,并具有异步方法,并支持Linq.

运行以下命令,会同时安装上面三个包:

Install-Package MongoDB.Driver

访问数据库

若要连接到数据库,请使用MongoClient类访问MongoDB实例,并通过它选择要使用的数据库。这个类有四个构造函数。

  • 默认情况下,连接到端口27017上的实例的无参数结构器:
var client = new MongoClient();
  • 接受连接字符串:
var connectionString = "mongodb://localhost:27017";
var client = new MongoClient(connectionString);
  • 接受一个MongoUrl的实例,而MongoUrl跟使用connectionstring构造函数很类似,您可以通过使用默认构造函数来创建此类实例:
var client = new MongoClient(new MongoUrl("mongodb://localhost:27017"));

.或者使用静态的Create方法:

var client = new MongoClient(MongoUrl.Create("mongodb://localhost:27017"));
  • 最后一个是接受一个MongoClientSettings的构造函数,这里你可以设置很多东西,比如凭据、连接生存期和超时时间等等。下面是两个例子:
var settings1 = MongoClientSettings
        .FromUrl(MongoUrl.Create("mongodb://localhost:27017"));

var settings2 = new MongoClientSettings
          {
          Server = new MongoServerAddress("localhost", 27017),
          UseSsl = false
          };

var client1 = new MongoClient(settings1);
var client2 = new MongoClient(settings2);

通常,你只需要使用包含一个connectionString参数的构造函数就可以了,我们将在本教程中使用此构造函数。代码如下所示:

using MongoDB.Driver;
using System;
namespace MongoDBDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Test();
            Console.ReadLine();
        }

        static void Test()
        {
            var connectionString = "mongodb://localhost:27017";

            var client = new MongoClient(connectionString);
        }
    }
}

使用MongoClient实例,我们可以做很多事情,如删除数据库、获取数据库或检索服务器上的数据库名称列表等。这里没有一个用于创建数据库方法,因为一旦您选择一个数据库并将数据插入其中,它将自动创建数据库。

这里我们使用的是GetDatabase方法,它将自动为我们创建一个数据库。如下所示获取一个名为bookstore 的数据库:

IMongoDatabase db = client.GetDatabase("bookstore");

这个GetDatabase方法返回一个对象,该对象是数据库的表示形式,我们可以从该对象访问不同的集合并操作数据库。这个MongoClient对象是线程安全的,因此您可以将其放在静态字段中,使其成为可以通过DI容器随时获得的Singleton对象,或者使用相同的连接设置实例化一个新的字段(下面将使用相同的连接池);通过这个对象,您可以选择您想要使用的任何数据库。

使用数据库对象,可以从数据库创建、重命名、检索或获取集合列表。文档存储在集合中,如果你对SQL比较熟悉的话,可以将集合视为表,将文档视为表中的记录。

创建一个集合

若要创建集合,我们将使用 IMongoDatabase对象的CreateCollection 或CreateCollection Async方法来进行 。该方法接受三个参数(最后两个参数是可选的):

  1. 集合的名称。
  2. 创建集合的选项
  3. 取消令牌
 void CreateCollection(
                string name,
                CreateCollectionOptions options = null,
                CancellationToken cancellationToken = default);

Task CreateCollectionAsync(
                string name, 
                CreateCollectionOptions options = null, 
                CancellationToken cancellationToken = default);

这个CreateCollectionOptions指定集合的特殊设置,例如它应该包含的最大文档数。下面是一个例子:

 IMongoDatabase database = client.GetDatabase("bookstore");
 await database.CreateCollectionAsync("books", new CreateCollectionOptions
            {
                Capped=true,
                MaxDocuments=100,
            });

大多数情况下,我们只需要创建一个集合,并使用默认的创建设置,因此我们只需要传递一个collection的名称即可。

await database.CreateCollectionAsync("books");

创建集合的另一种方法是使用GetCollection它接受集合的名称和集合设置选项作为参数。使用此方法,即使不存在该名称的集合,一旦创建文档,它也会在此之前创建该集合。这通常是您想要的方式,因此这里建议只在你需要创建一个有上限的集合时才使用CREATE进行集合的创建。

Capped集合是一个固定大小的集合,当它达到最大值时,它会自动覆盖其最旧的条目。GetCollection方法是泛型的,在调用此方法时需要指定文档类型。该类型表示要处理的对象/文档的类型。它可以被强类型化为我们定义的任何类,或者使用BsonDocument类型表示一个允许我们处理集合中任何文档形状的动态架构。

获取一个集合

在讨论了创建集合之后,还需要一个额外的步骤来检查集合是否存在,创建它,然后将文档添加到集合中。如果集合不存在,GetCollection会自动创建一个集合,并将文档添加到该集合中。因此,即使有一个CreateCollection,我们通常还是希望使用GetCollection。就像数据库一样,集合也是线程安全的,并且创建起来非常j简单。为了获得一个集合,我们调用GetCollection方法来指定文档类型

 static async Task TestAsync()
        {
            var connectionString = "mongodb://localhost:27017";
            var client = new MongoClient(connectionString);
            IMongoDatabase database = client.GetDatabase("bookstore");
            IMongoCollection<BsonDocument> collection = database.GetCollection<BsonDocument>("books");
        }

BsonDocument是来自MongoDB.Bson包的类型,它表示BSON文档,使用这种类型,我们可以处理来自数据库的任何形状的数据。这包含了所有基本BSON类型和其他一些用于使用BSON的方法。

在这个包中,我们有表示BSON类型的类,以及如何在.NET类型和BsonValue之间映射。下面简单列举一些:

  • 我们已经讨论过的BsonDocument类型
  • 表示BSON元素的BsonElement
  • BsonValue是各种子类使用的抽象基类,如BsonString、BsonInt 32等。

这个BsonDocument是字符串到bson值的字典,因此我们可以像初始化字典一样来进行初始化:

 var document = new BsonDocument
            {
                  {"bookname", BsonValue.Create(".net core3.1 with mongodb")},
                  {"description", new BsonString("这是一本关于在.net core3.1中使用mongodb进行开发的教程")},
                  {"tags", new BsonArray(new[] {".net core", "mongodb"}) },
                  {"remark", "C#是世界上最好的语言" },
                  {"publishyear", 2020 }
            };

.或者使用Add方法,该方法具有多个重载:

 var document2 = new BsonDocument();
            document2.Add("bookname", ".net core3.1 with mongodb2");
            document2.Add("description", "这是一本关于在.net core3.1中使用mongodb进行开发的教程2");
            document2.Add("tags", new BsonArray(new[] { ".net core", "mongodb" }));
            document2.Add("remark", "C#是世界上最好的语言");
            document2.Add("publishyear", 2020);

.或者使用索引器:

var document3 = new BsonDocument();
            document3["bookname"] = ".net core3.1 with mongodb3";
            document3["description"] = "这是一本关于在.net core3.1中使用mongodb进行开发的教程3";
            document3["tags"] = new BsonArray(new[] { ".net core", "mongodb" });
            document3["remark"] = "C#是世界上最好的语言";
            document3["publishyear"] = 2020;

创建/插入文档

文档存储在集合中,在查看了创建和获取集合之后,我们将继续在集合中插入新文档。Mongo集合实例提供了一次插入单个文档和一次插入多个文档的方法。

接下来让我们一步一步来进行实现吧:

  • 获取一个IMongocollection类型的对象,该对象表示我们要使用的集合:
 IMongoCollection<BsonDocument> collection = database.GetCollection<BsonDocument>("books");
  • 然后创建我们想要插入的文档:
 var document = new BsonDocument
            {
                  {"bookname", BsonValue.Create(".net core3.1 with mongodb")},
                  {"description", new BsonString("这是一本关于在.net core3.1中使用mongodb进行开发的教程")},
                  {"tags", new BsonArray(new[] {".net core", "mongodb"}) },
                  {"remark", "C#是世界上最好的语言" },
                  {"publishyear", 2020 }
            };
  • 最后插入该文件:
await collection.InsertOneAsync(document);

要想看到这个效果,让我们开始一个mongod实例,并从控制台监视事件的同时运行以下完整代码:

class Program
    {
        static async Task Main(string[] args)
        {
            await TestAsync();
            Console.ReadLine();
        }

        /// <summary>
        /// 测试代码
        /// </summary>
        /// <returns></returns>
        static async Task TestAsync()
        {
            var connectionString = "mongodb://localhost:27017";

            var client = new MongoClient(connectionString);
            IMongoDatabase database = client.GetDatabase("bookstore");
            IMongoCollection<BsonDocument> collection = database.GetCollection<BsonDocument>("books");
            var document = new BsonDocument
            {
                  {"bookname", BsonValue.Create(".net core3.1 with mongodb")},
                  {"description", new BsonString("这是一本关于在.net core3.1中使用mongodb进行开发的教程")},
                  {"tags", new BsonArray(new[] {".net core", "mongodb"}) },
                  {"remark", "C#是世界上最好的语言" },
                  {"publishyear", 2020 }
            };
            await collection.InsertOneAsync(document);
        }
    }

…启动你的mongo服务并运行程序,看到如下所示的数据:

这里的InsertOneAsync方法还有一个同步的版本

collection.InsertOne(document);

我们还可以使用InsertManyInsertManyAsync方法进行批量插入。假设我们图书馆又来了三本新书,我们可以使用这个方法同时插入所有的内容,并且它们将被插入到一个批中(假设您使用的是MongoDB2.6或更高版本)。要查看此操作,我们将继续更新代码并运行应用程序:

class Program
    {
        static async Task Main(string[] args)
        {
            await TestAsync();
            Console.ReadLine();
        }

        /// <summary>
        /// 测试代码
        /// </summary>
        /// <returns></returns>
        static async Task TestAsync()
        {
            var connectionString = "mongodb://localhost:27017";
            var client = new MongoClient(connectionString);
            IMongoDatabase database = client.GetDatabase("bookstore");
            IMongoCollection<BsonDocument> collection = database.GetCollection<BsonDocument>("books");
            await collection.InsertManyAsync(GetBooks());
          
        }

        static IEnumerable<BsonDocument> GetBooks() => new List<BsonDocument> {
            new BsonDocument
            {
                  {"bookname", BsonValue.Create(".net core3.1 with mongodb1")},
                  {"description", new BsonString("这是一本关于在.net core3.1中使用mongodb进行开发的教程1")},
                  {"tags", new BsonArray(new[] {".net core", "mongodb"}) },
                  {"remark", "C#是世界上最好的语言" },
                  {"publishyear", 2020 }
            },
            new BsonDocument
            {
                  {"bookname", BsonValue.Create(".net core3.1 with mongodb2")},
                  {"description", new BsonString("这是一本关于在.net core3.1中使用mongodb进行开发的教程2")},
                  {"tags", new BsonArray(new[] {".net core", "mongodb"}) },
                  {"remark", "C#是世界上最好的语言" },
                  {"publishyear", 2020 }
            },
            new BsonDocument
            {
                  {"bookname", BsonValue.Create(".net core3.1 with mongodb2")},
                  {"description", new BsonString("这是一本关于在.net core3.1中使用mongodb进行开发的教程2")},
                  {"tags", new BsonArray(new[] {".net core", "mongodb"}) },
                  {"remark", "C#是世界上最好的语言" },
                  {"publishyear", 2020 }
            },
        };
    }

这时候我们再进行夏查询,看到所有数据都入库了
1597204359324.png

除了使用BsonDocument,我们通常预先知道我们想要处理的是什么样的数据,并且我们可以为它们创建自定义的.NET类。遵循我们使用books集合的事例,让我们创建一个Book类并插入使用此类表示的新书籍:

internal class Book
{
        public string BookName { get; set; }
        public string Description { get; set; }
        public IEnumerable<string> Tags { get; set; }
        public string Remark { get; set; }
        public int PublishYear { get; set; }
}
class Program
    {
        static async Task Main(string[] args)
        {
            await TestAsync();
            Console.ReadLine();
        }

        /// <summary>
        /// 测试代码
        /// </summary>
        /// <returns></returns>
        static async Task TestAsync()
        {
            var connectionString = "mongodb://localhost:27017";
            var client = new MongoClient(connectionString);
            IMongoDatabase database = client.GetDatabase("bookstore");
            IMongoCollection<Book> collection = database.GetCollection<Book>("books");
            await collection.InsertManyAsync(GetBooks());
        }

        static IEnumerable<Book> GetBooks() => new List<Book> { 
            new Book
            {
                BookName=".net core3.1 with mongodb21",
                Description="这是一本关于在.net core3.1中使用mongodb进行开发的教程21",
                Tags=new List<string>{ ".net core", "mongodb"},
                Remark="C#是世界上最好的语言",
                PublishYear=2020,
            },
            new Book
            {
                BookName=".net core3.1 with mongodb22",
                Description="这是一本关于在.net core3.1中使用mongodb进行开发的教程22",
                Tags=new List<string>{ ".net core", "mongodb"},
                Remark="C#是世界上最好的语言",
                PublishYear=2020,
            },
            new Book
            {
                BookName=".net core3.1 with mongodb23",
                Description="这是一本关于在.net core3.1中使用mongodb进行开发的教程23",
                Tags=new List<string>{ ".net core", "mongodb"},
                Remark="C#是世界上最好的语言",
                PublishYear=2020,
            },
        };
    }

使用上面的代码,我们可以将集合的文档类型更改为新类,并调用InsertManyAsync方法。运行下程序,然后查询下集合数据如下所示:

总结

通过上面的示例代码的讲解,你应该对如何通过MongoDB .NET 驱动程序来操作MongoDB集合跟文档有所了解了,并且你也应该知道如何进行文档的插入,在下一篇文章中,我将介绍如何对文档进行检索以及为此构建的各种filter及linq查询技巧,有兴趣的可以关注下我的公众号“DotNetCore实战”第一时间进行更新!

参考资料:https://www.codementor.io/@pmbanugo/working-with-mongodb-in-net-1-basics-g4frivcvz