学习如何在ASP.NET Core中集成MongoDB。

WebAPI项目示例

创建WebAPI

建立一个Net6-with-MongoDB.Demo的WebAPI项目。
通过NuGet安装MongoDB.Driver：

  1. Install-Package MongoDB.Driver
  2. Install-Package AutoMapper
  3. Install-Package AutoMapper.Extensions.Microsoft.DependencyInjection

一般来说，我们操作MongoDB都会选择这个官方的Driver。

配置MongoDB

首先，请参照之前的文章安装部署好一个MongoDB节点或集群。
然后，手动创建一个数据库BookStoreDB 和 一个集合 Books。

  1. use BookStoreDB
  2. db.CreateCollection('Books')

或者打开Mongo Express,http://localhost:8081/
1664005531942.png
1664005561959.png
最后，预先插入两条测试数据：

  1. db.Books.insertMany([
  2. {'Name':'Design Patterns','Price':54.93,
  3. 'Category':'Computers','Author':'Ralph Johnson', 
  4. 'CreatedDate':ISODate("2012-10-02T07:58:51Z"),
  5. 'UpdatedDate':ISODate("2012-10-02T07:58:51Z")}, 
  6. {'Name':'Clean Code','Price':43.15,
  7. 'Category':'Computers','Author':'Robert C. Martin',
  8. 'CreatedDate':ISODate("2012-10-02T07:58:51Z"),
  9. 'UpdatedDate':ISODate("2012-10-02T07:58:51Z")}])

需要注意的是：这里的连接字符串指向的是一个没有设置用户名密码的MongoDB节点。如果你的MongoDB节点设置了用户名密码 或者 复制集分片集 之类的，请修改为匹配的连接字符串。
然后，创建一个配置项类，也放到Models目录中：

  1. namespace Net6.with.MongoDB.Demo.Models;
  3. public class DatabaseSettings : IDatabaseSettings
  4. {
  5.     public string BooksCollectionName { get; set; }
  6.     public string ConnectionString { get; set; }
  7.     public string DatabaseName { get; set; }
  8. }
  10. public interface IDatabaseSettings
  11. {
  12.     string BooksCollectionName { get; set; }
  13.     string ConnectionString { get; set; }
  14.     string DatabaseName { get; set; }
  15. }

最后，将其加入到IoC容器中控制：

  2. using Microsoft.Extensions.Options;
  3. using Net6.with.MongoDB.Demo.Models;
  4. using Net6.with.MongoDB.Demo.Services;
  6. var builder = WebApplication.CreateBuilder(args);
  8. // AutoMapper Settings
  9. builder.Services.AddAutoMapper(typeof(MappingConfigs));
  11. var appSetting = new AppSetting();
  12. builder.Configuration.GetSection("AppSetting").Bind(appSetting);
  14. //把AppSetting实体注入到容器,方便在构造函数里使用IOptionsSnapshot<AppSetting> options
  15. builder.Services.Configure<AppSetting>(builder.Configuration.GetSection("AppSetting"));
  17. // MongoDB Settings
  18. builder.Services.Configure<AppSetting>(
  19.     builder.Configuration.GetSection(nameof(AppSetting)));
  20. builder.Services.AddSingleton<IAppSetting>(sp =>
  21.     sp.GetRequiredService<IOptions<AppSetting>>().Value);
  23. // Add services to the container.
  24. builder.Services.AddSingleton<IBookService, BookService>();
  26. builder.Services.AddControllers();
  27. builder.Services.AddEndpointsApiExplorer();
  28. builder.Services.AddSwaggerGen();
  30. var app = builder.Build();
  32. // Configure the HTTP request pipeline.
  33. app.UseSwagger();
  34. app.UseSwaggerUI();
  36. app.UseHttpsRedirection();
  38. app.UseAuthorization();
  40. app.MapControllers();
  42. app.Run();

这里，IBookstoreDatabaseSettings 接口使用单一实例服务生存期在 DI 中注册。在注入时，接口实例时将解析为 BookStoreDatabaseSettings 对象。

