Rückgabe eines 404 von einem explizit typisierten ASP.NET Core API-Controller (nicht IActionResult)

ASP.NET Core API-Controller geben normalerweise explizite Typen zurück (und dies standardmäßig, wenn Sie ein neues Projekt erstellen).

[Route("api/[controller]")]
public class ThingsController : Controller
{
    // GET api/things
    [HttpGet]
    public async Task<IEnumerable<Thing>> GetAsync()
    {
        //...
    }

    // GET api/things/5
    [HttpGet("{id}")]
    public async Task<Thing> GetAsync(int id)
    {
        Thing thingFromDB = await GetThingFromDBAsync();
        if(thingFromDB == null)
            return null; // This returns HTTP 204

        // Process thingFromDB, blah blah blah
        return thing;
    }

    // POST api/things
    [HttpPost]
    public void Post([FromBody]Thing thing)
    {
        //..
    }

    //... and so on...
}

Das Problem ist, dass return null;- es ein HTTP zurückgibt 204: Erfolg, kein Inhalt.

Dies wird dann von vielen clientseitigen Javascript-Komponenten als Erfolg angesehen, daher gibt es Code wie:

const response = await fetch('.../api/things/5', {method: 'GET' ...});
if(response.ok)
    return await response.json(); // Error, no content!

Eine Online-Suche (wie diese Frage und diese Antwort ) weist auf hilfreiche return NotFound();Erweiterungsmethoden für den Controller hin, aber alle diese Rückgaben IActionResultsind nicht mit meinem Task<Thing>Rückgabetyp kompatibel . Das Designmuster sieht folgendermaßen aus:

// GET api/things/5
[HttpGet("{id}")]
public async Task<IActionResult> GetAsync(int id)
{
    var thingFromDB = await GetThingFromDBAsync();
    if (thingFromDB == null)
        return NotFound();

    // Process thingFromDB, blah blah blah
    return Ok(thing);
}

Das funktioniert, aber um es zu verwenden, muss der Rückgabetyp von GetAsyncgeändert werden Task<IActionResult>- die explizite Typisierung geht verloren, und entweder müssen alle Rückgabetypen auf dem Controller geändert werden (dh es wird überhaupt keine explizite Typisierung verwendet), oder es wird eine Mischung geben, bei der Einige Aktionen befassen sich mit expliziten Typen, während andere. Außerdem müssen Unit-Tests jetzt Annahmen über die Serialisierung treffen und den Inhalt des Where explizit deserialisieren, IActionResultbevor sie einen konkreten Typ hatten.

Es gibt viele Möglichkeiten, dies zu umgehen, aber es scheint ein verwirrender Mischmasch zu sein, der leicht herausgearbeitet werden kann. Die eigentliche Frage lautet also: Was ist der richtige Weg, den die ASP.NET Core-Designer beabsichtigen?

Es scheint, dass die möglichen Optionen sind:

1. Haben Sie eine seltsame (chaotisch zu testende) Mischung aus expliziten Typen und IActionResultabhängig vom erwarteten Typ.
2. Vergessen Sie explizite Typen, sind sie nicht wirklich von Core MVC unterstützt, immer Gebrauch IActionResult(in diesem Fall , warum sind sie überhaupt vorstellen?)
3. Schreiben Sie eine Implementierung HttpResponseExceptionund verwenden Sie es wie ArgumentOutOfRangeException(siehe diese Antwort für eine Implementierung). Dies erfordert jedoch die Verwendung von Ausnahmen für den Programmablauf, was im Allgemeinen eine schlechte Idee ist und auch vom MVC Core-Team abgelehnt wird .
4. Schreiben Sie eine Implementierung HttpNoContentOutputFormatterdieser Rückgabe 404für GET-Anforderungen.
5. Fehlt mir noch etwas, wie Core MVC funktionieren soll?
6. Oder gibt es einen Grund, warum eine fehlgeschlagene GET-Anforderung 204richtig und 404falsch ist?

All dies beinhaltet Kompromisse und Refactoring, die etwas verlieren oder eine scheinbar unnötige Komplexität hinzufügen, die im Widerspruch zum Design von MVC Core steht. Welcher Kompromiss ist der richtige und warum?

Dies wird in ASP.NET Core 2.1 behoben mit ActionResult<T>:

public ActionResult<Thing> Get(int id) {
    Thing thing = GetThingFromDB();

    if (thing == null)
        return NotFound();

    return thing;
}

Oder auch:

public ActionResult<Thing> Get(int id) =>
    GetThingFromDB() ?? NotFound();

Ich werde diese Antwort detaillierter aktualisieren, sobald ich sie implementiert habe.

Ursprüngliche Antwort

In ASP.NET Web API 5 gab es eine HttpResponseException(wie von Hackerman hervorgehoben ), die jedoch aus Core entfernt wurde und für deren Verarbeitung keine Middleware vorhanden ist.

Ich denke, diese Änderung ist auf .NET Core zurückzuführen - wo ASP.NET versucht, alles sofort zu erledigen, macht ASP.NET Core nur das, was Sie ausdrücklich sagen (was ein großer Teil dessen ist, warum es so viel schneller und portabler ist ).

