Jak zwrócić NotFound () IHttpActionResult z Komunikatem o błędzie lub wyjątkiem?

Oto jedna linijka do zwrotu IHttpActionResult Niefound z prostą wiadomością:

return Content(HttpStatusCode.NotFound, "Foo does not exist.");

Możesz użyć ResponseMessageResult jeśli chcesz:

var myCustomMessage = "your custom message which would be sent as a content-negotiated response"; 
return ResponseMessage(
    Request.CreateResponse(
        HttpStatusCode.NotFound, 
        myCustomMessage
    )
);

Tak, jeśli potrzebujesz znacznie krótszych wersji, to chyba musisz zaimplementować swój niestandardowy wynik działania.

Możesz użyć właściwości ReasonPhrase klasy HttpResponseMessage

catch (Exception exception)
{
  throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.NotFound)
  {
    ReasonPhrase = exception.Message
  });
}

Możesz utworzyć niestandardowy wynik negocjowanej zawartości zgodnie z sugestią d3m3t3er. Jednak odziedziczyłbym po nim. Ponadto, jeśli potrzebujesz go tylko do zwracania NotFound, nie musisz inicjalizować statusu http z konstruktora.

public class NotFoundNegotiatedContentResult<T> : NegotiatedContentResult<T>
{
    public NotFoundNegotiatedContentResult(T content, ApiController controller)
        : base(HttpStatusCode.NotFound, content, controller)
    {
    }

    public override Task<HttpResponseMessage> ExecuteAsync(
        CancellationToken cancellationToken)
    {
        return base.ExecuteAsync(cancellationToken).ContinueWith(
            task => task.Result, cancellationToken);
    }
}

Rozwiązałem to po prostu poprzez wyprowadzenie z OkNegotiatedContentResult i nadpisanie kodu HTTP w wynikowej wiadomości odpowiedzi. Ta klasa pozwala na zwrócenie zawartości ciała za pomocą dowolnego kodu odpowiedzi HTTP.

public class CustomNegotiatedContentResult<T> : OkNegotiatedContentResult<T>
{
    public HttpStatusCode HttpStatusCode;

    public CustomNegotiatedContentResult(
        HttpStatusCode httpStatusCode, T content, ApiController controller)
        : base(content, controller)
    {
        HttpStatusCode = httpStatusCode;
    }

    public override Task<HttpResponseMessage> ExecuteAsync(
        CancellationToken cancellationToken)
    {
        return base.ExecuteAsync(cancellationToken).ContinueWith(
            task => { 
                // override OK HTTP status code with our own
                task.Result.StatusCode = HttpStatusCode;
                return task.Result;
            },
            cancellationToken);
    }
}

Potrzebowałem stworzyć IHttpActionResult instancję w ciele IExceptionHandler klasy, w celu ustawienia właściwości ExceptionHandlerContext.Result. Jednak chciałem również ustawić niestandardowy ReasonPhrase.

Odkryłem, że a {[5] } może zawijać a HttpResponseMessage (co pozwala łatwo ustawić ReasonPhrase).

Na Przykład:

public class MyExceptionHandler : ExceptionHandler
{
    public override void Handle(ExceptionHandlerContext context)
    {
        var ex = context.Exception as IRecordNotFoundException;
        if (ex != null)
        {
            context.Result = new ResponseMessageResult(new HttpResponseMessage(HttpStatusCode.NotFound) { ReasonPhrase = $"{ex.EntityName} not found" });
        }
    }
}

Jeśli dziedziczysz z Bazy NegotitatedContentResult<T>, Jak wspomniano, i nie musisz przekształcać swojego content (np. chcesz tylko zwrócić łańcuch znaków), to nie musisz nadpisywać metody ExecuteAsync.

Wystarczy podać odpowiednią definicję typu i konstruktor, który powie bazie, który kod statusu HTTP ma zwrócić. Wszystko inne po prostu działa.

Oto przykłady dla NotFound i InternalServerError:

public class NotFoundNegotiatedContentResult : NegotiatedContentResult<string>
{
    public NotFoundNegotiatedContentResult(string content, ApiController controller)
        : base(HttpStatusCode.NotFound, content, controller) { }
}

public class InternalServerErrorNegotiatedContentResult : NegotiatedContentResult<string>
{
    public InternalServerErrorNegotiatedContentResult(string content, ApiController controller)
        : base(HttpStatusCode.InternalServerError, content, controller) { }
}

I wtedy można utworzyć odpowiednie metody rozszerzenia dla ApiController (lub zrób to w klasie bazowej, jeśli taką posiadasz):

public static NotFoundNegotiatedContentResult NotFound(this ApiController controller, string message)
{
    return new NotFoundNegotiatedContentResult(message, controller);
}

public static InternalServerErrorNegotiatedContentResult InternalServerError(this ApiController controller, string message)
{
    return new InternalServerErrorNegotiatedContentResult(message, controller);
}

I wtedy działają tak samo jak wbudowane metody. Możesz wywołać istniejącą NotFound() lub nową niestandardową NotFound(myErrorMessage).

I oczywiście, możesz pozbyć się" twardych " typów łańcuchów w niestandardowych definicjach typu i pozostawić je ogólne, jeśli chcesz, ale wtedy Może będziesz musiał się martwić o ExecuteAsync rzeczy, w zależności od tego, co <T> faktycznie jest.

Możesz spojrzeć nad kodem źródłowym dla NegotiatedContentResult<T>, aby zobaczyć wszystko, co robi. Nie ma w tym zbyt wiele.

Wiem, że PO zapytało z tekstem wiadomości, ale inną opcją zwrócenia 404 jest zwrócenie metody ihttpactionresult i użycie funkcji StatusCode

    public async Task<IHttpActionResult> Get([FromUri]string id)
    {
       var item = await _service.GetItem(id);
       if(item == null)
       {
           StatusCode(HttpStatusCode.NotFound);
       }
       return Ok(item);
    }

Tutaj brakuje odpowiedzi na mały problem z fabułą programisty. Klasa ApiController wciąż ujawnia metodę NotFound(), której mogą używać Programiści. Spowodowałoby to, że niektóre 404 odpowiedzi zawierają niekontrolowany wynik ciała.

Przedstawiam tutaj kilka części kodu " better apicontroller NotFound method ", które zapewnią mniej podatną na błędy metodę, która nie wymaga od programistów znajomości "lepszego sposobu wysyłania 404".

• Utwórz klasę dziedzicząc z ApiController called ApiController
  • używam tej techniki, aby uniemożliwić programistom używanie oryginalnej klasy
• override its NotFound method to let devs use the first available api
• jeśli chcesz to zniechęcić, oznacz to jako [Obsolete("Use overload instead")]
• dodaj dodatkowe protected NotFoundResult NotFound(string message) które chcesz zachęcić
• problem: wynik nie wspiera reakcji z ciałem. rozwiązanie: dziedziczenie i używanie NegotiatedContentResult. zobacz w załączeniu better NotFoundResult Klasa .