添加配置模型

首先，在appSettings.json中添加以下数据库配置：

  1. {
  2.   "Logging": {
  3.     "LogLevel": {
  4.       "Default": "Information",
  5.       "Microsoft.AspNetCore": "Warning"
  6.     }
  7.   },
  8.   "AllowedHosts": "*",
  9.   "AppSetting": {
  10.     "SqlServerSetting": {
  11.       "Connection": "Server=192.168.3.40;Database=webdemo;User=sa;Password=longfuchu;"
  12.     },
  13.     "MysqlSetting": {
  14.       "Connection": "server=192.168.3.40;port=3306;user=root;password=123456;database=webdemo;charset=utf8;Allow Zero Datetime=true;sslmode=none;Old Guids=true;Allow User Variables=True"
  15.     },
  16.     "RedisSetting": {
  17.       "Connection": "192.168.3.40:6379,password=",
  18.       "Database": "test"
  19.     },
  20.     "RabbitMQSetting": {
  21.       "HostName": "localhost",
  22.       "UserName": "admin",
  23.       "Password": "admin",
  24.       "Port": 5672
  25.     },
  26.     "MongoDbSetting": {
  27.       "Connection": "mongodb://192.168.3.40:2717", ///?replicaSet=rs0
  28.       "Database": "BookStoreDB",
  29.       "CollectionName": "Books"
  30.     }
  31.   }
  32. }
  1. namespace Net6.with.MongoDB.Demo.Models;
  4. /// <summary>
  5. /// mongodb setting
  6. /// </summary>
  7. public interface IAppSetting
  8. {
  9.     /// <summary>
  10.     /// SqlServerSetting
  11.     /// </summary>
  12.      SqlServerSetting SqlServerSetting { get; set; }
  13.     /// <summary>
  14.     /// MysqlSetting
  15.     /// </summary>
  16.      MysqlSetting MysqlSetting { get; set; }
  17.     /// <summary>
  18.     /// RedisSetting
  19.     /// </summary>
  20.      RedisSetting RedisSetting { get; set; }
  21.     /// <summary>
  22.     /// RabbitMQSetting
  23.     /// </summary>
  24.      RabbitMQSetting RabbitMQSetting { get; set; }
  26.     /// <summary>
  27.     /// MongoDbSetting
  28.     /// </summary>
  29.      MongoDbSetting MongoDbSetting { get; set; }
  30.     /// <summary>
  31.     /// KafkaSetting
  32.     /// </summary>
  33.      KafkaSetting KafkaSetting { get; set; }
  34. }
  36. /// <summary>
  37. /// mongodb setting
  38. /// </summary>
  39. public class AppSetting: IAppSetting
  40. {
  41.     /// <summary>
  42.     /// SqlServerSetting
  43.     /// </summary>
  44.     public SqlServerSetting SqlServerSetting { get; set; }
  45.     /// <summary>
  46.     /// MysqlSetting
  47.     /// </summary>
  48.     public MysqlSetting MysqlSetting { get; set; }
  49.     /// <summary>
  50.     /// RedisSetting
  51.     /// </summary>
  52.     public RedisSetting RedisSetting { get; set; }
  53.     /// <summary>
  54.     /// RabbitMQSetting
  55.     /// </summary>
  56.     public RabbitMQSetting RabbitMQSetting { get; set; }
  58.     /// <summary>
  59.     /// MongoDbSetting
  60.     /// </summary>
  61.     public MongoDbSetting MongoDbSetting { get; set; }
  62.     /// <summary>
  63.     /// KafkaSetting
  64.     /// </summary>
  65.     public KafkaSetting KafkaSetting { get; set; }
  66. }
  67. public class RabbitMQSetting
  68. {
  69.     /// <summary>
  70.     /// HostName
  71.     /// </summary>
  72.     public string HostName { get; set; } = "localhost";
  74.     /// <summary>
  75.     /// Password
  76.     /// </summary>
  77.     public string Password { get; set; }
  79.     /// <summary>
  80.     /// Username
  81.     /// </summary>
  82.     public string UserName { get; set; }
  84.     /// <summary>
  85.     /// The port to connect on.
  86.     /// </summary>
  87.     public int Port { get; set; } = 5672;
  88. }
  89. public class RedisSetting
  90. {
  91.     /// <summary>
  92.     /// connection string
  93.     /// </summary>
  94.     public string Connection { get; set; }
  95.     /// <summary>
  96.     /// database name
  97.     /// </summary>
  98.     public string Database { get; set; }
  99. }
  100. public class MongoDbSetting
  101. {
  102.     /// <summary>
  103.     /// connection string
  104.     /// </summary>
  105.     public string Connection { get; set; }
  106.     /// <summary>
  107.     /// database name
  108.     /// </summary>
  109.     public string Database { get; set; }
  110.     /// <summary>
  111.     /// CollectionName
  112.     /// </summary>
  114.     public string CollectionName { get; set; }
  115. }
  116. public class SqlServerSetting
  117. {
  118.     /// <summary>
  119.     /// connection string
  120.     /// </summary>
  121.     public string Connection { get; set; }
  122. }
  123. public class MysqlSetting
  124. {
  125.     /// <summary>
  126.     /// connection string
  127.     /// </summary>
  128.     public string Connection { get; set; }
  129. }
  130. public class KafkaSetting
  131. {
  132.     /// <summary>
  133.     /// Servers
  134.     /// </summary>
  135.     public string Servers { get; set; }
  136. }

