首页 > 资讯 > 数据库 >NoSql非关系型数据库之MongoDB应用(三)：MongoDB在项目中的初步应用 - 熊泽

267

分享到

NoSql非关系型数据库之MongoDB应用(三)：MongoDB在项目中的初步应用 - 熊泽

NoSql非关系型数据库之MongoDB应用(三)：MongoDB在项目中的初步应用 -熊泽 2018-06-10 08:06:17 267人浏览才女

摘要

业精于勤，荒于嬉；行成于思，毁于随。我们可以结合相关的IDE做一个简单的增删改查了，实现mongoDB在项目中的初步应用。前提是安装了MonGoDB服务和MongoDB可视化工具，没有安装的可以点下面的路径去操作一下。第一步

业精于勤，荒于嬉；行成于思，毁于随。

我们可以结合相关的IDE做一个简单的增删改查了，实现mongoDB在项目中的初步应用。

前提是安装了MonGoDB服务和MongoDB可视化工具，没有安装的可以点下面的路径去操作一下。

第一步：NoSQL非关系型数据库之MongoDB应用(一)：安装MongoDB服务

第二步：Nosql非关系型数据库之MongoDB应用(二)：安装MongoDB可视化工具

注：文档末尾附源码

1、创建项目

演示操作环境（其他环境也可以）：

开发环境：windows 10 专业版

系统类型：64 位操作系统, 基于 x64 的处理器

IDE：Visual Studio 2019 CommUnity

数据库：MongoDB

创建一个项目名为MongoDBTest的WEB api，net或者Net Core都可以，我这里以net core为例

2、在NuGet引用MongoDB动态链接库

需要在项目中引用 MongoDB.Bson 和 MongoDB.Driver 注意是2.10.4版本的。

MongoDB.Bson是什么

BSON是一种类JSON的一种二进制形式的存储格式，简称Binary jsON，它和JSON一样，支持内嵌的文档对象和数组对象，但是BSON有JSON没有的一些数据类型，如Date和BinData类型。

BSON可以做为网络数据交换的一种存储形式，这个有点类似于Google的Protocol Buffer，但是BSON是一种schema-less的存储形式，它的优点是灵活性高，但它的缺点是空间利用率不是很理想，

BSON有三个特点：轻量性、可遍历性、高效性