Ich kann keine vorhandene Bibliothek finden, die dies tut, also habe ich sie selbst geschrieben. Zuerst benötigen wir eine benutzerdefinierte Ausnahme, um Folgendes zu überprüfen:

public class StatusCodeException : Exception
{
    public StatusCodeException(HttpStatusCode statusCode)
    {
        StatusCode = statusCode;
    }

    public HttpStatusCode StatusCode { get; set; }
}

Dann brauchen wir einen RequestDelegateHandler, der nach der neuen Ausnahme sucht und sie in den HTTP-Antwortstatuscode konvertiert:

public class StatusCodeExceptionHandler
{
    private readonly RequestDelegate request;

    public StatusCodeExceptionHandler(RequestDelegate pipeline)
    {
        this.request = pipeline;
    }

    public Task Invoke(HttpContext context) => this.InvokeAsync(context); // Stops VS from nagging about async method without ...Async suffix.

    async Task InvokeAsync(HttpContext context)
    {
        try
        {
            await this.request(context);
        }
        catch (StatusCodeException exception)
        {
            context.Response.StatusCode = (int)exception.StatusCode;
            context.Response.Headers.Clear();
        }
    }
}

Dann registrieren wir diese Middleware in unserem Startup.Configure:

public class Startup
{
    ...