添加实体模型

在WebAPI项目中添加Models目录，并增加 Book 实体类：

  1. using MongoDB.Bson.Serialization.Attributes;
  2. using MongoDB.Bson;
  4. namespace Net6.with.MongoDB.Demo.Models;
  6. public class Book : MongoDocBase
  7. {
  8.     [BsonElement("Name")]
  9.     public string BookName { get; set; }
  11.     public decimal Price { get; set; }
  13.     public string Category { get; set; }
  15.     public string Author { get; set; }
  16. }
  18. public class MongoDocBase
  19. {
  20.     [BsonId]
  21.     [BsonRepresentation(BsonType.ObjectId)]
  22.     public string Id { get; set; }
  24.     [BsonDateTimeOptions(Kind = DateTimeKind.Local)]
  25.     public DateTime? CreatedDate { get; set; }
  27.     [BsonDateTimeOptions(Kind = DateTimeKind.Local)]
  28.     public DateTime? UpdatedDate { get; set; }
  29. }

需要注意的是：MongoDB存储时间类型数据时，都是先转换为UTC时间，然后存储到数据库中。当我们取出存储的时间时，就会出现时差的问题。因此，一般我们会给文档中的日期类型加上如下所示的注解，将它转换为本地时间传输：

  1. [BsonDateTimeOptions(Kind = DateTimeKind.Local)]

在实际应用中，我们会给实体类创建一些DTO，然后在应用层进行DTO向DO的转换。因此，这里我们假设会进行 创建Book 和 修改Book 的操作，创建两个DTO类：
（1）CreateBookDto

  1. using System.Text.Json.Serialization;
  3. namespace Net6.with.MongoDB.Demo.Models;
  5. public class CreateBookDto
  6. {
  7.     public string BookName { get; set; }
  9.     public decimal Price { get; set; }
  11.     public string Category { get; set; }
  13.     public string Author { get; set; }
  15.     [JsonIgnore]
  16.     public DateTime CreatedDate { get; set; } = DateTime.Now;
  17. }

（2）UpdateBookDto

  1. using System.Text.Json.Serialization;
  3. namespace Net6.with.MongoDB.Demo.Models;
  5. public class UpdateBookDto : CreateBookDto
  6. {
  7.     public string Id { get; set; }
  9.     [JsonIgnore]
  10.     public DateTime UpdatedDate { get; set; } = DateTime.Now;
  11. }

