Devolver contenido con IHttpActionResult para una respuesta no correcta

Para regresar de un controlador Web API 2, puedo devolver contenido con la respuesta si la respuesta es correcta (estado 200) de esta manera:

    public IHttpActionResult Get()
    {
        string myResult = ...
        return Ok(myResult);
    }

Si es posible, quiero usar los tipos de resultados integrados aquí cuando sea posible: https://msdn.microsoft.com/en-us/library/system.web.http.results(v=vs.118).aspx

Mi pregunta es, para otro tipo de respuesta (no 200), ¿cómo puedo devolver un mensaje (cadena) con él? Por ejemplo, puedo hacer esto:

    public IHttpActionResult Get()
    {
       return InternalServerError();
    }

pero no esto:

    public IHttpActionResult Get()
    {
       return InternalServerError("Message describing the error here");
    }

Idealmente, quiero que esto se generalice para poder enviar un mensaje de vuelta con cualquiera de las implementaciones de IHttpActionResult.

¿Necesito hacer esto (y construir mi propio mensaje de respuesta):

    public IHttpActionResult Get()
    {
       HttpResponseMessage responseMessage = ...
       return ResponseMessage(responseMessage);
    }

¿O hay un mejor camino?

Puedes usar esto:

return Content(HttpStatusCode.BadRequest, "Any object");

Puede usar HttpRequestMessagesExtensions.CreateErrorResponse ( System.Net.Httpespacio de nombres), así:

public IHttpActionResult Get()
{
   return ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Message describing the error here"));
}

Es preferible crear respuestas basadas en la solicitud para aprovechar la negociación de contenido de la API web.

Terminé yendo con la siguiente solución:

public class HttpActionResult : IHttpActionResult
{
    private readonly string _message;
    private readonly HttpStatusCode _statusCode;

    public HttpActionResult(HttpStatusCode statusCode, string message)
    {
        _statusCode = statusCode;
        _message = message;
    }

    public Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
    {
        HttpResponseMessage response = new HttpResponseMessage(_statusCode)
        {
            Content = new StringContent(_message)
        };
        return Task.FromResult(response);
    }
}

... que se puede usar así:

public IHttpActionResult Get()
{
   return new HttpActionResult(HttpStatusCode.InternalServerError, "error message"); // can use any HTTP status code
}

Estoy abierto a sugerencias de mejora. :)

También puedes hacer:

return InternalServerError(new Exception("SOME CUSTOM MESSAGE"));

Cualquiera que esté interesado en devolver algo con cualquier código de estado con ResponseMessage:

//CreateResponse(HttpStatusCode, T value)
return ResponseMessage(Request.CreateResponse(HttpStatusCode.XX, object));

En ASP.NET Web API 2, puede ajustar cualquiera ResponseMessageen un ResponseMessageResult :

public IHttpActionResult Get()
{
   HttpResponseMessage responseMessage = ...
   return new ResponseMessageResult(responseMessage);
}

En algunos casos, esta puede ser la forma más sencilla de obtener el resultado deseado, aunque en general puede ser preferible utilizar los diversos resultados en System.Web.Http.Results .

Sencillo:

return ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Your message"));

Recuerde hacer referencia a System.Net.Http y System.Net .

Recomiendo leer esta publicación. Hay muchas formas de usar HttpResponse existente como se sugiere, pero si desea aprovechar Web Api 2, entonces considere usar algunas de las opciones integradas de IHttpActionResult como

return Ok() 

o

return NotFound()

Elija el tipo de retorno correcto para los controladores de API web

Un ejemplo más detallado con soporte de código HTTP no definido en C # HttpStatusCode.

public class MyController : ApiController
{
    public IHttpActionResult Get()
    {
        HttpStatusCode codeNotDefined = (HttpStatusCode)429;
        return Content(codeNotDefined, "message to be sent in response body");
    }
}

Contentes un método virtual definido en clase abstracta ApiController, la base del controlador. Vea la declaración a continuación:

protected internal virtual NegotiatedContentResult<T> Content<T>(HttpStatusCode statusCode, T value);

