.NET Core中基于MongoDB的JSON:API后端服务实现方案咨询

Great question! Since you're already working with a generic MongoDB CRUD service and want to implement a JSON:API compliant backend in .NET Core without DbContext, here are a few solid approaches to consider:

1. 扩展JsonApiDotNetCore以支持MongoDB #

While JsonApiDotNetCore doesn't have official MongoDB support, it's designed to be highly extensible—its core relies on the IResourceRepository interface to abstract data access. You can implement this interface on top of your existing generic MongoDB service to hook into JsonApiDotNetCore's JSON:API handling logic:

• Create a MongoResourceRepository<T> class that implements the IResourceRepository<T> interface
• Inject your generic MongoDB CRUD service into this class, then handle JSON:API-specific operations like filtering, sorting, pagination, and included relationships
• Use MongoDB.Driver's LINQ capabilities to convert JsonApiDotNetCore's parsed query parameters (like FilterQuery or SortQuery) into valid MongoDB queries
• Register your custom repository in the DI container to replace the default EF Core-backed implementation

This approach lets you reuse JsonApiDotNetCore's mature features for request/response parsing, validation, and link generation, so you don't have to build the entire JSON:API spec from scratch.

2. Manually Combine MongoDB.Driver with JSON:API Spec #

If you'd rather avoid relying on JsonApiDotNetCore, you can build on your existing CRUD service by manually handling JSON:API request and response formatting:

• In your API controllers, parse JSON:API query parameters (include, filter, sort, page, etc.)
• Convert these parameters into MongoDB-compatible operations: use Builders<T>.Filter for filtering, SortDefinition<T> for sorting, and Skip()/Limit() for pagination
• Call your generic MongoDB service to execute the query, then map the returned entities to JSON:API-compliant response structures:
  • Wrap resource data in a data field
  • Handle included relationships (if the include parameter is present) by adding related resources to an included array
  • Generate required links (self-links, pagination links, etc.)

Here's a simplified code snippet to illustrate this:

[HttpGet]
public IActionResult Get([FromQuery] JsonApiQueryParams queryParams)
{
    // Parse filter parameter into MongoDB filter
    var filter = BuildMongoFilter(queryParams.Filter);
    // Parse sort parameter into MongoDB sort definition
    var sort = BuildMongoSort(queryParams.Sort);
    // Handle pagination values
    var pageSize = queryParams.Page?.Size ?? 20;
    var pageNumber = queryParams.Page?.Number ?? 1;

    var entities = _genericMongoService.Get(filter, sort, pageSize, pageNumber);
    var jsonApiResources = entities.Select(MapEntityToJsonApiResource);
    
    var response = new JsonApiResponse
    {
        Data = jsonApiResources,
        Links = GeneratePaginationLinks(pageNumber, pageSize, _genericMongoService.Count(filter))
    };

    return Ok(response);
}

3. Use Community-Maintained MongoDB Adapters #

Check for third-party NuGet packages maintained by the community that add MongoDB support to JsonApiDotNetCore. These packages typically implement the IResourceRepository interface for MongoDB out of the box, letting you quickly integrate with your existing service without writing all the boilerplate yourself.

• First, make sure you understand the core JSON:API spec (resource structures, relationships, query parameter rules)—this is foundational to any implementation
• Leverage MongoDB.Driver's strongly-typed LINQ queries to keep parameter conversion safe and maintainable
• Encapsulate entity-to-JSON:API resource mapping logic (consider using tools like AutoMapper to reduce repetitive code)
• Standardize error responses to match JSON:API's error format requirements, ensuring consistency across your endpoints

内容的提问来源于stack exchange，提问作者leo