创建映射规则配置：

  1. using AutoMapper;
  3. namespace Net6.with.MongoDB.Demo.Models;
  5. public class MappingConfigs : Profile
  6. {
  7.     public MappingConfigs()
  8.     {
  9.         CreateMap<CreateBookDto, Book>().ReverseMap();
  10.         CreateMap<UpdateBookDto, Book>()
  11.             .ForMember(dest => dest.CreatedDate, opt => opt.Ignore())
  12.             .ReverseMap();
  13.     }
  14. }

添加CRUD服务

在Services目录下，创建IBookService接口：

  1. using Net6.with.MongoDB.Demo.Models;
  3. namespace Net6.with.MongoDB.Demo.Services;
  5. public interface IBookService
  6. {
  7.     IList<Book> Get();
  9.     Task<IList<Book>> GetAsync();
  11.     Book Get(string id);
  13.     Task<Book> GetAsync(string id);
  15.     Book Create(Book book);
  17.     Task<Book> CreateAsync(Book book);
  19.     void Update(string id, Book bookIn);
  21.     Task UpdateAsync(string id, Book bookIn);
  23.     void Remove(string id);
  25.     Task RemoveAsync(string id);
  26. }

然后，创建BookService 实现 IBookService 接口。

  1. using Microsoft.Extensions.Options;
  2. using MongoDB.Driver;
  3. using Net6.with.MongoDB.Demo.Models;
  5. namespace Net6.with.MongoDB.Demo.Services;
  7. public class BookService : IBookService
  8. {
  9.     private readonly IMongoCollection<Book> _books;
  11.     public BookService(IAppSetting settings)
  12.     {
  13.         var mongoClient = new MongoClient(settings.MongoDbSetting.Connection);
  14.         var mongoDatabase = mongoClient.GetDatabase(settings.MongoDbSetting.Database);
  15.         _books = mongoDatabase.GetCollection<Book>(settings.MongoDbSetting.CollectionName);
  16.     }
  18.     //错误
  19.     //public BookService(IOptionsSnapshot<AppSetting> settings)
  20.     //{
  21.     //    var mongoClient = new MongoClient(settings.Value.MongoDbSetting.Connection);
  22.     //    var mongoDatabase = mongoClient.GetDatabase(settings.Value.MongoDbSetting.Database);
  23.     //    _books = mongoDatabase.GetCollection<Book>(settings.Value.MongoDbSetting.CollectionName);
  24.     //}
  26.     public Book Create(Book book)
  27.     {
  28.         _books.InsertOne(book);
  29.         return book;
  30.     }
  32.     public async Task<Book> CreateAsync(Book book)
  33.     {
  34.         await _books.InsertOneAsync(book);
  35.         return book;
  36.     }
  38.     public IList<Book> Get()
  39.     {
  40.         return _books.Find(book => true).ToList();
  41.     }
  43.     public async Task<IList<Book>> GetAsync()
  44.     {
  45.         return await _books.Find(book => true).ToListAsync();
  46.     }
  48.     public Book Get(string id)
  49.     {
  50.         return _books.Find(book => book.Id == id).FirstOrDefault();
  51.     }
  53.     public async Task<Book> GetAsync(string id)
  54.     {
  55.         return await _books.Find(book => book.Id == id).FirstOrDefaultAsync();
  56.     }
  58.     public void Remove(string id)
  59.     {
  60.         _books.DeleteOne(book => book.Id == id);
  61.     }
  63.     public async Task RemoveAsync(string id)
  64.     {
  65.         await _books.DeleteOneAsync(book => book.Id == id);
  66.     }
  68.     public void Update(string id, Book bookIn)
  69.     {
  70.         _books.ReplaceOne(book => book.Id == id, bookIn);
  71.     }
  73.     public async Task UpdateAsync(string id, Book bookIn)
  74.     {
  75.         await _books.ReplaceOneAsync(book => book.Id == id, bookIn);
  76.     }
  77. }

在上面的代码中，会通过构造函数从DI检索IBookStoreDatabaseSettings实例获取MongoDB连接字符串、数据库名 和 集合名。
当然，我们也可以使用 约定大于配置 的方式，统一采用实体类的名字 作为默认的 集合名，示例如下：

  1. _books = mongoDatabase.GetCollection<Book>(typeof(Book).Name);

