Renvoyer le contenu avec IHttpActionResult pour une réponse non OK

Pour le retour d'un contrôleur Web API 2, je peux renvoyer du contenu avec la réponse si la réponse est OK (état 200) comme ceci:

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

Si possible, je souhaite utiliser les types de résultats intégrés ici lorsque cela est possible: https://msdn.microsoft.com/en-us/library/system.web.http.results(v=vs.118).aspx

Ma question est, pour un autre type de réponse (pas 200), comment puis-je renvoyer un message (chaîne) avec? Par exemple, je peux faire ceci:

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

mais pas ça:

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

Idéalement, je veux que cela soit généralisé afin de pouvoir renvoyer un message avec l'une des implémentations de IHttpActionResult.

Dois-je faire cela (et créer mon propre message de réponse):

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

ou y a-t-il un meilleur moyen?

Vous pouvez utiliser ceci:

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

Vous pouvez utiliser HttpRequestMessagesExtensions.CreateErrorResponse ( System.Net.Httpnamespace), comme ceci:

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

Il est préférable de créer des réponses basées sur la demande pour profiter de la négociation de contenu de l'API Web.

J'ai fini par choisir la solution suivante:

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

... qui peut être utilisé comme ceci:

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

Je suis ouvert aux suggestions d'amélioration. :)

Vous pouvez également faire:

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

Toute personne intéressée à retourner quelque chose avec n'importe quel code d'état avec le retour de ResponseMessage:

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

Dans l'API Web ASP.NET 2, vous pouvez encapsuler n'importe lequel ResponseMessagedans un ResponseMessageResult :

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

Dans certains cas, cela peut être le moyen le plus simple d'obtenir le résultat souhaité, bien qu'il soit généralement préférable d'utiliser les différents résultats dans System.Web.Http.Results .

Facile:

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

N'oubliez pas de référencer System.Net.Http et System.Net .

Je recommanderais de lire cet article. Il existe des tonnes de façons d'utiliser HttpResponse existant comme suggéré, mais si vous souhaitez profiter de Web Api 2, envisagez d'utiliser certaines des options IHttpActionResult intégrées telles que

return Ok() 

ou

return NotFound()

Choisissez le bon type de retour pour les contrôleurs Web Api

Un exemple plus détaillé avec prise en charge du code HTTP non défini en C # HttpStatusCode.

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

Contentest une méthode virtuelle définie dans la classe abstraite ApiController, la base du contrôleur. Voir la déclaration ci-dessous:

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

@mayabelle vous pouvez créer IHttpActionResult concret et encapsuler ce code comme ceci:

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

J'ai eu le même problème. Je veux créer un résultat personnalisé pour mes contrôleurs api, pour les appeler comme return Ok("some text");

Ensuite, j'ai fait ceci: 1) Créer un type de résultat personnalisé avec 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) Créez un contrôleur personnalisé avec une nouvelle méthode:

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

Et puis je peux les appeler dans mes contrôleurs, comme ceci:

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

cette réponse est basée sur la réponse de Shamil Yakupov, avec un objet réel au lieu d'une chaîne.

using System.Dynamic;

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

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

Pour les exceptions, je fais habituellement

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

Les choses ci-dessus sont vraiment utiles.

Lors de la création de services Web, si vous prenez le cas des services consommateur sera grandement apprécié. J'ai essayé de maintenir l'uniformité de la sortie. Vous pouvez également donner une remarque ou un message d'erreur réel. Le consommateur du service Web ne peut que vérifier IsSuccess true ou non, il sera sûr qu'il y a un problème et agira selon la situation.

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

Vous êtes invités à donner des suggestions le cas échéant :)

Désolé pour la réponse tardive, pourquoi ne pas utiliser simplement

return BadRequest("your message");

Je l'utilise pour tous mes IHttpActionResult erreurs, il fonctionne bien

voici la documentation: https://msdn.microsoft.com/en-us/library/system.web.http.apicontroller.badrequest(v=vs.118).aspx