C# 操作Mongodb数据库

最新推荐文章于 2025-04-12 15:46:11 发布
最新推荐文章于 2025-04-12 15:46:11 发布
阅读量1.8k 收藏 5
点赞数 1
分类专栏： C# 文章标签： c# 数据库 mongodb
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zzzsss123333/article/details/124375916
版权

C# 操作Mongodb数据库

1.引入NuGet包

在这里插入图片描述

2.创建数据库操作类（MongodbHelper）

里面有增删改查的所有内容，同步和异步

using MongoDB.Bson;
using MongoDB.Driver;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace ConsoleApp9
{
    public class MongoHelper<T>
    {
        private string connStr = "";//服务器网址
        private string dbName = "";//数据库名称
        private IMongoClient client;//连接客户端
        private IMongoDatabase db;//连接数据库
        private string collName;//集合名称
        public MongoHelper(string connStr, string dbName, string collName)
        {
            this.connStr = connStr;
            this.dbName = dbName;
            this.collName = collName;
            this.Init();
        }
        private void Init()
        {

            if (client == null)
                client = new MongoClient(this.connStr);
            if (db == null)
                db = client.GetDatabase(this.dbName);
        }
        public DbMessage Insert(T obj)
        {
            try
            {
                var collection = db.GetCollection<T>(this.collName);
                collection.InsertOne(obj);
                return new DbMessage() { Ex = string.Empty, iFlg = 1 };
            }
            catch (Exception e)
            {
                Console.WriteLine("Insert错误!!!");
                return new DbMessage() { Ex = e.Message, iFlg = -1 };
            }
        }
        public DbMessage Insert(Dictionary<string,object> dicInfo)
        {
            try
            {
                var collection = db.GetCollection<BsonDocument>(this.collName);
                var document = new BsonDocument(dicInfo);
                collection.InsertOne(document);
                return new DbMessage() { Ex = string.Empty, iFlg = 1 };
            }
            catch (Exception e)
            {
                Console.WriteLine("Insert错误!!!");
                return new DbMessage() { Ex = e.Message, iFlg = -1 };
            }
        }
        public DbMessage Insert(List<T> documents)
        {
            try
            {
                var collection = db.GetCollection<T>(this.collName);
                collection.InsertMany(documents);
                return new DbMessage() { Ex = string.Empty, iFlg = documents.Count };
            }
            catch (Exception e)
            {
                Console.WriteLine("Insert出错!!!");
                return new DbMessage() { Ex = e.Message, iFlg = -1 };
            }
        }
        public async Task<DbMessage> InsertAsync(T obj)
        {
            try
            {
                var collection = db.GetCollection<T>(this.collName);
                await collection.InsertOneAsync(obj);
                return new DbMessage() { Ex = string.Empty, iFlg = 1 };
            }
            catch (Exception e)
            {
                Console.WriteLine("InsertAsync错误!!!");
                return new DbMessage() { Ex = e.Message, iFlg = -1 };
            }
        }
        public async Task<DbMessage> InsertAsync(Dictionary<string, object> dicInfo)
        {
            try
            {
                var collection = db.GetCollection<BsonDocument>(this.collName);
                var document = new BsonDocument(dicInfo);
                await collection.InsertOneAsync(document);
                return new DbMessage() { Ex = string.Empty, iFlg = 1 };
            }
            catch (Exception e)
            {
                Console.WriteLine("InsertAsync错误!!!");
                return new DbMessage() { Ex = e.Message, iFlg = -1 };
            }
        }
        public async Task<DbMessage> InsertManyAsync(List<T> documents)
        {
            try
            {
                var collection = db.GetCollection<T>(this.collName);
                await collection.InsertManyAsync(documents);
                return new DbMessage() { Ex = string.Empty, iFlg = documents.Count };
            }
            catch (Exception e)
            {
                Console.WriteLine("InsterManyAsync出错!!!");
                return new DbMessage() { Ex = e.Message, iFlg = -1 };
            }
        }
        public List<T> QueryMany()
        {
            try
            {
                var collection = db.GetCollection<T>(this.collName);
                var rest = collection.Find(Builders<T>.Filter.Empty);
                return rest.As<T>().ToList();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                return null;
            }
        }
        public List<T> QueryMany(string field, object val)
        {
            try
            {
                var collection = db.GetCollection<T>(collName);
                var rest = collection.Find(Builders<T>.Filter.Eq(field, val));
                return rest.As<T>().ToList();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                return null;
            }
        }
        public List<T> QueryMany(BsonDocument document)
        {
            try
            {
                var collection = db.GetCollection<T>(collName);
                var rest =collection.Find(document);
                return rest.As<T>().ToList();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                return null;
            }
        }
        public async Task<List<T>> QueryManyAsync()
        {
            try
            {
                var collection = db.GetCollection<T>(this.collName);
                var rest = await collection.FindAsync(Builders<T>.Filter.Empty);
                return await rest.ToListAsync<T>();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                return null;
            }
        }
        public async Task<List<T>> QueryManyAsync(string field, object val)
        {
            try
            {
                var collection = db.GetCollection<T>(collName);
                var rest = await collection.FindAsync(Builders<T>.Filter.Eq(field, val));
                return await rest.ToListAsync<T>();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                return null;
            }
        }
        public async Task<List<T>> QueryManyAsync(BsonDocument document)
        {
            try
            {
                var collection = db.GetCollection<T>(collName);
                var rest = await collection.FindAsync(document);
                return await rest.ToListAsync();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                return null;
            }
        }
        public DbMessage UpdateOne(FilterDefinition<T> filter, UpdateDefinition<T> update, bool upsert = false)
        {
            try
            {
                var collection = db.GetCollection<T>(collName);
                var rest = collection.UpdateOne(filter, update, new UpdateOptions { IsUpsert = upsert });
                return new DbMessage { Ex = string.Empty, iFlg = rest.ModifiedCount };
            }
            catch (Exception e)
            {
                Console.WriteLine("UpdateOne错误!!!");
                return new DbMessage { Ex = e.Message, iFlg = -1 };
            }
        }
        public DbMessage UpdateOne(string filterKey, object filterVal, string setKey, object setVal, bool upsert = false)
        {
            try
            {
                var collection = db.GetCollection<T>(collName);
                var filter = Builders<T>.Filter.Eq(filterKey, filterVal);
                var update = Builders<T>.Update.Set(setKey, setVal);
                var rest = collection.UpdateOne(filter, update, new UpdateOptions { IsUpsert = upsert });
                return new DbMessage { Ex = string.Empty, iFlg = rest.ModifiedCount };
            }
            catch (Exception e)
            {
                Console.WriteLine("UpdateOne错误!!!");
                return new DbMessage { Ex = e.Message, iFlg = -1 };
            }
        }
        public DbMessage UpdateMany(FilterDefinition<T> filter, UpdateDefinition<T> update, bool upsert = false)
        {
            try
            {
                var collection = db.GetCollection<T>(collName);
                var rest = collection.UpdateMany(filter, update, new UpdateOptions { IsUpsert = upsert });
                return new DbMessage { Ex = string.Empty, iFlg = rest.ModifiedCount };
            }
            catch (Exception e)
            {
                Console.WriteLine("UpdateMany错误!!!");
                return new DbMessage { Ex = e.Message, iFlg = -1 };
            }
        }
        public DbMessage UpdateMany(string filterKey, object filterVal, string setKey, object setVal, bool upsert = false)
        {
            try
            {
                var collection = db.GetCollection<T>(collName);
                var filter = Builders<T>.Filter.Eq(filterKey, filterVal);
                var update = Builders<T>.Update.Set(setKey, setVal);
                var rest = collection.UpdateMany(filter, update, new UpdateOptions { IsUpsert = upsert });
                return new DbMessage { Ex = string.Empty, iFlg = rest.ModifiedCount };
            }
            catch (Exception e)
            {
                Console.WriteLine("UpdateMany错误!!!");
                return new DbMessage { Ex = e.Message, iFlg = -1 };
            }
        }
        public async Task<DbMessage> UpdateOneAsync(FilterDefinition<T> filter, UpdateDefinition<T> update, bool upsert = false)
        {
            try
            {
                var collection = db.GetCollection<T>(collName);
                var rest = await collection.UpdateOneAsync(filter, update, new UpdateOptions { IsUpsert = upsert });
                return new DbMessage { Ex = string.Empty, iFlg = rest.ModifiedCount };
            }
            catch (Exception e)
            {
                Console.WriteLine("UpdateOneAsync错误!!!");
                return new DbMessage { Ex = e.Message, iFlg = -1 };
            }
        }
        public async Task<DbMessage> UpdateOneAsync(string filterKey, object filterVal, string setKey, object setVal, bool upsert = false)
        {
            try
            {
                var collection = db.GetCollection<T>(collName);
                var filter = Builders<T>.Filter.Eq(filterKey, filterVal);
                var update = Builders<T>.Update.Set(setKey, setVal);
                var rest = await collection.UpdateOneAsync(filter, update, new UpdateOptions { IsUpsert = upsert });
                return new DbMessage { Ex = string.Empty, iFlg = rest.ModifiedCount };
            }
            catch (Exception e)
            {
                Console.WriteLine("UpdateOneAsync错误!!!");
                return new DbMessage { Ex = e.Message, iFlg = -1 };
            }
        }
        public async Task<DbMessage> UpdateManyAsync(FilterDefinition<T> filter, UpdateDefinition<T> update, bool upsert = false)
        {
            try
            {
                var collection = db.GetCollection<T>(collName);
                var rest = await collection.UpdateManyAsync(filter, update, new UpdateOptions { IsUpsert = upsert });
                return new DbMessage { Ex = string.Empty, iFlg = rest.ModifiedCount };
            }
            catch (Exception e)
            {
                Console.WriteLine("UpdateManyAsync错误!!!");
                return new DbMessage { Ex = e.Message, iFlg = -1 };
            }
        }
        public async Task<DbMessage> UpdateManyAsync(string filterKey, object filterVal, string setKey, object setVal, bool upsert = false)
        {
            try
            {
                var collection = db.GetCollection<T>(collName);
                var filter = Builders<T>.Filter.Eq(filterKey, filterVal);
                var update = Builders<T>.Update.Set(setKey, setVal);
                var rest = await collection.UpdateManyAsync(filter, update, new UpdateOptions { IsUpsert = upsert });
                return new DbMessage { Ex = string.Empty, iFlg = rest.ModifiedCount };
            }
            catch (Exception e)
            {
                Console.WriteLine("UpdateManyAsync错误!!!");
                return new DbMessage { Ex = e.Message, iFlg = -1 };
            }
        }
        public DbMessage DeleteOne(string filterKey, string filterVal, bool isTrueDelete = false)
        {
            try
            {
                var collection = db.GetCollection<T>(collName);
                if (isTrueDelete)
                {
                    var rest = collection.DeleteOne(Builders<T>.Filter.Eq(filterKey, filterVal));
                    return new DbMessage { Ex = string.Empty, iFlg = rest.DeletedCount };
                }
                else
                {
                    var msg = UpdateOne(filterKey, filterVal, "IsDelete", true);
                    if (msg.iFlg == -1 || !string.IsNullOrEmpty(msg.Ex))
                        throw new Exception("DeleteOne中更新字段IsDelete出错!!!");
                    return new DbMessage { Ex = msg.Ex, iFlg = msg.iFlg };
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("DeleteOneAsync错误!!!");
                return new DbMessage { Ex = e.Message, iFlg = -1 };
            }
        }
        public DbMessage DeleteMany(string filterKey, string filterVal, bool isTrueDelete = false)
        {
            try
            {
                var collection = db.GetCollection<T>(collName);
                if (isTrueDelete)
                {
                    var rest = collection.DeleteMany(Builders<T>.Filter.Eq(filterKey, filterVal));
                    return new DbMessage { Ex = string.Empty, iFlg = rest.DeletedCount };
                }
                else
                {
                    var msg = UpdateMany(filterKey, filterVal, "IsDelete", true);
                    if (msg.iFlg == -1 || !string.IsNullOrEmpty(msg.Ex))
                        throw new Exception("DeleteOneAsync中更新字段IsDelete出错!!!");
                    return new DbMessage { Ex = msg.Ex, iFlg = msg.iFlg };
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("DeleteManyAsync错误!!!");
                return new DbMessage { Ex = e.Message, iFlg = -1 };
            }
        }
        public DbMessage DeleteMany(FilterDefinition<T> filter, bool isTrueDelete = false)
        {
            try
            {
                var collection = db.GetCollection<T>(collName);
                if (isTrueDelete)
                {
                    var rest = collection.DeleteMany(filter);
                    return new DbMessage { Ex = string.Empty, iFlg = rest.DeletedCount };
                }
                else
                {
                    try
                    {
                        var rest = collection.UpdateMany(filter, Builders<T>.Update.Set("IsDelete", true), new UpdateOptions { IsUpsert = false });
                        return new DbMessage { Ex = string.Empty, iFlg = rest.ModifiedCount };
                    }
                    catch
                    {
                        throw new Exception("DeleteOneAsync中更新字段IsDelete出错!!!");
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("DeleteOneAsync错误!!!");
                return new DbMessage { Ex = e.Message, iFlg = -1 };
            }
        }
        public async Task<DbMessage> DeleteOneAsync(FilterDefinition<T> filter,bool isTrueDelete = false)
        {
            try
            {
                var collection = db.GetCollection<T>(collName);
                if (isTrueDelete)
                {
                    var rest = await collection.DeleteOneAsync(filter);
                    return new DbMessage { Ex = string.Empty, iFlg = rest.DeletedCount };
                }
                else
                {
                    try
                    {
                        var rest = await collection.UpdateOneAsync(filter, Builders<T>.Update.Set("IsDelete", true), new UpdateOptions { IsUpsert = false });
                        return new DbMessage { Ex = string.Empty, iFlg = rest.ModifiedCount };
                    }
                    catch
                    {
                        throw new Exception("DeleteOneAsync中更新字段IsDelete出错!!!");
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("DeleteOneAsync错误!!!");
                return new DbMessage { Ex = e.Message, iFlg = -1 };
            }
        }
        public async Task<DbMessage> DeleteManyAsync(string filterKey, string filterVal, bool isTrueDelete = false)
        {
            try
            {
                var collection = db.GetCollection<T>(collName);
                if (isTrueDelete)
                {
                    var rest = await collection.DeleteManyAsync(Builders<T>.Filter.Eq(filterKey, filterVal));
                    return new DbMessage { Ex = string.Empty, iFlg = rest.DeletedCount };
                }
                else
                {
                    var msg = await UpdateManyAsync(filterKey, filterVal, "IsDelete", true);
                    if (msg.iFlg == -1 || !string.IsNullOrEmpty(msg.Ex))
                        throw new Exception("DeleteOneAsync中更新字段IsDelete出错!!!");
                    return new DbMessage { Ex = msg.Ex, iFlg = msg.iFlg };
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("DeleteManyAsync错误!!!");
                return new DbMessage { Ex = e.Message, iFlg = -1 };
            }
        }
        public async Task<DbMessage> DeleteManyAsync(FilterDefinition<T> filter, bool isTrueDelete = false)
        {
            try
            {
                var collection = db.GetCollection<T>(collName);
                if (isTrueDelete)
                {
                    var rest = await collection.DeleteManyAsync(filter);
                    return new DbMessage { Ex = string.Empty, iFlg = rest.DeletedCount };
                }
                else
                {
                    try
                    {
                        var rest = await collection.UpdateManyAsync(filter, Builders<T>.Update.Set("IsDelete", true), new UpdateOptions { IsUpsert = false });
                        return new DbMessage { Ex = string.Empty, iFlg = rest.ModifiedCount };
                    }
                    catch
                    {
                        throw new Exception("DeleteOneAsync中更新字段IsDelete出错!!!");
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("DeleteOneAsync错误!!!");
                return new DbMessage { Ex = e.Message, iFlg = -1 };
            }
        }
    }
    public class DbMessage
    {
        /// <summary>
        /// 反馈数量
        /// </summary>
        public long iFlg { get; set; }
        /// <summary>
        /// 反馈文字描述
        /// </summary>
        public string Ex { get; set; }
        public override string ToString()
        {
            return $"返回数据库消息: 是否成功:{string.IsNullOrEmpty(Ex)},反馈数量:{iFlg},描述:{Ex}";
        }
    }
}

3.使用封装的类操作数据库

namespace ConsoleApp9
{
    class Program
    {
        static void Main(string[] args)
        {
            //var connStr = "mongodb://127.0.0.1:27017";
            //var client = new MongoDB.Driver.MongoClient(connStr);
            //var db = client.GetDatabase("test");
            //var studentCollection = db.GetCollection<Students>("Students");
            //var student = new Students()
            //{
            //    _id = ObjectId.GenerateNewId(),
            //    Name = "zzs",
            //    Age = 18,
            //    Sex = true,
            //};
            //Console.WriteLine("开始插入");
            //studentCollection.InsertOneAsync(student);
            //Console.WriteLine("插入完成");

            //Thread thread = new Thread(async () =>
            //{
            //    MongoHelper<Students> studentsMongoHeaper = new MongoHelper<Students>("mongodb://127.0.0.1:27017", "test", "Students");
            //    var msg = await studentsMongoHeaper.InsterManyAsync(new List<Students>()
            //    {
            //        new Students{Name = "wy",Age = 14,Sex = true},
            //        new Students{Name = "pnb",Age = 20,Sex = true}
            //    });
            //    Console.WriteLine(msg);
            //    Console.WriteLine("插入完成!!!");
            //});
            //thread.Start();

            //Thread thread = new Thread(async () =>
            //{
            //    MongoHelper<Students> studentsMongoHeaper = new MongoHelper<Students>("mongodb://127.0.0.1:27017", "test", "Students");
            //    var doc = new BsonDocument();
            //    doc.Add("Age",18);
            //    doc.Add("Sex",false);
            //    var allList = await studentsMongoHeaper.QueryAsync(doc);
            //    Console.WriteLine(allList[0].Name);
            //});
            //thread.Start();

            //Thread thread = new Thread(async () =>
            //{
            //    MongoHelper<Students> studentsMongoHeaper = new MongoHelper<Students>("mongodb://127.0.0.1:27017", "test", "Students");
            //    var msg = await studentsMongoHeaper.UpdateManyAsync
            //        (
            //        Builders<Students>.Filter.Eq("Name", "zzs"),
            //        Builders<Students>.Update.Set("Age", 777)
            //        );
            //    Console.WriteLine(msg);
            //});
            //thread.Start();

            Thread thread = new Thread(async () =>
            {
                MongoHelper<Students> studentsMongoHeaper = new MongoHelper<Students>("mongodb://127.0.0.1:27017", "test", "Students");
                var msg = await studentsMongoHeaper.DeleteManyAsync("Name","zzs",true);
                Console.WriteLine(msg);
            });
            thread.Start();

            Console.ReadKey();
        }
    }

    class Students
    {
        public ObjectId _id { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }
        public bool Sex { get; set; }
    }
}
c#操作mongodb实例（含完整源码）
02-28
新版贡献经验总结含完整例子，操作类源码包括添加、修改、删除和查询（包括分页）
MongoDB C#
06-15
关于mongoDB数据库连接类，对于MongoDB 基本操作，新手可以借鉴哦
【MongoDB】在C#中使用
weixin_30945039的博客
11-04 244
一、MongoClient类 在2.10.0版本中引入了MongoClient类，同时在其API中也说明了Mongo类会在将来的版本中被MongoClient替换（Note: This class has been superseded byMongoClient, and may be deprecated in a future release.）。故在这次调整中，也对原...
C#使用MongoDB-第一章 基本操作
SchuylerEX的博客
01-12 3271
C#使用MongoDB.Driver库进行MongoDB数据库的操作
C# 与 MongoDB 库：深度解析与实战指南
最新发布
lijunhe1991的博客
04-12 669
在当今快节奏的应用程序开发领域，高效的数据存储与管理无疑是构建稳健软件系统的基石。MongoDB 作为一款备受瞩目的 NoSQL 数据库，以其灵活的文档模型、卓越的可扩展性以及出色的性能，在各类项目中得到了广泛应用。而 C# 凭借其强大的功能和丰富的生态系统，成为了众多开发者青睐的编程语言。当 C# 遇上 MongoDB，借助官方提供的 MongoDB 驱动库，两者得以无缝协作，为开发者带来便捷高效的数据处理体验。
C#操作MongoDB
weixin_33941350的博客
07-23 212
8.1）下载安装  想要在C#中使用MongoDB,首先得要有个MongoDB支持的C#版的驱动。C#版的驱动有很多种，如官方提供的，samus。 实现思路大都类似。这里我们先用官方提供的mongo-csharp-driver ,当前版本为1.4.1 下载地址：http://github.com/mongodb/mongo-csharp-driver/downloads 编译之后得到两个dl...
MongoDBHelper
wangnaisheng的专栏
04-13 801
c#驱动操作mongodb辅助类MongoDBHelper
C# MongoDB操作类
热门推荐
Curtain的博客
10-19 1万+
using Entity.MongoDBHelper; using MongoDB.Bson; using MongoDB.Driver; using System; using System.Collections.Generic; using System.Threading.Tasks; using DAL.Interface; namespace DAL.Implments { ...
C# mongodb数据库操作类 MongoDBHelper
weixin_34400525的博客
02-22 761
2019独角兽企业重金招聘Python工程师标准>>> ...
C#操作MongoDB数据库的dll驱动指南
开发者使用这个DLL文件，可以通过C#代码构建对MongoDB数据库的连接，并通过这个连接进行各种数据库操作。 在使用MongoDB.dll之前，需要在C#项目中安装MongoDB的官方驱动。这通常可以通过NuGet包管理器来完成。在...
C#操作MongoDB数据库实例教程
该驱动程序允许开发人员使用C#语言连接到MongoDB数据库，并执行数据的增删改查操作。本文将详细介绍如何在C#项目中实现与MongoDB数据库的底层连接以及如何进行基本操作。 首先，要连接到MongoDB数据库，需要在C#...
C#操作MongoDB数据库所需DLL文件介绍
MongoDB为C#语言提供了官方的驱动程序，让C#开发者能够以一种熟悉的方式与MongoDB数据库进行交互。根据提供的文件信息，以下是对MongoDB C#驱动dll相关知识点的详细介绍。 ### MongoDB C# 驱动概述 MongoDB C# ...
.net平台（C#）MongoDB最新版操作类
06-12
.net平台（C#）MongoDB最新版操作类 MongoDB操作类源码包括添加、修改、删除和查询（包括分页）等同步及异步操作类完整的代码。 本项目是以最新版的MVC结合MongoDB呈现，对MongoDB有兴趣的朋友很有参考价值。 可以直接拿到自己的项目直接开发，可以少走弯路。
C#操作mongodb
03-15
自己做的成C# 操作mongodb 数据库的demo,正式项目中已经使用，放心下载，可完整运行
C#连接MongoDB数据库.docx
03-02
本文将详细介绍如何在C#环境中连接和操作MongoDB数据库。 首先，你需要从MongoDB的官方网站（https://www.mongodb.com/download-center#community）下载社区版的安装包。安装过程中，可以选择自定义路径，但要注意...
C#操作MongoDB数据库的最新驱动程序
这一驱动为C#应用程序与MongoDB数据库之间的交互提供了便捷的API。 ### MongoDB Driver的核心概念 MongoDB Driver是MongoDB官方提供的.NET客户端库，它是用来与MongoDB数据库进行通信的桥梁。它支持.NET Standard ...
C# 操作mongodb
five_s的博客
12-04 1050
目录前言下载mongodb C#版驱动实现代码连接MongoDB条件查询功能1. 等于 条件查询2. 小于/大于/小于等于/大于等于 条件查询3. 包含(in) 条件查询4. 模糊匹配(like) 条件查询5. 多条件混合查询MongoDBHelper 前言 简单介绍一下C#如何操作mongodb数据库，同时穿插一些简单的mongodb的语法 下载mongodb C#版驱动 利用Nuget包下载 MongoDB.Driver 实现代码 连接MongoDB // 定义客户端 public
C# 操作mongoDB
Major_S的博客
01-09 1188
【代码】C# 操作mongoDB。
MongoDb在C#中使用
lnc2003的专栏
12-22 597
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Runtime.Serialization; using System.Data; using System.Data.SqlClient; using MongoDB.Bson; using Mong
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值