.net core操作MongoDB

前言

现实中认识的一个搞java(百万富婆)的大佬,已经转行做抖音主播了,搞技术的只能赶在年前再水一篇博客,不足之处欢迎拍砖,以免误人子弟,呔,真是太难受了

环境准备

• .net core 3.1
• MongoDB
• Navicat Premium 16

创建项目

1.选择ASP.NET Core Web API 项目模板

2.配置项目信息 项目名称,项目路径

3.配置项目其它信息,这里选择使用.net core 3.1 不配置https

添加依赖

1.获取MongoDB.Driver包 版本 2.18.0

方案A. install-package MongoDB.Driver 方案B. nuget包管理工具搜索 MongoDB.Driver 方案C. 选中项目,双击,添加 <ItemGroup>     <PackageReference Include="MongoDB.Driver" Version="2.18.0" /> </ItemGroup> 

注册中间件

1.添加配置文件

"MongoDB": { "ConnName": "mongodb://root:123456@127.0.0.1:27017/", "DatabaseName": "test" } 

2.添加配置类

public class MongoDBConfig {     /// <summary>     /// 连接字符串     /// </summary>     public string ConnName { get; set; }      /// <summary>     /// 数据库名称     /// </summary>     public string DatabaseName { get; set; } } 

3.注册配置文件与中间件

//读取配置文件 var mongoDBOptions = Configuration.GetSection("MongoDB").Get<MongoDBConfig>();  //注册配置 services.Configure<MongoDBConfig>(this.Configuration.GetSection("MongoDB"));  //注册中间件 services.AddSingleton(new MongoClient(mongoDBOptions.ConnName)); 

其实就是注册了一个mongodb的客户端实例,然后用这个客户端实例来实现crud,如果你想优雅点(强迫症),也可以自定义一个拓展,来注册这个实例,这是一个通用技巧,后面使用到的类请自行注册

public static class MongoDBExtensions  {     public static void AddMongoDB(this IServiceCollection services, Action<MongoDBConfig> setupAction)     {         if (setupAction == null)         {             throw new ArgumentNullException(nameof(setupAction));         }         var options = new MongoDBConfig();         setupAction(options);         services.Configure(setupAction);         services.AddSingleton(services.AddSingleton(new MongoClient(options.ConnName)));     } } 

使用拓展,来注册中间件

var mongoDBOptions = Configuration.GetSection("MongoDB").Get<MongoDBConfig>(); services.AddMongoDB(m =>  {     m.ConnName = mongoDBOptions.ConnName;     m.DatabaseName = mongoDBOptions.DatabaseName; }); 

封装基础操作

最常用的办法,就是弄个DBHelper类,这种简单粗暴的方式,在.net core里使用并不优雅(网上教程太多了,不想重复的水),这里模拟常规的仓储模式,进行演示

1.创建 Service,Repertoty,Model 文件夹
2.创建 BaseDbContext 类

public class BaseDbContext {     private readonly IMongoDatabase _database;     public BaseDbContext(MongoClient client, IOptions<MongoDBConfig> options)     {         //决定使用哪个库         _database = client.GetDatabase(options.Value.DatabaseName);     }      /// <summary>     /// 数据库对象     /// </summary>     public IMongoDatabase MongoDatabase { get{ return _database; } } } 

如果项目只操作一个数据库,直接在基类里指定操作的数据库即可,如果需要操作多个数据库,可以再新建一个子类(TestDbContext),在子类里指定要操作的数据库
前面我已经注册了mongodb的客户端跟配置文件,所以在Startup类下,可以直接注册这个类,容器会自动管理这些依赖

services.AddSingleton(typeof(BaseDbContext)); 

如果你想更优雅点(强迫症),可以创建一个IBaseDbContext 接口,在接口里定义相关的规范

services.AddSingleton<IBaseDbContext>(); 

3.创建 BaseRepertoty 类

public class BaseRepertoty<T> where T : class, new() {     private readonly IMongoDatabase _database;      private readonly string _collName;      public BaseRepertoty(BaseDbContext baseDbContext)      {         _database = baseDbContext.MongoDatabase;         _collName = typeof(T).GetAttributeValue((TableAttribute m) => m.Name);         _collName = _collName ?? typeof(T).Name;      } } 

前面我们已经注册了BaseDbContext,它的主要作用是确定操作的库,那BaseRepertoty就是对具体集合(表)的操作,这里使用泛型,避免重复的CRUD操作
我新建了一个拓展,用于获取实体类上真实集合(表)的名称,如果用户没有指定,则取实体类的类名,做为集合(表)的名称

public static class AttributeExtensions {     public static TValue GetAttributeValue<TAttribute, TValue>(         this Type type,         Func<TAttribute, TValue> valueSelector)         where TAttribute : Attribute     {         var att = type.GetCustomAttributes(             typeof(TAttribute), true         ).FirstOrDefault() as TAttribute;         if (att != null)         {             return valueSelector(att);         }         return default(TValue);     } } 

4.创建 UserInfoRepertoty 类

public class UserInfoRepertoty : BaseRepertoty<UserInfo> {     public UserInfoRepertoty(BaseDbContext baseDbContext) : base(baseDbContext)      {      } } 

它的作用是指定操作具体的集合(表),这个类是非必须的,它只是指定了泛型的具体类型,也可以在server层调用的时候指定

5.创建 UserInfo 实体类

[Table("UserInfo")] public class UserInfo {     /// <summary>     /// 主键     /// </summary>     [BsonId]     public ObjectId Id { get; set; }      /// <summary>     /// 用户名     /// </summary>     public string Name { get; set; }      /// <summary>     /// 年龄     /// </summary>     public int Age { get; set; }      /// <summary>     /// 创建时间     /// </summary>     [BsonDateTimeOptions(Kind = DateTimeKind.Local)]     public DateTime CreateTime { get; set; }      /// <summary>     /// 合作伙伴     /// </summary>     public List<Partner> PartnerList { get; set; }      /// <summary>     /// 其它信息     /// </summary>     public Info Info { get; set; } }    public class Partner {     /// <summary>     /// 伙伴名称     /// </summary>     public string Name { get; set; }      /// <summary>     /// 合作状态     /// </summary>     public int? Status { get; set; } }   public class Info  {     /// <summary>     /// 身份编码     /// </summary>     public string Code { get; set; }      /// <summary>     /// 图片     /// </summary>     public string Pic { get; set; } } 

mongodb里默认的主键是_id,它会自动生成,类型为ObjectId,强烈推荐使用自动生成,速度快,且能提供获取对应的时间戳的方法

ObjectId 类似唯一主键，可以很快的去生成和排序，包含 12 bytes，含义是： 前4个字节表示创建 unix 时间戳,格林尼治时间 UTC 时间，比北京时间晚了 8 个小时 接下来的3个字节是机器标识码 紧接的两个字节由进程 id 组成 PID 最后三个字节是随机数 

时间类型要做对应的处理,标记为当前时间

其它常用注解说明

BsonId修饰的字段对应BsonDocument中的_id; BsonDefaultValue(value)用于指定默认值; BsonIgnore表示不映射，即使BsonDocument中包含该字段也不会赋值给属性; BsonExtraElements修饰的字段用于存储没有映射到类中的其他属性; BsonElement可以指定修饰的属性映射到BsonDocument中的哪个字段; 

使用mongodb的一个主要原因,就是它灵活的存储方式,类json,我们就来体验一番,基于这个模型来进行CRUD,我定义的类型如下,基本上能覆盖99%的使用场景

ObjectId (主键)
string (字符串)
int (数字)
object (对象)
array (数组)

我们在BaseRepertoty类里,实现CRUD,完整代码如下

public class BaseRepertoty<T> where T : class, new() {     private readonly IMongoDatabase _database;      private readonly string _collName;      public BaseRepertoty(BaseDbContext baseDbContext)      {         _database = baseDbContext.MongoDatabase;         _collName = typeof(T).GetAttributeValue((TableAttribute m) => m.Name);         _collName = _collName ?? typeof(T).Name;      }        #region Add 添加一条数据     /// <summary>     /// 添加一条数据     /// </summary>     /// <param name="t">添加的实体</param>     /// <returns></returns>     public bool Add(T t)     {         try         {             var client = _database.GetCollection<T>(_collName);             client.InsertOne(t);             return true;         }         catch (Exception ex)         {             return false;         }     }     #endregion      #region AddAsync 异步添加一条数据     /// <summary>     /// 异步添加一条数据     /// </summary>     /// <param name="t">添加的实体</param>     /// <returns></returns>     public async Task<bool> AddAsync(T t)     {         try         {             var client = _database.GetCollection<T>(_collName);             await client.InsertOneAsync(t);             return true;         }         catch         {             return false;         }     }     #endregion      #region InsertMany 批量插入     /// <summary>     /// 批量插入     /// </summary>     /// <param name="t">实体集合</param>     /// <returns></returns>     public bool InsertMany(List<T> t)     {         try         {             var client = _database.GetCollection<T>(_collName);             client.InsertMany(t);             return true;         }         catch (Exception ex)         {             return false;         }     }     #endregion      #region InsertManyAsync 异步批量插入     /// <summary>     /// 异步批量插入     /// </summary>     /// <param name="t">实体集合</param>     /// <returns></returns>     public async Task<bool> InsertManyAsync(List<T> t)     {         try         {             var client = _database.GetCollection<T>(_collName);             await client.InsertManyAsync(t);             return true;         }         catch         {             return false;         }     }     #endregion      #region UpdateOne 修改数据(单条)     /// <summary>     /// 批量修改数据     /// </summary>     /// <param name="update">要修改的字段</param>     /// <param name="filter">修改条件</param>     /// <returns></returns>     public UpdateResult UpdateOne(UpdateDefinition<T> update, FilterDefinition<T> filter)     {         try         {             var client = _database.GetCollection<T>(_collName);             return client.UpdateOne(filter, update);         }         catch (Exception ex)         {             throw ex;         }     }     #endregion      #region UpdateOneAsync 异步批量修改数据     /// <summary>     /// 异步批量修改数据     /// </summary>     /// <param name="update">要修改的字段</param>     /// <param name="filter">修改条件</param>     /// <returns></returns>     public async Task<UpdateResult> UpdateOneAsync(UpdateDefinition<T> update, FilterDefinition<T> filter)     {         try         {             var client = _database.GetCollection<T>(_collName);             return await client.UpdateOneAsync(filter, update);         }         catch (Exception ex)         {             throw ex;         }     }     #endregion      #region UpdateManay 批量修改数据     /// <summary>     /// 批量修改数据     /// </summary>     /// <param name="update">要修改的字段</param>     /// <param name="filter">修改条件</param>     /// <returns></returns>     public UpdateResult UpdateManay(UpdateDefinition<T> update, FilterDefinition<T> filter)     {         try         {             var client = _database.GetCollection<T>(_collName);             return  client.UpdateMany(filter, update);         }         catch (Exception ex)         {             throw ex;         }     }     #endregion      #region UpdateManayAsync 异步批量修改数据     /// <summary>     /// 异步批量修改数据     /// </summary>     /// <param name="update">要修改的字段</param>     /// <param name="filter">修改条件</param>     /// <returns></returns>     public async Task<UpdateResult> UpdateManayAsync(UpdateDefinition<T> update, FilterDefinition<T> filter)     {         try         {             var client = _database.GetCollection<T>(_collName);             return await client.UpdateManyAsync(filter, update);         }         catch (Exception ex)         {             throw ex;         }     }     #endregion        #region DeleteOne 删除一条数据     /// <summary>     /// 删除多条数据     /// </summary>     /// <param name="filter">删除的条件</param>     /// <returns></returns>     public DeleteResult DeleteOne(FilterDefinition<T> filter)     {         try         {             var client = _database.GetCollection<T>(_collName);             return client.DeleteOne(filter);         }         catch (Exception ex)         {             throw ex;         }      }     #endregion      #region DeleteOneAsync 异步删除一条数据     /// <summary>     /// 异步删除多条数据     /// </summary>     /// <param name="filter">删除的条件</param>     /// <returns></returns>     public async Task<DeleteResult> DeleteOneAsync(FilterDefinition<T> filter)     {         try         {             var client = _database.GetCollection<T>(_collName);             return await client.DeleteOneAsync(filter);         }         catch (Exception ex)         {             throw ex;         }      }     #endregion      #region DeleteMany 删除多条数据     /// <summary>     /// 删除多条数据     /// </summary>     /// <param name="filter">删除的条件</param>     /// <returns></returns>     public DeleteResult DeleteMany(FilterDefinition<T> filter)     {         try         {             var client = _database.GetCollection<T>(_collName);             return client.DeleteMany(filter);         }         catch (Exception ex)         {             throw ex;         }      }     #endregion      #region DeleteManyAsync 异步删除多条数据     /// <summary>     /// 异步删除多条数据     /// </summary>     /// <param name="filter">删除的条件</param>     /// <returns></returns>     public async Task<DeleteResult> DeleteManyAsync(FilterDefinition<T> filter)     {         try         {             var client = _database.GetCollection<T>(_collName);             return await client.DeleteManyAsync(filter);         }         catch (Exception ex)         {             throw ex;         }      }     #endregion      #region FindOne 根据id查询一条数据     /// <summary>     /// 根据id查询一条数据     /// </summary>     /// <param name="id">objectid</param>     /// <param name="field">要查询的字段，不写时查询全部</param>     /// <returns></returns>     public T FindOne(string id, bool isObjectId = true, string[] field = null)     {         try         {             var client = _database.GetCollection<T>(_collName);             FilterDefinition<T> filter;             if (isObjectId)             {                 filter = Builders<T>.Filter.Eq("_id", new ObjectId(id));             }             else             {                 filter = Builders<T>.Filter.Eq("_id", id);             }             //不指定查询字段             if (field == null || field.Length == 0)             {                 return client.Find(filter).FirstOrDefault<T>();             }              //制定查询字段             var fieldList = new List<ProjectionDefinition<T>>();             for (int i = 0; i < field.Length; i++)             {                 fieldList.Add(Builders<T>.Projection.Include(field[i].ToString()));             }             var projection = Builders<T>.Projection.Combine(fieldList);             fieldList?.Clear();             return client.Find(filter).Project<T>(projection).FirstOrDefault<T>();         }         catch (Exception ex)         {             throw ex;         }     }     #endregion      #region FindOneAsync 异步根据id查询一条数据     /// <summary>     /// 异步根据id查询一条数据     /// </summary>     /// <param name="id">objectid</param>     /// <returns></returns>     public async Task<T> FindOneAsync(string id, bool isObjectId = true, string[] field = null)     {         try         {             var client = _database.GetCollection<T>(_collName);             FilterDefinition<T> filter;             if (isObjectId)             {                 filter = Builders<T>.Filter.Eq("_id", new ObjectId(id));             }             else             {                 filter = Builders<T>.Filter.Eq("_id", id);             }              //不指定查询字段             if (field == null || field.Length == 0)             {                 return await client.Find(filter).FirstOrDefaultAsync();             }              //制定查询字段             var fieldList = new List<ProjectionDefinition<T>>();             for (int i = 0; i < field.Length; i++)             {                 fieldList.Add(Builders<T>.Projection.Include(field[i].ToString()));             }             var projection = Builders<T>.Projection.Combine(fieldList);             fieldList?.Clear();             return await client.Find(filter).Project<T>(projection).FirstOrDefaultAsync();         }         catch (Exception ex)         {             throw ex;         }     }     #endregion      #region FindList 查询集合     /// <summary>     /// 查询集合     /// </summary>     /// <param name="filter">查询条件</param>     /// <param name="field">要查询的字段,不写时查询全部</param>     /// <param name="sort">要排序的字段</param>     /// <returns></returns>     public List<T> FindList(FilterDefinition<T> filter, string[] field = null, SortDefinition<T> sort = null)     {         try         {             var client = _database.GetCollection<T>(_collName);             //不指定查询字段             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<ProjectionDefinition<T>>();             for (int i = 0; i < field.Length; i++)             {                 fieldList.Add(Builders<T>.Projection.Include(field[i].ToString()));             }             var projection = Builders<T>.Projection.Combine(fieldList);             fieldList?.Clear();             if (sort == null) return client.Find(filter).Project<T>(projection).ToList();             //排序查询             return client.Find(filter).Sort(sort).Project<T>(projection).ToList();         }         catch (Exception ex)         {             throw ex;         }     }     #endregion      #region FindListAsync 异步查询集合     /// <summary>     /// 异步查询集合     /// </summary>     /// <param name="filter">查询条件</param>     /// <param name="field">要查询的字段,不写时查询全部</param>     /// <param name="sort">要排序的字段</param>     /// <returns></returns>     public async Task<List<T>> FindListAsync(FilterDefinition<T> filter, string[] field = null, SortDefinition<T> sort = null)     {         try         {             var client = _database.GetCollection<T>(_collName);             //不指定查询字段             if (field == null || field.Length == 0)             {                 //return await client.Find(new BsonDocument()).ToListAsync();                 if (sort == null) return await client.Find(filter).ToListAsync();                 return await client.Find(filter).Sort(sort).ToListAsync();             }              //制定查询字段             var fieldList = new List<ProjectionDefinition<T>>();             for (int i = 0; i < field.Length; i++)             {                 fieldList.Add(Builders<T>.Projection.Include(field[i].ToString()));             }             var projection = Builders<T>.Projection.Combine(fieldList);             fieldList?.Clear();             if (sort == null) return await client.Find(filter).Project<T>(projection).ToListAsync();             //排序查询             return await client.Find(filter).Sort(sort).Project<T>(projection).ToListAsync();         }         catch (Exception ex)         {             throw ex;         }     }     #endregion      #region FindListByPage 分页查询集合     /// <summary>     /// 分页查询集合     /// </summary>     /// <param name="filter">查询条件</param>     /// <param name="pageIndex">当前页</param>     /// <param name="pageSize">页容量</param>     /// <param name="count">总条数</param>     /// <param name="field">要查询的字段,不写时查询全部</param>     /// <param name="sort">要排序的字段</param>     /// <returns></returns>     public List<T> FindListByPage(FilterDefinition<T> filter, int pageIndex, int pageSize, out long count, string[] field = null, SortDefinition<T> sort = null)     {         try         {             var client = _database.GetCollection<T>(_collName);             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<ProjectionDefinition<T>>();             for (int i = 0; i < field.Length; i++)             {                 fieldList.Add(Builders<T>.Projection.Include(field[i].ToString()));             }             var projection = Builders<T>.Projection.Combine(fieldList);             fieldList?.Clear();              //不排序             if (sort == null) return client.Find(filter).Project<T>(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();              //排序查询             return client.Find(filter).Sort(sort).Project<T>(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();          }         catch (Exception ex)         {             throw ex;         }     }     #endregion      #region FindListByPageAsync 异步分页查询集合     /// <summary>     /// 异步分页查询集合     /// </summary>     /// <param name="filter">查询条件</param>     /// <param name="pageIndex">当前页</param>     /// <param name="pageSize">页容量</param>     /// <param name="field">要查询的字段,不写时查询全部</param>     /// <param name="sort">要排序的字段</param>     /// <returns></returns>     public async Task<List<T>> FindListByPageAsync(FilterDefinition<T> filter, int pageIndex, int pageSize, string[] field = null, SortDefinition<T> sort = null)     {         try         {             var client = _database.GetCollection<T>(_collName);             //不指定查询字段             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<ProjectionDefinition<T>>();             for (int i = 0; i < field.Length; i++)             {                 fieldList.Add(Builders<T>.Projection.Include(field[i].ToString()));             }             var projection = Builders<T>.Projection.Combine(fieldList);             fieldList?.Clear();              //不排序             if (sort == null) return await client.Find(filter).Project<T>(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync();              //排序查询             return await client.Find(filter).Sort(sort).Project<T>(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync();          }         catch (Exception ex)         {             throw ex;         }     }     #endregion       #region Count 根据条件获取总数     /// <summary>     /// 根据条件获取总数     /// </summary>     /// <param name="filter">条件</param>     /// <returns></returns>     public long Count(FilterDefinition<T> filter)     {         try         {             var client = _database.GetCollection<T>(_collName);             return client.CountDocuments(filter);         }         catch (Exception ex)         {             throw ex;         }     }     #endregion      #region CountAsync 异步根据条件获取总数     /// <summary>     /// 异步根据条件获取总数     /// </summary>     /// <param name="filter">条件</param>     /// <returns></returns>     public async Task<long> CountAsync(FilterDefinition<T> filter)     {         try         {             var client = _database.GetCollection<T>(_collName);             return await client.CountDocumentsAsync(filter);         }         catch (Exception ex)         {             throw ex;         }     }     #endregion } 

6.创建 UserInfoService 类

public class UserInfoService {     private readonly UserInfoRepertoty _userInfoRepertoty;      private readonly FilterDefinitionBuilder<UserInfo> _buildFilter;     public UserInfoService(UserInfoRepertoty userInfoRepertoty)      {         _userInfoRepertoty = userInfoRepertoty;         _buildFilter = Builders<UserInfo>.Filter;     } } 

体验mongodb独特的使用方式,这里挑出两个具有代表性的操作进行讲解,测试数据

分页查询集合(表)

• 1.动态条件查询
• 2.查询文档指定字段
• 3.排序
• 4.分页

定义查询操作

FilterDefinition<UserInfo> filter = _buildFilter.Empty; 

查询条件由查询条件构造器构建,这个地方网上很多示例写的有bug,当查询所有集合(表)数据的时候,filter = null 在转换的时候会抛出异常

//创建查询条件构造器 FilterDefinitionBuilder<UserInfo> _buildFilter = Builders<UserInfo>.Filter; //定义查询条件 FilterDefinition<UserInfo> filter = null; if(!string.IsNullOrEmpty(request.Name)) filter = _buildFilter.Eq(m => m.Name, request.Name); 

这里有很多种类型的构造器,对应不同的操作

//排序操作 SortDefinition<UserInfo> sort //排序构造器 Builders<UserInfo>.Sort  修改操作 UpdateDefinition<UserInfo> update //修改构造器 Builders<UserInfo>.Update  

完整的查询示例,比较麻烦的地方,是针对数组的条件查询,如果嵌套的层数比较多,查询也是同理的套娃查询

public class GetUserListRequest {     /// <summary>     /// 名称     /// </summary>     public string Name { get; set; }      /// <summary>     /// 年龄     /// </summary>     public int? Age { get; set; }       /// <summary>     /// 创建时间     /// </summary>     public DateTime CreateTime { get; set; }      /// <summary>     /// 合作伙伴     /// </summary>     public Partner PartnerList { get; set; }      /// <summary>     /// 信息     /// </summary>     public Info Info { get; set; } }  public async Task<List<UserInfo>> GetUserPageList(GetUserListRequest request) {     if (request == null) return new List<UserInfo>();     FilterDefinition<UserInfo> filter = _buildFilter.Empty;      SortDefinition<UserInfo> sort = Builders<UserInfo>.Sort.Ascending(m => m.Age);      if (!string.IsNullOrEmpty(request.Name))     {         filter = _buildFilter.Eq(m => m.Name, request.Name);     }     if (request.Age.HasValue)     {         filter = _buildFilter.Eq(m => m.Age, request.Age);     }     if (request.PartnerList != null)     {         if (request.PartnerList.Status.HasValue)         {             filter = _buildFilter.ElemMatch("PartnerList", Builders<Partner>.Filter.Eq(m => m.Status, request.PartnerList.Status));         }     }     if (request.Info != null)     {         if (!string.IsNullOrEmpty(request.Info.Code))         {             filter = _buildFilter.Eq(m => m.Info.Code, request.Info.Code);         }     }     var list = await _userInfoRepertoty.FindListByPageAsync(filter,1,3, new string[] { "Name","Age", "CreateTime" }, sort);     return list; } 

动态条件查询(查询全部)

var list = await _userInfoRepertoty.FindListByPageAsync(filter, 1, 30); 

条件查询,排序,分页,查询指定字段

var list = await _userInfoRepertoty.FindListByPageAsync(filter,1,3, new string[] { "Name","Age", "CreateTime" }, sort); 

除了使用对象模型进行操作,也可以直接使用mongodb原生的BsonDocument进行操作

var buildFilter = Builders<BsonDocument>.Filter; FilterDefinition<BsonDocument> filter = _buildFilter.Empty;; BsonDocument bson = new BsonDocument {     { "Age",20},     {"Info.Status",3 } };  foreach (var bs in bson) {     filter = _buildFilter.Eq(bs.Name, bs.Value);  } var sort = Builders<BsonDocument>.Sort; var list = await collection.Find(filter).Sort(sort.Descending("age")).ToListAsync(); 

修改集合(表)的数据

• 1.修改满足条件的文档
• 2.修改文档的部分字段

public async Task UpdateUserInfo() {     //修改条件     FilterDefinition<UserInfo> filter = _buildFilter.Empty;     filter = _buildFilter.Eq(m => m.Name, "tibos");     filter = _buildFilter.ElemMatch(list => list.PartnerList, child => child.Status == 1);       //修改字段     var update = Builders<UserInfo>.Update.Set("Age",100).Set("PartnerList.$.Name", "ppp").Set("PartnerList.$.Status", "");     await _userInfoRepertoty.UpdateManayAsync(update, filter); }