最后，将BookService也加入到IoC容器中：

  1. services.AddSingleton<IBookService, BookService>();

这里，将BookService作为单一实例注入，这是因为 BookService 直接依赖于 MongoClient，而根据官方Mongo Client重用准则，我们应该使用单一实例服务在IoC容器中注入MongoClient。

添加Controller

在Controllers目录下，新增 BookController 控制器：

  1. using AutoMapper;
  2. using Microsoft.AspNetCore.Mvc;
  3. using Net6.with.MongoDB.Demo.Models;
  4. using Net6.with.MongoDB.Demo.Services;
  6. namespace Net6.with.MongoDB.Demo.Controllers.MQ;
  8. /// <summary>
  9. /// 
  10. /// </summary>
  11. [ApiController]
  12. public class BookController : AreaController
  13. {
  14.     private readonly IMapper _mapper;
  15.     private readonly IBookService _bookService;
  17.     public BookController(IMapper mapper, IBookService bookService)
  18.     {
  19.         _mapper = mapper;
  20.         _bookService = bookService;
  21.     }
  23.     [HttpGet]
  24.     [ProducesResponseType(typeof(IList<Book>), StatusCodes.Status200OK)]
  25.     [ProducesResponseType(typeof(IList<Book>), StatusCodes.Status204NoContent)]
  26.     public async Task<ActionResult<IList<Book>>> Get()
  27.     {
  28.         var books = await _bookService.GetAsync();
  29.         if (books == null)
  30.         {
  31.             return NoContent();
  32.         }
  34.         return Ok(books);
  35.     }
  37.     [HttpGet("{id:length(24)}", Name = "GetBook")]
  38.     [ProducesResponseType(typeof(Book), StatusCodes.Status200OK)]
  39.     [ProducesResponseType(typeof(Book), StatusCodes.Status404NotFound)]
  40.     public async Task<ActionResult<Book>> Get(string id)
  41.     {
  42.         var book = await _bookService.GetAsync(id);
  43.         if (book == null)
  44.         {
  45.             return NotFound();
  46.         }
  48.         return Ok(book);
  49.     }
  51.     [HttpPost]
  52.     [ProducesResponseType(typeof(Book), StatusCodes.Status201Created)]
  53.     public async Task<ActionResult<Book>> Create(CreateBookDto bookDto)
  54.     {
  55.         var book = _mapper.Map<Book>(bookDto);
  56.         await _bookService.CreateAsync(book);
  57.         return CreatedAtRoute("GetBook", new { id = book.Id.ToString() }, bookDto);
  58.     }
  60.     [HttpPut("{id:length(24)}")]
  61.     [ProducesResponseType(StatusCodes.Status200OK)]
  62.     [ProducesResponseType(StatusCodes.Status404NotFound)]
  63.     public async Task<ActionResult> Update(string id, UpdateBookDto bookDto)
  64.     {
  65.         var book = await _bookService.GetAsync(id);
  66.         if (book == null)
  67.         {
  68.             return NotFound();
  69.         }
  71.         _mapper.Map(bookDto, book);
  73.         await _bookService.UpdateAsync(id, book);
  74.         return Ok();
  75.     }
  77.     [HttpDelete("{id:length(24)}")]
  78.     [ProducesResponseType(StatusCodes.Status200OK)]
  79.     [ProducesResponseType(StatusCodes.Status404NotFound)]
  80.     public async Task<ActionResult> Update(string id)
  81.     {
  82.         var book = await _bookService.GetAsync(id);
  83.         if (book == null)
  84.         {
  85.             return NotFound();
  86.         }
  88.         await _bookService.RemoveAsync(id);
  89.         return Ok();
  90.     }
  91. }

测试WebAPI

生成该ASP.NET Core WebAPI应用，启动之后在Swagger页面进行测试：

参考

MongoDB入门实战教程（5）
Microsoft Doc：使用ASP.NET Core和MongoDB创建WebAPI