Seit .NET 10.0 ist es möglich, die JSON-Patch-Implementierung in WebAPIs zu verwenden. Das folgende Beispiel zeigt, wie man das neue NuGet-Paket Microsoft.AspNetCore.JsonPatch.SystemTextJson in einer ASP.NET-Core-10.0-basierten WebAPI anwendet, um ein JSON-Patch-Dokument zu verarbeiten.

Die Datenklassen sind dieselben wie in dem Beispiel zum Beitrag „JSON Patch“ in dieser Blogserie: Person, Address und PhoneNumber.

Die WebAPI-Aktionsmethode besitzt einen Parameter vom Typ JsonPatchDocument<Person>. Das JSON-Patch-Dokument wird im Body des HTTP-Aufrufs erwartet.

Leider funktioniert das neue JSON-Patch-Paket nicht in Verbindung mit dem NativeAOT-Compiler, sondern nur mit dem Just-in-Time-Compiler.

Folgender Code zeigt JSON Patch mit Microsoft.AspNetCore.JsonPatch.SystemTextJson:

using System;
using System.Formats.Asn1;
using System.Net.ServerSentEvents;
using System.Runtime.CompilerServices;
using ITVisions;
using Microsoft.AspNetCore.Http.HttpResults;
using Microsoft.AspNetCore.JsonPatch.SystemTextJson;
using Microsoft.AspNetCore.Mvc;
 
namespace NET10_WebAPIController.Controllers;
 
/// <summary>
/// Personendaten holen und aktualisieren mit einem JSON-Patch-Dokument
/// </summary>
[ApiController]
[Route("[controller]")]
public class PersonController : ControllerBase
{
 
 private readonly ILogger<WeatherForecastController> _logger;
 
 public PersonController(ILogger<WeatherForecastController> logger)
 {
  _logger = logger;
 }
 
 /// <summary>
 /// Diese WebAPI-Operation liefert die Daten zu einer Person anhand der ID
 /// </summary>
 /// <remarks>Es wird aktuell immer die gleiche Person geliefert ;-(</remarks>
 /// <param name="id">ID der Person</param>
 /// <returns>Person-Objekt mit Adresse</returns>
 [HttpGet]
 [Route("/Person_OhneTypedResult/{id}")]
 public async Task<Person> Get1(int id = 0)
 {
  var person = await new PersonManager().GetPersonByIdAsync(id);
  return person;
 }
 
 /// <summary>
 /// Diese WebAPI-Operation liefert die Daten zu einer Person anhand der ID
 /// </summary>
 /// <remarks>Es wird aktuell immer die gleiche Person geliefert ;-(</remarks>
 /// <param name="id">ID der Person</param>
 /// <returns>Person-Objekt mit Adresse</returns>
 [HttpGet]
 [Route("/Person_MitTypedResult/{id}")]
 [ProducesResponseType<IEnumerable<WeatherForecast>>(StatusCodes.Status200OK, Description = "Person-Objekt mit Adresse (aus [ProducesResponseType])")]
 [ProducesResponseType<ValidationProblem>(StatusCodes.Status400BadRequest, Description = "Fehlerhafte Anfrage / ID muss größer als 0 sein!")]
 [ProducesResponseType<ValidationProblem>(StatusCodes.Status404NotFound, Description = "Person nicht gefunden")]
 
 public async Task<Results<Ok<Person>, ValidationProblem, NotFound<ProblemDetails>>> Get_MitTypedResult(int id = 0)
 {
  if (id <= 0)
  {
   return TypedResults.ValidationProblem(new Dictionary<string, string[]> { { "id", new[] { "ID muss größer als 0 sein!" } } });
  }
  var person = await new PersonManager().GetPersonByIdAsync(id);
  if (person == null)
  {
   return TypedResults.NotFound(new ProblemDetails { Title = "Person not found", Detail = $"Person mit ID {id} nicht gefunden!" });
  }
  return TypedResults.Ok(person);
 }
 
 // PATCH https://localhost:7022/person/123
 [HttpPatch]
 [Route("{id}")]
 public async Task<Results<Ok<Person>, ValidationProblem, NotFound<ProblemDetails>>> UpdatePerson(int id, JsonPatchDocument<Person> patchDoc = null)
 {
  var person = await new PersonManager().GetPersonByIdAsync(id);
  if (person == null)
  {
   return TypedResults.NotFound(new ProblemDetails { Title = "Person not found", Detail = $"No person found with ID {id}" });
  }
 
  if (patchDoc != null)
  {
   Dictionary<string, string[]> errors = new Dictionary<string, string[]>();
   // JSON-Patch-Dokument anwenden auf das Person-Objekt
   int errorCount = 0;
   patchDoc!.ApplyTo(person, patchError =>
   {
    errors.Add(patchError.AffectedObject.GetType().Name + "#" + ++errorCount, new[] { patchError.ErrorMessage });
   });
 
   if (errors.Count > 0)
   {
    return TypedResults.ValidationProblem(errors);
   }
  }
  return TypedResults.Ok(person);
 }
}

Folgender Beispielcode simuliert die vom obigen Controller genutzte Geschäftslogik:

public class PersonManager
{
 
 public async Task<Person?> GetPersonByIdAsync(int id)
 {
  // Originalobjekt
  var person = new Person
  {
   FirstName = "Holger",
   LastName = "Schwichtenberg",
   PrivateEmail = "buero@IT-Visions.de",
   PrivateWebsite = "www.dotnet-doktor.de",
   CompanyWebsite = "www.IT-Visions.de",
   PhoneNumbers = [new PhoneNumber() { Number = "0201 649590-0", Type = PhoneNumberType.Work }],
   Address = new Address
   {
    Street = "Fahrenberg 40b",
    City = "Essen",
    State = "NRW"
   }
  };
  return await Task.FromResult(person);
 }
}

Da man einen PATCH-Aufruf nicht einfach über die Adresszeile eines Webbrowsers auslösen kann, verwendet man zum Testen die HTTP-Tests in Visual Studio (.http-Dateien) oder ein externes Werkzeug wie Fiddler oder Postman. Das JSON-Patch-Dokument übergibt man via HTTP-Body.

Aufruf einer ASP.NET-Core-basierten WebAPI, die ein JSON-Patch-Dokument erwartet und ein geändertes Objekt liefert, in einer .http-Datei innerhalb von Visual Studio (Abb. 1).

Aufruf einer ASP.NET-Core-basierten WebAPI, die ein JSON-Patch-Dokument erwartet und ein geändertes Objekt liefert, in Postman (Abb. 2).

(rme)