Retour du code d'état http à partir du contrôleur Web Api

J'essaie de retourner un code d'état de 304 non modifié pour une méthode GET dans un contrôleur web api.

La seule façon dont j'ai réussi était quelque chose comme ça:

public class TryController : ApiController
{
    public User GetUser(int userId, DateTime lastModifiedAtClient)
    {
        var user = new DataEntities().Users.First(p => p.Id == userId);
        if (user.LastModified <= lastModifiedAtClient)
        {
             throw new HttpResponseException(HttpStatusCode.NotModified);
        }
        return user;
    }
}

Le problème ici est que ce n'est pas une exception, il n'est tout simplement pas modifié donc le cache client est OK. Je veux également que le type de retour soit un utilisateur (comme le montrent tous les exemples d'API Web avec GET) et non pas HttpResponseMessage ou quelque chose comme ça.

Je ne connaissais pas la réponse alors j'ai demandé à l'équipe ASP.NET ici .

L'astuce consiste donc à modifier la signature HttpResponseMessageet à l'utiliser Request.CreateResponse.

[ResponseType(typeof(User))]
public HttpResponseMessage GetUser(HttpRequestMessage request, int userId, DateTime lastModifiedAtClient)
{
    var user = new DataEntities().Users.First(p => p.Id == userId);
    if (user.LastModified <= lastModifiedAtClient)
    {
         return new HttpResponseMessage(HttpStatusCode.NotModified);
    }
    return request.CreateResponse(HttpStatusCode.OK, user);
}

Vous pouvez également effectuer les opérations suivantes si vous souhaitez conserver la signature d'action en tant qu'utilisateur de retour:

public User GetUser(int userId, DateTime lastModifiedAtClient) 

Si vous voulez retourner autre chose que 200vous lancez un HttpResponseExceptiondans votre action et passez le que HttpResponseMessagevous voulez envoyer au client.

Dans MVC 5, les choses sont devenues plus faciles:

return new StatusCodeResult(HttpStatusCode.NotModified, this);

Modifiez la méthode GetXxx API pour renvoyer HttpResponseMessage, puis renvoyez une version typée pour la réponse complète et la version non typée pour la réponse NotModified.

    public HttpResponseMessage GetComputingDevice(string id)
    {
        ComputingDevice computingDevice =
            _db.Devices.OfType<ComputingDevice>()
                .SingleOrDefault(c => c.AssetId == id);

        if (computingDevice == null)
        {
            return this.Request.CreateResponse(HttpStatusCode.NotFound);
        }

        if (this.Request.ClientHasStaleData(computingDevice.ModifiedDate))
        {
            return this.Request.CreateResponse<ComputingDevice>(
                HttpStatusCode.OK, computingDevice);
        }
        else
        {
            return this.Request.CreateResponse(HttpStatusCode.NotModified);
        }
    }

* Les données ClientHasStale sont mon extension pour vérifier les en-têtes ETag et IfModifiedSince.

Le framework MVC doit toujours sérialiser et renvoyer votre objet.

REMARQUE

Je pense que la version générique est supprimée dans une future version de l'API Web.

Je déteste heurter les anciens articles, mais c'est le premier résultat pour cela dans la recherche Google et j'ai eu beaucoup de mal avec ce problème (même avec le soutien de vous). Alors ça ne va rien ...

J'espère que ma solution aidera ceux qui ont également été confus.

namespace MyApplication.WebAPI.Controllers
{
    public class BaseController : ApiController
    {
        public T SendResponse<T>(T response, HttpStatusCode statusCode = HttpStatusCode.OK)
        {
            if (statusCode != HttpStatusCode.OK)
            {
                // leave it up to microsoft to make this way more complicated than it needs to be
                // seriously i used to be able to just set the status and leave it at that but nooo... now 
                // i need to throw an exception 
                var badResponse =
                    new HttpResponseMessage(statusCode)
                    {
                        Content =  new StringContent(JsonConvert.SerializeObject(response), Encoding.UTF8, "application/json")
                    };

                throw new HttpResponseException(badResponse);
            }
            return response;
        }
    }
}

puis juste hériter du BaseController

[RoutePrefix("api/devicemanagement")]
public class DeviceManagementController : BaseController
{...

puis l'utiliser

[HttpGet]
[Route("device/search/{property}/{value}")]
public SearchForDeviceResponse SearchForDevice(string property, string value)
{
    //todo: limit search property here?
    var response = new SearchForDeviceResponse();

    var results = _deviceManagementBusiness.SearchForDevices(property, value);

    response.Success = true;
    response.Data = results;

    var statusCode = results == null || !results.Any() ? HttpStatusCode.NoContent : HttpStatusCode.OK;

    return SendResponse(response, statusCode);
}

.net core 2.2 renvoyant le code de statut 304. Cela utilise un ApiController.

    [HttpGet]
    public ActionResult<YOUROBJECT> Get()
    {
        return StatusCode(304);
    }

Vous pouvez éventuellement renvoyer un objet avec la réponse

    [HttpGet]
    public ActionResult<YOUROBJECT> Get()
    {
        return StatusCode(304, YOUROBJECT); 
    }

Pour ASP.NET Web Api 2, ce message de MS suggère de changer le type de retour de la méthode en IHttpActionResult. Vous pouvez ensuite revenir construit dans la IHttpActionResultmise en œuvre comme Ok, BadRequest, etc ( voir ici ) ou retourner votre propre implémentation.

Pour votre code, cela pourrait se faire comme:

public IHttpActionResult GetUser(int userId, DateTime lastModifiedAtClient)
{
    var user = new DataEntities().Users.First(p => p.Id == userId);
    if (user.LastModified <= lastModifiedAtClient)
    {
        return StatusCode(HttpStatusCode.NotModified);
    }
    return Ok(user);
}

Une autre option:

return new NotModified();

public class NotModified : IHttpActionResult
{
    public Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
    {
        var response = new HttpResponseMessage(HttpStatusCode.NotModified);
        return Task.FromResult(response);
    }
}

public HttpResponseMessage Post(Article article)
{
    HttpResponseMessage response = Request.CreateResponse<Article>(HttpStatusCode.Created, article);

    string uriToTheCreatedItem = Url.Route(null, new { id = article.Id });
    response.Headers.Location = new Uri(Request.RequestUri, uriToTheCreatedItem);

    return response;
}

Si vous devez renvoyer un IHttpActionResult et que vous souhaitez renvoyer le code d'erreur plus un message, utilisez:

return ResponseMessage(Request.CreateErrorResponse(HttpStatusCode.NotModified, "Error message here"));

Je n'aime pas avoir à changer ma signature pour utiliser le type HttpCreateResponse, j'ai donc proposé une petite solution étendue pour masquer cela.

public class HttpActionResult : IHttpActionResult
{
    public HttpActionResult(HttpRequestMessage request) : this(request, HttpStatusCode.OK)
    {
    }

    public HttpActionResult(HttpRequestMessage request, HttpStatusCode code) : this(request, code, null)
    {
    }

    public HttpActionResult(HttpRequestMessage request, HttpStatusCode code, object result)
    {
        Request = request;
        Code = code;
        Result = result;
    }

    public HttpRequestMessage Request { get; }
    public HttpStatusCode Code { get; }
    public object Result { get; }

    public Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
    {
        return Task.FromResult(Request.CreateResponse(Code, Result));
    }
}

Vous pouvez ensuite ajouter une méthode à votre ApiController (ou mieux votre contrôleur de base) comme ceci:

protected IHttpActionResult CustomResult(HttpStatusCode code, object data) 
{
    // Request here is the property on the controller.
    return new HttpActionResult(Request, code, data);
}

Ensuite, vous pouvez le renvoyer comme n'importe quelle méthode intégrée:

[HttpPost]
public IHttpActionResult Post(Model model)
{
    return model.Id == 1 ?
                Ok() :
                CustomResult(HttpStatusCode.NotAcceptable, new { 
                    data = model, 
                    error = "The ID needs to be 1." 
                });
}

Une mise à jour de la réponse @Aliostads utilisant le plus de modens IHttpActionResultintroduit dans l'API Web 2.

https://docs.microsoft.com/en-us/aspnet/web-api/overview/getting-started-with-aspnet-web-api/action-results#ihttpactionresult

public class TryController : ApiController
{
    public IHttpActionResult GetUser(int userId, DateTime lastModifiedAtClient)
    {
        var user = new DataEntities().Users.First(p => p.Id == userId);
        if (user.LastModified <= lastModifiedAtClient)
        {
            return StatusCode(HttpStatusCode.NotModified);
            // If you would like to return a Http Status code with any object instead:
            // return Content(HttpStatusCode.InternalServerError, "My Message");
        }
        return Ok(user);
    }
}

Essaye ça :

return new ContentResult() { 
    StatusCode = 404, 
    Content = "Not found" 
};