    public void Configure(IApplicationBuilder app)
    {
        ...
        app.UseMiddleware<StatusCodeExceptionHandler>();

Schließlich können Aktionen die HTTP-Statuscode-Ausnahme auslösen und dennoch einen expliziten Typ zurückgeben, der ohne Konvertierung von IActionResult:

public Thing Get(int id) {
    Thing thing = GetThingFromDB();

    if (thing == null)
        throw new StatusCodeException(HttpStatusCode.NotFound);

    return thing;
}

Dies behält die expliziten Typen für die Rückgabewerte bei und ermöglicht eine einfache Unterscheidung zwischen erfolgreichen leeren Ergebnissen ( return null;) und einem Fehler, da etwas nicht gefunden werden kann (ich denke, es ist wie das Auslösen eines ArgumentOutOfRangeException).

Obwohl dies eine Lösung für das Problem ist, beantwortet es meine Frage immer noch nicht wirklich - die Designer der Web-API erstellen Unterstützung für explizite Typen mit der Erwartung, dass sie verwendet werden, und fügten eine spezifische Behandlung hinzu return null;, damit eher ein 204 erzeugt wird als eine 200, und dann keine Möglichkeit hinzugefügt, mit 404 umzugehen? Es scheint eine Menge Arbeit zu sein, etwas so Grundlegendes hinzuzufügen.

Sie können tatsächlich IActionResultoder Task<IActionResult>anstelle von Thingoder Task<Thing>oder sogar verwenden Task<IEnumerable<Thing>>. Wenn Sie eine API haben, die JSON zurückgibt , können Sie einfach Folgendes tun:

[Route("api/[controller]")]
public class ThingsController : Controller
{
    // GET api/things
    [HttpGet]
    public async Task<IActionResult> GetAsync()
    {
    }

    // GET api/things/5
    [HttpGet("{id}")]
    public async Task<IActionResult> GetAsync(int id)
    {
        var thingFromDB = await GetThingFromDBAsync();
        if (thingFromDB == null)
            return NotFound();

        // Process thingFromDB, blah blah blah
        return Ok(thing); // This will be JSON by default
    }

    // POST api/things
    [HttpPost]
    public void Post([FromBody] Thing thing)
    {
    }
}

Aktualisieren

Es scheint , als ob die Sorge ist , dass sein persönliches Vertrauen in der Rückkehr einer API irgendwie hilfreich ist, während es möglich ist , wird explizit es in der Tat nicht sehr nützlich ist. Wenn Sie Komponententests schreiben, die die Anforderungs- / Antwort-Pipeline ausführen, überprüfen Sie normalerweise die unformatierte Rückgabe (die höchstwahrscheinlich JSON ist , dh eine Zeichenfolge in C # ). Sie können einfach die zurückgegebene Zeichenfolge nehmen und sie für Vergleiche mit wieder in das stark typisierte Äquivalent konvertieren Assert.

Dies scheint das einzige Manko bei der Verwendung von IActionResultoder zu sein Task<IActionResult>. Wenn Sie wirklich, wirklich explizit sein und dennoch den Statuscode festlegen möchten, gibt es mehrere Möglichkeiten, dies zu tun - aber es ist verpönt, da das Framework bereits einen eingebauten Mechanismus dafür hat, dh; Verwenden der IActionResultWrapper für die Rückgabemethode in der ControllerKlasse. Sie können jedoch eine benutzerdefinierte Middleware schreiben , um dies zu handhaben, wie Sie möchten.

Abschließend möchte ich darauf hinweisen, dass ein Statuscode von 204 tatsächlich korrekt ist , wenn ein API-Aufruf nullgemäß W3 zurückgegeben wird. Warum um alles in der Welt möchten Sie einen 404 ?

204

Der Server hat die Anforderung erfüllt, muss jedoch keinen Entitätskörper zurückgeben und möchte möglicherweise aktualisierte Metainformationen zurückgeben. Die Antwort kann neue oder aktualisierte Metainformationen in Form von Entity-Headern enthalten, die, falls vorhanden, der angeforderten Variante zugeordnet werden sollten.

Wenn der Client ein Benutzeragent ist, DARF er seine Dokumentansicht NICHT von der Ansicht ändern, die das Senden der Anforderung verursacht hat. Diese Antwort soll in erster Linie die Eingabe von Aktionen ermöglichen, ohne die aktive Dokumentansicht des Benutzeragenten zu ändern, obwohl alle neuen oder aktualisierten Metainformationen auf das Dokument angewendet werden sollten, das sich derzeit in der aktiven Ansicht des Benutzeragenten befindet.

Die Antwort 204 darf keinen Nachrichtentext enthalten und wird daher immer durch die erste leere Zeile nach den Headerfeldern beendet.

Ich denke, der erste Satz des zweiten Absatzes sagt es am besten: "Wenn der Client ein Benutzeragent ist, sollte er seine Dokumentansicht NICHT von der ändern, die das Senden der Anfrage verursacht hat." Dies ist bei einer API der Fall. Im Vergleich zu einem 404 :

Der Server hat nichts gefunden, das mit dem Request-URI übereinstimmt. Es wird kein Hinweis darauf gegeben, ob der Zustand vorübergehend oder dauerhaft ist. Der 410 (Gone) -Statuscode sollte verwendet werden, wenn der Server über einen intern konfigurierbaren Mechanismus weiß, dass eine alte Ressource dauerhaft nicht verfügbar ist und keine Weiterleitungsadresse hat. Dieser Statuscode wird häufig verwendet, wenn der Server nicht genau angeben möchte, warum die Anforderung abgelehnt wurde, oder wenn keine andere Antwort zutreffend ist.

Der Hauptunterschied besteht darin, dass einer eher für eine API und der andere für die Dokumentansicht gilt, d. H. die angezeigte Seite.

Um so etwas zu erreichen (immer noch, ich glaube , dass der beste Ansatz verwenden sollten IActionResult), können Sie folgen, wo Sie throwein , HttpResponseExceptionwenn Ihr Thingheißt null:

// GET api/things/5
[HttpGet("{id}")]
public async Task<Thing> GetAsync(int id)
{
    Thing thingFromDB = await GetThingFromDBAsync();
    if(thingFromDB == null){
        throw new HttpResponseException(HttpStatusCode.NotFound); // This returns HTTP 404
    }
    // Process thingFromDB, blah blah blah
    return thing;
}

Was Sie mit der Rückgabe von "Explicit Types" vom Controller tun, wird nicht mit Ihrer Anforderung zusammenarbeiten, explizit mit Ihrem eigenen Antwortcode umzugehen . Die einfachste Lösung ist zu gehen IActionResult(wie andere vorgeschlagen haben); Sie können Ihren Rückgabetyp jedoch auch explizit mithilfe des [Produces]Filters steuern .

Verwenden von IActionResult.

Um die Kontrolle über die Statusergebnisse zu erlangen, müssen Sie a zurückgeben IActionResult, wo Sie dann den StatusCodeResultTyp nutzen können. Jetzt haben Sie jedoch das Problem, ein bestimmtes Format erzwingen zu wollen ...

Die folgenden Informationen stammen aus dem Microsoft-Dokument: Formatieren von Antwortdaten - Erzwingen eines bestimmten Formats

Erzwingen eines bestimmten Formats

Wenn Sie die Antwortformate für eine bestimmte Aktion einschränken möchten, können Sie den [Produces]Filter anwenden . Der [Produces]Filter gibt die Antwortformate für eine bestimmte Aktion (oder einen bestimmten Controller) an. Wie die meisten Filter kann dies auf die Aktion, den Controller oder den globalen Bereich angewendet werden.

Alles zusammenfügen

Hier ist ein Beispiel für die Kontrolle über die StatusCodeResultzusätzlich zur Kontrolle über den "expliziten Rückgabetyp".

// GET: api/authors/search?namelike=foo
[Produces("application/json")]
[HttpGet("Search")]
public IActionResult Search(string namelike)
{
    var result = _authorRepository.GetByNameSubstring(namelike);
    if (!result.Any())
    {
        return NotFound(namelike);
    }
    return Ok(result);
}

Ich bin kein großer Befürworter dieses Entwurfsmusters, aber ich habe diese Bedenken in einige zusätzliche Antworten auf die Fragen anderer Leute aufgenommen. Sie müssen beachten, dass Sie für den [Produces]Filter den entsprechenden Formatierer / Serializer / Expliziten Typ zuordnen müssen. In dieser Antwort finden Sie weitere Ideen oder in dieser Antwort eine detailliertere Steuerung Ihrer ASP.NET Core-Web-API .