{“hello":"world"} 这是一个BSON的例子，其中"hello"是key name，它一般是cstring类型，字节表示是cstring::= (byte*) "/x00" ,其中*表示零个或多个byte字节，/x00表示结束符;后面的"world"是value值，它的类型一般是string,double,array,binarydata等类型。

MongoDB.Bson在MongoDB中的使用

　　MongoDB使用了BSON这种结构来存储数据和网络数据交换。把这种格式转化成一文档这个概念(Document)，因为BSON是schema-free的，

所以在MongoDB中所对应的文档也有这个特征，这里的一个Document也可以理解成关系数据库中的一条记录(Record)，只是这里的Document的变化更丰富一些，如Document可以嵌套。

　　MongoDB以BSON做为其存储结构的一种重要原因是其可遍历性。

MongoDB.Driver是什么

顾名思义，MongoDB.Driver是官网推出的连接MongoDB的驱动包，我们连接MongoDB需要依赖这个链接库。

2、创建MongoDB上下文连接工具类

引入 MongoDB.Bson 和 MongoDB.Driver包后就可以编写帮助类了，帮助类太多，帮助类可以自己拓展需要的方法，不过这里拓展的方法已经足够使用了。

创建一个上下文文件夹DbContexts，创建DBFactory帮助类，添加Bson和Driver的using引用，内容如下（文档末尾附源码里面有）：

using MongoDB.Bson;
using MongoDB.Driver;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace MongoDBTest.DbContexts
{
    /// 
    /// Date 2021-07-12
    /// Author：xiongze
    /// Describe：MongoDB工具类
    /// 
    /// 
    public static class MongodbClient where T : class
    {
        #region +MongodbInfoClient 获取mongodb实例
        /// 
        /// 获取mongodb实例
        /// 
        /// 连接字符串，库，表
        /// 
        public static IMongoCollection MongodbInfoClient(MongodbHost host)
        {
            var mongoSettings = MongoClientSettings.FromConnectionString(host.Connection);
            mongoSettings.GuidRepresentation = GuidRepresentation.pythonLegacy;
            MongoClient client = new MongoClient(mongoSettings);
            var dataBase = client.GetDatabase(host.DataBase);
            return dataBase.GetCollection(host.Table);
        }
        #endregion
    }

    public class MongodbHost
    {
        //public MongodbHost()
        //{
        //    //Connection = CommonConfig.GetConnectionStrings().ConnectionStrings.MongoDBConnection;
        //    Connection ="";  //这里是获取配置连接的mongodb连接，我这里先不指定，各种指定写法不一样（net和netcore获取不一样）
        //    DataBase = new MongoUrl(Connection).DatabaseName;
        //}
        public MongodbHost(string connectionString)
        {
            Connection = connectionString;
            DataBase = new MongoUrl(connectionString).DatabaseName;
        }
        /// 
        /// 连接字符串
        /// 
        public string Connection { get; set; }
        /// 
        /// 库
        /// 
        public string DataBase { get; set; }
        /// 
        /// 表
        /// 
        public string Table { get; set; }

    }

    public static class TMongodbHelper where T : class, new()
    {
        #region +Add 添加一条数据
        /// 
        /// 添加一条数据
        /// 
        /// 添加的实体
        /// mongodb连接信息
        /// 
        public static int Add(MongodbHost host, T t)
        {
            try
            {
                var client = MongodbClient.MongodbInfoClient(host);
                client.InsertOne(t);
                return 1;
            }
            catch
            {
                return 0;
            }
        }
        #endregion

        #region +AddAsync 异步添加一条数据
        /// 
        /// 异步添加一条数据
        /// 
        /// 添加的实体
        /// mongodb连接信息
        /// 
        public static async Task<int> AddAsync(MongodbHost host, T t)
        {
            try
            {
                var client = MongodbClient.MongodbInfoClient(host);
                await client.InsertOneAsync(t);
                return 1;
            }
            catch
            {
                return 0;
            }
        }
        #endregion

        #region +InsertMany 批量插入
        /// 
        /// 批量插入
        /// 
        /// mongodb连接信息
        /// 实体集合
        /// 
        public static int InsertMany(MongodbHost host, List t)
        {
            try
            {
                var client = MongodbClient.MongodbInfoClient(host);
                client.InsertMany(t);
                return 1;
            }
            catch (Exception)
            {
                //throw ex;
                return 0;
            }
        }
        #endregion

        #region +InsertManyAsync 异步批量插入
        /// 
        /// 异步批量插入
        /// 
        /// mongodb连接信息
        /// 实体集合
        /// 
        public static async Task<int> InsertManyAsync(MongodbHost host, List t)
        {
            try
            {
                var client = MongodbClient.MongodbInfoClient(host);
                await client.InsertManyAsync(t);
                return 1;
            }
            catch (Exception)
            {
                return 0;
            }
        }

        public static async Task<int> AsyncInsertManyMethod(MongodbHost mongodb, T log)
        {
            int i = await TMongodbHelper.InsertManyAsync(mongodb, new List { log });
            return i;
        }
        #endregion

        #region +Update 修改一条数据
        /// 
        /// 修改一条数据
        /// 
        /// 添加的实体
        /// mongodb连接信息
        /// 
        public static UpdateResult Update(MongodbHost host, T t, string id)
        {
            try
            {
                var client = MongodbClient.MongodbInfoClient(host);
                //修改条件
                FilterDefinition filter = Builders.Filter.Eq("_id", new ObjectId(id));
                //要修改的字段
                var list = new List>();
                foreach (var item in t.GetType().GetProperties())
                {
                    if (item.Name.ToLower() == "id") continue;
                    list.Add(Builders.Update.Set(item.Name, item.GetValue(t)));
                }
                var updatefilter = Builders.Update.Combine(list);
                return client.UpdateOne(filter, updatefilter);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        #endregion

        #region +UpdateAsync 异步修改一条数据
        /// 
        /// 异步修改一条数据
        /// 
        /// 添加的实体
        /// mongodb连接信息
        /// 
        public static async Task UpdateAsync(MongodbHost host, T t, string id)
        {
            try
            {
                var client = MongodbClient.MongodbInfoClient(host);
                //修改条件
                FilterDefinition filter = Builders.Filter.Eq("_id", new ObjectId(id));
                //要修改的字段
                var list = new List>();
                foreach (var item in t.GetType().GetProperties())
                {
                    if (item.Name.ToLower() == "id") continue;
                    list.Add(Builders.Update.Set(item.Name, item.GetValue(t)));
                }
                var updatefilter = Builders.Update.Combine(list);
                return await client.UpdateOneAsync(filter, updatefilter);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        #endregion

        #region +UpdateManay 批量修改数据
        /// 
        /// 批量修改数据
        /// 
        /// 要修改的字段
        /// mongodb连接信息
        /// 修改条件
        /// 
        public static UpdateResult UpdateManay(MongodbHost host, Dictionary<string, string> dic, FilterDefinition filter)
        {
            try
            {
                var client = MongodbClient.MongodbInfoClient(host);
                T t = new T();
                //要修改的字段
                var list = new List>();
                foreach (var item in t.GetType().GetProperties())
                {
                    if (!dic.ContainsKey(item.Name)) continue;
                    var value = dic[item.Name];
                    list.Add(Builders.Update.Set(item.Name, value));
                }
                var updatefilter = Builders.Update.Combine(list);
                return client.UpdateMany(filter, updatefilter);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        #endregion

        #region +UpdateManayAsync 异步批量修改数据
        /// 
        /// 异步批量修改数据
        /// 
        /// 要修改的字段
        /// mongodb连接信息
        /// 修改条件
        /// 
        public static async Task UpdateManayAsync(MongodbHost host, Dictionary<string, string> dic, FilterDefinition filter)
        {
            try
            {
                var client = MongodbClient.MongodbInfoClient(host);
                T t = new T();
                //要修改的字段
                var list = new List>();
                foreach (var item in t.GetType().GetProperties())
                {
                    if (!dic.ContainsKey(item.Name)) continue;
                    var value = dic[item.Name];
                    list.Add(Builders.Update.Set(item.Name, value));
                }
                var updatefilter = Builders.Update.Combine(list);
                return await client.UpdateManyAsync(filter, updatefilter);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        #endregion

        #region Delete 删除一条数据
        /// 
        /// 删除一条数据
        /// 
        /// mongodb连接信息
        /// objectId
        /// 
        public static DeleteResult Delete(MongodbHost host, string id)
        {
            try
            {
                var client = MongodbClient.MongodbInfoClient(host);
                FilterDefinition filter = Builders.Filter.Eq("_id", new ObjectId(id));
                return client.DeleteOne(filter);
            }
            catch (Exception ex)
            {
                throw ex;
            }

        }
        #endregion

        #region DeleteAsync 异步删除一条数据
        /// 
        /// 异步删除一条数据
        /// 
        /// mongodb连接信息
        /// objectId
        /// 
        public static async Task DeleteAsync(MongodbHost host, string id)
        {
            try
            {
                var client = MongodbClient.MongodbInfoClient(host);
                //修改条件
                FilterDefinition filter = Builders.Filter.Eq("_id", new ObjectId(id));
                return await client.DeleteOneAsync(filter);
            }
            catch (Exception ex)
            {
                throw ex;
            }

        }
        #endregion

        #region DeleteMany 删除多条数据
        /// 
        /// 删除一条数据
        /// 
        /// mongodb连接信息
        /// 删除的条件
        /// 
        public static DeleteResult DeleteMany(MongodbHost host, FilterDefinition filter)
        {
            try
            {
                var client = MongodbClient.MongodbInfoClient(host);
                return client.DeleteMany(filter);
            }
            catch (Exception ex)
            {
                throw ex;
            }

        }
        #endregion

        #region DeleteManyAsync 异步删除多条数据
        /// 
        /// 异步删除多条数据
        /// 
        /// mongodb连接信息
        /// 删除的条件
        /// 
        public static async Task DeleteManyAsync(MongodbHost host, FilterDefinition filter)
        {
            try
            {
                var client = MongodbClient.MongodbInfoClient(host);
                return await client.DeleteManyAsync(filter);
            }
            catch (Exception ex)
            {
                throw ex;
            }

        }
        #endregion

        #region Count 根据条件获取总数
        /// 
        /// 根据条件获取总数
        /// 
        /// mongodb连接信息
        /// 条件
        /// 
        public static long Count(MongodbHost host, FilterDefinition filter)
        {
            try
            {
                var client = MongodbClient.MongodbInfoClient(host);
                return client.CountDocuments(filter);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        #endregion

        #region CountAsync 异步根据条件获取总数
        /// 
        /// 异步根据条件获取总数
        /// 
        /// mongodb连接信息
        /// 条件
        /// 
        public static async Task<long> CountAsync(MongodbHost host, FilterDefinition filter)
        {
            try
            {
                var client = MongodbClient.MongodbInfoClient(host);
                return await client.CountDocumentsAsync(filter);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        #endregion

        #region FindOne 根据id查询一条数据
        /// 
        /// 根据id查询一条数据
        /// 
        /// mongodb连接信息
        /// objectid
        /// 要查询的字段，不写时查询全部
        /// 
        public static T FindOne(MongodbHost host, string id, string[] field = null)
        {
            try
            {
                var client = MongodbClient.MongodbInfoClient(host);
                FilterDefinition filter = Builders.Filter.Eq("_id", new ObjectId(id));
                //不指定查询字段
                if (field == null || field.Length == 0)
                {
                    return client.Find(filter).FirstOrDefault();
                }

                //制定查询字段
                var fieldList = new List>();
                for (int i = 0; i < field.Length; i++)
                {
                    fieldList.Add(Builders.Projection.Include(field[i].ToString()));
                }
                var projection = Builders.Projection.Combine(fieldList);
                fieldList?.Clear();
                return client.Find(filter).Project(projection).FirstOrDefault();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        #endregion

        #region FindOneAsync 异步根据id查询一条数据
        /// 
        /// 异步根据id查询一条数据
        /// 
        /// mongodb连接信息
        /// objectid
        /// 
        public static async Task FindOneAsync(MongodbHost host, string id, string[] field = null)
        {
            try
            {
                var client = MongodbClient.MongodbInfoClient(host);
                FilterDefinition filter = Builders.Filter.Eq("_id", new ObjectId(id));
                //不指定查询字段
                if (field == null || field.Length == 0)
                {
                    return await client.Find(filter).FirstOrDefaultAsync();
                }

                //制定查询字段
                var fieldList = new List>();
                for (int i = 0; i < field.Length; i++)
                {
                    fieldList.Add(Builders.Projection.Include(field[i].ToString()));
                }
                var projection = Builders.Projection.Combine(fieldList);
                fieldList?.Clear();
                return await client.Find(filter).Project(projection).FirstOrDefaultAsync();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        #endregion

        #region FindList 查询集合
        /// 
        /// 查询集合
        /// 
        /// mongodb连接信息
        /// 查询条件
        /// 要查询的字段,不写时查询全部
        /// 要排序的字段
        /// 
        public static List FindList(MongodbHost host, FilterDefinition filter, string[] field = null, SortDefinition sort = null)
        {
            try
            {
                var client = MongodbClient.MongodbInfoClient(host);
                //不指定查询字段
                if (field == null || field.Length == 0)
                {
                    if (sort == null) return client.Find(filter).ToList();
                    //进行排序
                    return client.Find(filter).Sort(sort).ToList();
                }

                //制定查询字段
                var fieldList = new List>();
                for (int i = 0; i < field.Length; i++)
                {
                    fieldList.Add(Builders.Projection.Include(field[i].ToString()));
                }
                var projection = Builders.Projection.Combine(fieldList);
                fieldList?.Clear();
                if (sort == null) return client.Find(filter).Project(projection).ToList();
                //排序查询
                return client.Find(filter).Sort(sort).Project(projection).ToList();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        #endregion

        #region FindListAsync 异步查询集合
        /// 
        /// 异步查询集合
        /// 
        /// mongodb连接信息
        /// 查询条件
        /// 要查询的字段,不写时查询全部
        /// 要排序的字段
        /// 
        public static async Task> FindListAsync(MongodbHost host, FilterDefinition filter, string[] field = null, SortDefinition sort = null)
        {
            try
            {
                var client = MongodbClient.MongodbInfoClient(host);
                //不指定查询字段
                if (field == null || field.Length == 0)
                {
                    if (sort == null) return await client.Find(filter).ToListAsync();
                    return await client.Find(filter).Sort(sort).ToListAsync();
                }

                //制定查询字段
                var fieldList = new List>();
                for (int i = 0; i < field.Length; i++)
                {
                    fieldList.Add(Builders.Projection.Include(field[i].ToString()));
                }
                var projection = Builders.Projection.Combine(fieldList);
                fieldList?.Clear();
                if (sort == null) return await client.Find(filter).Project(projection).ToListAsync();
                //排序查询
                return await client.Find(filter).Sort(sort).Project(projection).ToListAsync();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        #endregion

        #region FindListByPage 分页查询集合
        /// 
        /// 分页查询集合
        /// 
        /// mongodb连接信息
        /// 查询条件
        /// 当前页
        /// 页容量
        /// 总条数
        /// 要查询的字段,不写时查询全部
        /// 要排序的字段
        /// 
        public static List FindListByPage(MongodbHost host, FilterDefinition filter, int pageIndex, int pageSize, out long count, string[] field = null, SortDefinition sort = null)
        {
            try
            {
                var client = MongodbClient.MongodbInfoClient(host);
                count = client.CountDocuments(filter);
                //不指定查询字段
                if (field == null || field.Length == 0)
                {
                    if (sort == null) return client.Find(filter).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();
                    //进行排序
                    return client.Find(filter).Sort(sort).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();
                }

                //制定查询字段
                var fieldList = new List>();
                for (int i = 0; i < field.Length; i++)
                {
                    fieldList.Add(Builders.Projection.Include(field[i].ToString()));
                }
                var projection = Builders.Projection.Combine(fieldList);
                fieldList?.Clear();

                //不排序
                if (sort == null) return client.Find(filter).Project(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();

                //排序查询
                return client.Find(filter).Sort(sort).Project(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();

            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        #endregion

        #region FindListByPageAsync 异步分页查询集合
        /// 
        /// 异步分页查询集合
        /// 
        /// mongodb连接信息
        /// 查询条件
        /// 当前页
        /// 页容量
        /// 要查询的字段,不写时查询全部
        /// 要排序的字段
        /// 
        public static async Task> FindListByPageAsync(MongodbHost host, FilterDefinition filter, int pageIndex, int pageSize, string[] field = null, SortDefinition sort = null)
        {
            try
            {
                var client = MongodbClient.MongodbInfoClient(host);
                //不指定查询字段
                if (field == null || field.Length == 0)
                {
                    if (sort == null) return await client.Find(filter).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync();
                    //进行排序
                    return await client.Find(filter).Sort(sort).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync();
                }

                //制定查询字段
                var fieldList = new List>();
                for (int i = 0; i < field.Length; i++)
                {
                    fieldList.Add(Builders.Projection.Include(field[i].ToString()));
                }
                var projection = Builders.Projection.Combine(fieldList);
                fieldList?.Clear();

                //不排序
                if (sort == null) return await client.Find(filter).Project(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync();

                //排序查询
                return await client.Find(filter).Sort(sort).Project(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync();

            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        #endregion

        #region Save 替换原数据表列 (字段删除添加)

        public static T Save(MongodbHost host, FilterDefinition filter, T t)
        {
            try
            {
                var client = MongodbClient.MongodbInfoClient(host);
                return client.FindOneAndReplace(filter, t);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        #endregion

        #region SaveAsync 替换原数据表列 (字段删除添加)

        public static async Task SaveAsync(MongodbHost host, FilterDefinition filter, T t)
        {
            try
            {
                var client = MongodbClient.MongodbInfoClient(host);
                return await client.FindOneAndReplaceAsync(filter, t);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        #endregion



    }
}

View Code

写好工具类我们就可以直接写增删改查了。

3、连接MongoDB编编写语句

3.1、插入

先定义实体类，下面就不在重复说定义实体了。

 [BsonIgnoreExtraElements]  //忽略增加项（MongoDB是文档型数据库，所以数据字段是根据传入的数据自动增加的，如果不忽略，增加项，查询返回实体就少了字段报错，当然也可以查询指定字段）
        public class empty_collection  
        {
            public ObjectId _id { get; set; }  //主键
            public string Name { get; set; }   //姓名
            public List ClassTable { get; set; }  //数据集合
            public DateTime CreateDate { get; set; }  //创建时间
        }

        public class ClassTable
        {
            public string ItemName { get; set; } //键名
            public string ItemValue { get; set; } //值
        }

        //返回类型实体
        public class ResultInfo
        {
            public int code { get; set; }
            public string message { get; set; }
            public object result { get; set; }
        }

View Code

编写插入方法，注意看里面的注释，数据库连接的字符串格式、传值的类型等都有详细注释，这里就不进行啰嗦，直接上菜。

//插入
        //GET api/values/InsertDate
        [HttpGet("InsertDate")]
        public JsonResult InsertDate()
        {
            ResultInfo res = new ResultInfo();

            try
            {
                //连接mongodb的固定格式，应该写在配置里面，由于这里做演示，所以单独写
                //user:user         第一个是用户名，第二个是密码
                //localhost:27017   是你数据库的连接
                //TestData          是你的数据库名称
                var mongodbClient = "mongodb://user:user@localhost:27017/TestData";  
                MongodbHost mongodb = new MongodbHost(mongodbClient);  

                mongodb.DataBase = "TestData";  //数据库名
                mongodb.Table = "empty_collection";  //操作的数据表（如果数据库没有定义表名，插入时会自动定义）

                List ctList = new List();
                int i = 0;
                while(i<3)
                {
                    ClassTable ct = new ClassTable();
                    switch (i)
                    {
                        case 0:
                            ct.ItemName = "班级";
                            ct.ItemValue = "取经天团";
                            break;
                        case 1:
                            ct.ItemName = "种族";
                            ct.ItemValue = "龙族";
                            break;
                        case 2:
                            ct.ItemName = "战斗力";
                            ct.ItemValue = "999999";
                            break;
                    }
                    ctList.Add(ct);
                    i++;
                }

                empty_collection model = new empty_collection()
                {
                    Name = "白龙马",
                    ClassTable = ctList,
                    CreateDate=DateTime.Now
                };
                List Listmodel = new List();
                Listmodel.Add(model);
                var resCount=TMongodbHelper.InsertMany(mongodb, Listmodel);  // 插入多条数据

                res.code = resCount;
                res.message = resCount > 0 ? "操作成功" : "操作失败";
            }
            catch (Exception ex)
            {
                res.code = -2;
                res.message = "操作失败：" + ex.Message;
            }

            return new JsonResult(res);
        }

View Code

然后我们运行调用这个方法，查看一下数据库的值，很显然写入成功了。

3.2、查询

编写查询方法，然后调用这个方法。

 //查询
        //GET api/values/GetDateList
        [HttpGet("GetDateList")]
        public JsonResult GetDateList()
        {
            ResultInfo res = new ResultInfo();
            try
            {
                //连接mongodb的固定格式，应该写在配置里面，由于这里做演示，所以单独写
                //user:user         第一个是用户名，第二个是密码
                //localhost:27017   是你数据库的连接
                //TestData          是你的数据库名称
                var mongodbClient = "mongodb://user:user@localhost:27017/TestData";
                MongodbHost mongodb = new MongodbHost(mongodbClient);

                mongodb.DataBase = "TestData";  //数据库名
                mongodb.Table = "empty_collection";  //操作的数据表


                #region 筛选条件（至少一个条件）

                var list = new List>();
                //Gte 大于等于   Lte 小于等于
                list.Add(Builders.Filter.Gte("CreateDate", "2021-01-01")); //注意：MongoDB当前方法查询需要必传至少一个参数，否则会报错
                var filter = Builders.Filter.And(list);

                #endregion

                var GetList = TMongodbHelper.FindList(mongodb, filter).ToList();    //查询全部
                //var GetList = TMongodbHelper.FindListByPage(mongodb, filter, 1, 5, out count).ToList();   //分页查询
                res.code = 0;
                res.message = "查询成功";
                res.result = GetList;

            }
            catch (Exception ex)
            {
                res.code = -2;
                res.message = ex.Message;
            }
            return new JsonResult(res);
        }

View Code

需要注意的是，查询语句的数据库交互至少有一个条件

3.3、修改

编写修改方法，然后调用这个方法。

 //修改
        //GET api/values/UpdateDate
        [HttpGet("UpdateDate")]
        public JsonResult UpdateDate()
        {
            ResultInfo res = new ResultInfo();
            try
            {
                //连接mongodb的固定格式，应该写在配置里面，由于这里做演示，所以单独写
                //user:user         第一个是用户名，第二个是密码
                //localhost:27017   是你数据库的连接
                //TestData          是你的数据库名称
                var mongodbClient = "mongodb://user:user@localhost:27017/TestData";
                MongodbHost mongodb = new MongodbHost(mongodbClient);

                mongodb.DataBase = "TestData";  //数据库名
                mongodb.Table = "empty_collection";  //操作的数据表


                //需要修改的条件
                var UpdateList = new List>();
                UpdateList.Add(Builders.Filter.Gte("CreateDate", "2021-01-01")); //注意：MongoDB当前方法查询需要必传至少一个参数，否则会报错
                UpdateList.Add(Builders.Filter.Eq("Name", "白龙马"));
                var filterList = Builders.Filter.And(UpdateList);

                //需要修改后的值
                Dictionary<string, string> dicList = new Dictionary<string, string>();
                dicList.Add("Name", "南无八部天龙广力菩萨");
                dicList.Add("CreateDate", DateTime.Now.ToString());

                var resCount = TMongodbHelper.UpdateManay(mongodb, dicList, filterList);

                res.code = resCount.ModifiedCount > 0 ? 0 : -2;
                res.message = resCount.ModifiedCount > 0 ? "操作成功" : "操作失败";

            }
            catch (Exception ex)
            {
                res.message = "操作失败：" + ex.Message;
            }
            return new JsonResult(res);
        }

View Code

3.4、删除

编写删除方法，然后调用这个方法。

//删除
        //GET api/values/DeleteDate
        [HttpGet("DeleteDate")]
        public JsonResult DeleteDate()
        {
            ResultInfo res = new ResultInfo();
            try
            {
                //连接mongodb的固定格式，应该写在配置里面，由于这里做演示，所以单独写
                //user:user         第一个是用户名，第二个是密码
                //localhost:27017   是你数据库的连接
                //TestData          是你的数据库名称
                var mongodbClient = "mongodb://user:user@localhost:27017/TestData";
                MongodbHost mongodb = new MongodbHost(mongodbClient);

                mongodb.DataBase = "TestData";  //数据库名
                mongodb.Table = "empty_collection";  //操作的数据表


                #region 筛选条件（至少一个条件）

                var list = new List>();
                //Gte 大于等于   Lte 小于等于
                list.Add(Builders.Filter.Gte("CreateDate", "2021-01-01")); //注意：MongoDB当前方法查询需要必传至少一个参数，否则会报错
                list.Add(Builders.Filter.Eq("Name", "南无八部天龙广力菩萨"));
                var filter = Builders.Filter.And(list);

                #endregion

                var resCount = TMongodbHelper.DeleteMany(mongodb, filter);

                res.code = resCount.DeletedCount > 0 ? 0 : -2;
                res.message = resCount.DeletedCount > 0 ? "操作成功" : "操作失败";

            }
            catch (Exception ex)
            {
                res.message = "操作失败：" + ex.Message;
            }
            return new JsonResult(res);
        }

View Code

源码下载（git）

https://gitee.com/xiongze/MongoDBTest.git

https://gitee.com/xiongze/MongoDBTest

后语

NoSql非关系型数据库之MongoDB在项目中的初步应用我们就介绍到这里了，

有想法其他想法的可以在评论区留言讨论。

欢迎关注订阅微信公众号【熊泽有话说】，更多好玩易学知识等你来取
作者：熊泽-学习中的苦与乐
公众号：熊泽有话说
出处：https://www.cnblogs.com/xiongze520/p/15001789.html
创作不易，任何人或团体、机构全部转载或者部分转载、摘录，请在文章明显位置注明作者和原文链接。