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

Vous pouvez utiliser ceci:

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

Vous pouvez utiliser HttpRequestMessagesExtensions.CreateErrorResponse (System.Net.Http espace de noms), 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 tirer parti de la négociation de contenu de L'API Web.

Vous pouvez également faire:

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

Toute personne intéressée à retourner quelque chose avec n'importe quel statuscode avec returning ResponseMessage:

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

Dans ASP.NET API Web 2, Vous pouvez envelopper n'importe quel ResponseMessage dans 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 le système .Web.Http.Résultats .

@ mayabelle vous pouvez créer IHttpActionResult concrete et envelopper 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 d'api, pour les appeler comme return Ok("some text");

Alors j'ai fait ça: 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éer 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 consommateurs 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 de service web peut seulement vérifier IsSuccess vrai ou pas d'autre sera sûr qu'il y a un problème, et agir 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 une suggestion le cas échéant:)

Je recommande de lire ce post. Il y a des tonnes de façons d'utiliser HttpResponse existant comme suggéré, mais si vous voulez profiter de L'Api Web 2, alors regardez en utilisant certaines des options IHttpActionResult intégrées telles que

return Ok() 

Ou

return NotFound()

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

Simple:

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

N'oubliez pas de faire référence à System. Net. Http et System.Net .

Désolé pour la réponse tardive pourquoi n'utilisez-vous pas simplement

return BadRequest("your message");

Je l'utilise pour toutes mes erreurs IHttpActionResult cela fonctionne bien

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