Rückgabe des http-Statuscodes vom Web Api-Controller

Ich versuche, einen Statuscode von 304 zurückzugeben, der für eine GET-Methode in einem Web-API-Controller nicht geändert wurde.

Der einzige Weg, auf dem ich Erfolg hatte, war ungefähr so:

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

Das Problem hierbei ist, dass es keine Ausnahme ist. Es wird nur nicht geändert, sodass der Client-Cache in Ordnung ist. Ich möchte auch, dass der Rückgabetyp ein Benutzer ist (wie alle Beispiele für Web-APIs mit GET zeigen) und nicht HttpResponseMessage oder ähnliches zurückgibt.

Ich kannte die Antwort nicht und fragte das ASP.NET-Team hier .

Der Trick besteht also darin, die Signatur zu ändern HttpResponseMessageund zu verwenden 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);
}

Sie können auch Folgendes tun, wenn Sie die Aktionssignatur als wiederkehrender Benutzer beibehalten möchten:

public User GetUser(int userId, DateTime lastModifiedAtClient) 

Wenn Sie etwas anderes als das zurückgeben möchten, 200werfen Sie ein HttpResponseExceptionin Ihre Aktion und übergeben das, das HttpResponseMessageSie an den Client senden möchten.

In MVC 5 wurde es einfacher:

return new StatusCodeResult(HttpStatusCode.NotModified, this);

Ändern Sie die GetXxx-API-Methode so, dass HttpResponseMessage zurückgegeben wird, und geben Sie dann eine typisierte Version für die vollständige Antwort und die untypisierte Version für die NotModified-Antwort zurück.

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

* Die ClientHasStale-Daten sind meine Erweiterung zum Überprüfen von ETag- und IfModifiedSince-Headern.

Das MVC-Framework sollte Ihr Objekt weiterhin serialisieren und zurückgeben.

HINWEIS

Ich denke, die generische Version wird in einer zukünftigen Version der Web-API entfernt.

Ich hasse es, alte Artikel zu stoßen, aber dies ist das erste Ergebnis in der Google-Suche und ich hatte verdammt viel Zeit mit diesem Problem (sogar mit der Unterstützung von euch). Also hier geht nichts ...

Hoffentlich hilft meine Lösung denen, die auch verwirrt waren.

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

und dann einfach vom BaseController erben

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

und dann mit ihm

[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 gibt 304 Statuscode zurück. Dies verwendet einen ApiController.

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

Optional können Sie ein Objekt mit der Antwort zurückgeben

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

Für ASP.NET Web Api 2 wird in diesem Beitrag von MS vorgeschlagen , den Rückgabetyp der Methode in zu ändern IHttpActionResult. Sie können dann eine eingebaute Rück IHttpActionResultUmsetzung wie Ok, BadRequestusw. ( siehe hier ) oder eine eigene Implementierung zurück.

Für Ihren Code könnte dies wie folgt erfolgen:

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

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

Wenn Sie ein IHttpActionResult zurückgeben müssen und den Fehlercode plus eine Nachricht zurückgeben möchten, verwenden Sie:

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

Ich mag es nicht, meine Signatur ändern zu müssen, um den Typ HttpCreateResponse zu verwenden, deshalb habe ich mir eine erweiterte Lösung ausgedacht, um das zu verbergen.

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

Sie können dann Ihrem ApiController (oder besser Ihrem Basis-Controller) eine Methode wie folgt hinzufügen:

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

Dann können Sie es wie jede der integrierten Methoden zurückgeben:

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

Ein Update für @Aliostads Antwort unter Verwendung des IHttpActionResultin Web API 2 eingeführten mehr Moden .

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

Versuche dies :

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