@mayabelle puedes crear concreto IHttpActionResult y envolver esos códigos de esta manera:

public class NotFoundPlainTextActionResult : IHttpActionResult
{
    public NotFoundPlainTextActionResult(HttpRequestMessage request, string message)
    {
        Request = request;
        Message = message;
    }

    public string Message { get; private set; }
    public HttpRequestMessage Request { get; private set; }

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

    public HttpResponseMessage ExecuteResult()
    {
        var response = new HttpResponseMessage();

        if (!string.IsNullOrWhiteSpace(Message))
            //response.Content = new StringContent(Message);
            response = Request.CreateErrorResponse(HttpStatusCode.NotFound, new Exception(Message));

        response.RequestMessage = Request;
        return response;
    }
}

Yo tuve el mismo problema. Quiero crear un resultado personalizado para mis controladores api, para llamarlos como return Ok("some text");

Luego hice esto: 1) Crear un tipo de resultado personalizado con singletone

public sealed class EmptyResult : IHttpActionResult
{
    public Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
    {
        return Task.FromResult(new HttpResponseMessage(System.Net.HttpStatusCode.NoContent) { Content = new StringContent("Empty result") });
    }
}

2) Crear controlador personalizado con nuevo método:

public class CustomApiController : ApiController
{
    public IHttpActionResult EmptyResult()
    {
        return new EmptyResult();
    }
}

Y luego puedo llamarlos en mis controladores, así:

public IHttpActionResult SomeMethod()
    {
       return EmptyResult();
    }

Esta respuesta se basa en la respuesta de Shamil Yakupov, con objeto real en lugar de cadena.

using System.Dynamic;

dynamic response = new ExpandoObject();
response.message = "Email address already exist";

return Content<object>(HttpStatusCode.BadRequest, response);

Por excepciones, generalmente hago

 catch (Exception ex)
        {
            return InternalServerError(new ApplicationException("Something went wrong in this request. internal exception: " + ex.Message));
        }

Las cosas anteriores son realmente útiles.

Al crear servicios web, si toma el caso de los servicios, el consumidor lo apreciará mucho. Traté de mantener la uniformidad de la salida. También puede dar un comentario o un mensaje de error real. El consumidor del servicio web solo puede verificar que IsSuccess sea verdadero o no, de lo contrario se asegurará de que haya un problema y actuará según la situación.

  public class Response
    {
        /// <summary>
        /// Gets or sets a value indicating whether this instance is success.
        /// </summary>
        /// <value>
        /// <c>true</c> if this instance is success; otherwise, <c>false</c>.
        /// </value>
        public bool IsSuccess { get; set; } = false;

        /// <summary>
        /// Actual response if succeed 
        /// </summary>
        /// <value>
        /// Actual response if succeed 
        /// </value>
        public object Data { get; set; } = null;

        /// <summary>
        /// Remark if anythig to convey
        /// </summary>
        /// <value>
        /// Remark if anythig to convey
        /// </value>
        public string Remark { get; set; } = string.Empty;
        /// <summary>
        /// Gets or sets the error message.
        /// </summary>
        /// <value>
        /// The error message.
        /// </value>
        public object ErrorMessage { get; set; } = null;


    }  




[HttpGet]
        public IHttpActionResult Employees()
        {
            Response _res = new Response();
            try
            { 
                DalTest objDal = new DalTest(); 
                _res.Data = objDal.GetTestData();
                _res.IsSuccess = true;
                return Ok<Response>(_res);
            }
            catch (Exception ex)
            {
                _res.IsSuccess = false;
                _res.ErrorMessage = ex;
                return ResponseMessage(Request.CreateResponse(HttpStatusCode.InternalServerError, _res )); 
            } 
        }

Le invitamos a dar sugerencias si las hay :)

Perdón por la respuesta tardía, ¿por qué no usas simplemente

return BadRequest("your message");

Lo uso para todos mis IHttpActionResulterrores, funciona bien

Aquí está la documentación: https://msdn.microsoft.com/en-us/library/system.web.http.apicontroller.badrequest(v=vs.118).aspx