¿Cómo devuelvo NotFound () IHttpActionResult con un mensaje de error o una excepción?

Estoy devolviendo un NotFound IHttpActionResult, cuando no se encuentra algo en mi acción WebApi GET. Junto con esta respuesta, quiero enviar un mensaje personalizado y / o el mensaje de excepción (si corresponde). La corriente ApiController's NotFound()método no proporciona una sobrecarga para pasar un mensaje.

¿Hay alguna forma de hacer esto? o tendré que escribir mi propia costumbre IHttpActionResult?

Debería escribir el resultado de su propia acción si desea personalizar la forma del mensaje de respuesta.

Queríamos proporcionar las formas de mensaje de respuesta más comunes listas para usar para cosas como simples 404 vacíos, pero también queríamos mantener estos resultados lo más simples posible; Una de las principales ventajas de utilizar los resultados de la acción es que hace que su método de acción sea mucho más fácil de realizar pruebas unitarias. Cuantas más propiedades pongamos en los resultados de la acción, más cosas debe tener en cuenta la prueba unitaria para asegurarse de que el método de acción está haciendo lo que usted espera.

A menudo también quiero la capacidad de proporcionar un mensaje personalizado, así que no dude en registrar un error para que consideremos respaldar ese resultado de acción en una versión futura: https://aspnetwebstack.codeplex.com/workitem/list/advanced

Sin embargo, una cosa buena acerca de los resultados de las acciones es que siempre puedes escribir los tuyos con bastante facilidad si quieres hacer algo ligeramente diferente. Así es como puede hacerlo en su caso (suponiendo que desee el mensaje de error en texto / plano; si desea JSON, haría algo ligeramente diferente con el contenido):

public class NotFoundTextPlainActionResult : IHttpActionResult
{
    public NotFoundTextPlainActionResult(string message, HttpRequestMessage request)
    {
        if (message == null)
        {
            throw new ArgumentNullException("message");
        }

        if (request == null)
        {
            throw new ArgumentNullException("request");
        }

        Message = message;
        Request = request;
    }

    public string Message { get; private set; }

    public HttpRequestMessage Request { get; private set; }

    public Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
    {
        return Task.FromResult(Execute());
    }

    public HttpResponseMessage Execute()
    {
        HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.NotFound);
        response.Content = new StringContent(Message); // Put the message in the response body (text/plain content).
        response.RequestMessage = Request;
        return response;
    }
}

public static class ApiControllerExtensions
{
    public static NotFoundTextPlainActionResult NotFound(this ApiController controller, string message)
    {
        return new NotFoundTextPlainActionResult(message, controller.Request);
    }
}

Luego, en su método de acción, puede hacer algo como esto:

public class TestController : ApiController
{
    public IHttpActionResult Get()
    {
        return this.NotFound("These are not the droids you're looking for.");
    }
}

Si usó una clase base de controlador personalizado (en lugar de heredar directamente de ApiController), también podría eliminar el "esto". part (que desafortunadamente se requiere cuando se llama a un método de extensión):

public class CustomApiController : ApiController
{
    protected NotFoundTextPlainActionResult NotFound(string message)
    {
        return new NotFoundTextPlainActionResult(message, Request);
    }
}

public class TestController : CustomApiController
{
    public IHttpActionResult Get()
    {
        return NotFound("These are not the droids you're looking for.");
    }
}

Aquí hay una sola línea para devolver un IHttpActionResult NotFound con un mensaje simple:

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

Podría usar ResponseMessageResultsi lo desea:

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

sí, si necesita versiones mucho más cortas, supongo que debe implementar el resultado de su acción personalizada.

Puede usar la propiedad ReasonPhrase de la clase HttpResponseMessage

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

Puede crear un resultado de contenido negociado personalizado como sugirió d3m3t3er. Sin embargo, heredaría de. Además, si solo lo necesita para devolver NotFound, no necesita inicializar el estado http desde el constructor.

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);
    }
}

Lo resolví simplemente derivando OkNegotiatedContentResulty anulando el código HTTP en el mensaje de respuesta resultante. Esta clase le permite devolver el cuerpo del contenido con cualquier código de respuesta 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);
    }
}

Si hereda de la base NegotitatedContentResult<T>, como se mencionó, y no necesita transformar su content(por ejemplo, solo desea devolver una cadena), entonces no necesita anular el ExecuteAsyncmétodo.

Todo lo que necesita hacer es proporcionar una definición de tipo adecuada y un constructor que le indique a la base qué código de estado HTTP debe devolver. Todo lo demás simplemente funciona.

Aquí hay ejemplos para ambos NotFoundy 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) { }
}

Y luego puede crear los métodos de extensión correspondientes para ApiController(o hacerlo en una clase base si tiene una):

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);
}

Y luego funcionan como los métodos integrados. Puede llamar al existente NotFound()o puede llamar a su nuevo personalizado NotFound(myErrorMessage).

Y, por supuesto, puede deshacerse de los tipos de cadenas "codificados" en las definiciones de tipos personalizados y dejarlos genéricos si lo desea, pero luego puede que tenga que preocuparse por las ExecuteAsynccosas, dependiendo de lo que <T>realmente sea.

Puede revisar el código fuente para NegotiatedContentResult<T>ver todo lo que hace. No hay mucho que hacer.

Necesitaba crear una IHttpActionResultinstancia en el cuerpo de una IExceptionHandlerclase para establecer la ExceptionHandlerContext.Resultpropiedad. Sin embargo, también quería establecer un archivo personalizado ReasonPhrase.

Descubrí que a ResponseMessageResultpodría envolver a HttpResponseMessage(lo que permite que ReasonPhrase se configure fácilmente).

Por ejemplo:

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" });
        }
    }
}

Sé que PO preguntó con un mensaje de texto, pero otra opción para devolver un 404 es hacer que el método devuelva un IHttpActionResult y use la función StatusCode

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

A las respuestas aquí les falta un pequeño problema de la historia del desarrollador. La ApiControllerclase todavía expone un NotFound()método que los desarrolladores pueden usar. Esto provocaría que alguna respuesta 404 contenga un cuerpo de resultado no controlado.

Presento aquí algunas partes del código " mejor método ApiController NotFound " que proporcionará un método menos propenso a errores que no requiere que los desarrolladores conozcan "la mejor manera de enviar un 404".

• crear una clase heredada de laApiController llamadaApiController
  • Utilizo esta técnica para evitar que los desarrolladores usen la clase original
• anula su NotFoundmétodo para permitir que los desarrolladores usen la primera API disponible
• si desea desalentar esto, márquelo como [Obsolete("Use overload instead")]
• añade un extra protected NotFoundResult NotFound(string message)que quieras animar
• problema: el resultado no admite responder con un cuerpo. solución: heredar y usar NegotiatedContentResult. ver adjunta mejor la clase NotFoundResult .