ASP.NET Core retourne JSON avec le code d'état

Je recherche la bonne façon de renvoyer JSON avec un code d'état HTTP dans mon contrôleur API Web .NET Core. J'utilise pour l'utiliser comme ceci:

public IHttpActionResult GetResourceData()
{
    return this.Content(HttpStatusCode.OK, new { response = "Hello"});
}

C'était dans une application MVC 4.6 mais maintenant avec .NET Core, je ne semble pas avoir ce que IHttpActionResultj'ai ActionResultet utiliser comme ceci:

public ActionResult IsAuthenticated()
{
    return Ok(Json("123"));
}

Mais la réponse du serveur est étrange, comme dans l'image ci-dessous:

Je veux juste que le contrôleur de l'API Web renvoie JSON avec un code d'état HTTP comme je l'ai fait dans l'API Web 2.

La version la plus basique qui répond par un JsonResultest:

// GET: api/authors
[HttpGet]
public JsonResult Get()
{
    return Json(_authorRepository.List());
}

Cependant, cela n'aidera pas votre problème car vous ne pouvez pas traiter explicitement votre propre code de réponse.

La façon d'obtenir le contrôle sur les résultats de statut, est que vous devez renvoyer un ActionResultqui est l'endroit où vous pouvez ensuite profiter du StatusCodeResulttype.

par exemple:

// GET: api/authors/search?namelike=foo
[HttpGet("Search")]
public IActionResult Search(string namelike)
{
    var result = _authorRepository.GetByNameSubstring(namelike);
    if (!result.Any())
    {
        return NotFound(namelike);
    }
    return Ok(result);
}

Notez que les deux exemples ci-dessus proviennent d'un excellent guide disponible dans la documentation Microsoft: Formatage des données de réponse

Trucs supplémentaires

Le problème que je rencontre assez souvent est que je voulais un contrôle plus granulaire sur mon WebAPI plutôt que de simplement utiliser la configuration par défaut du modèle "Nouveau projet" dans VS.

Assurons-nous que vous avez quelques notions de base ...

Étape 1: Configurez votre service

Pour que votre ASP.NET Core WebAPI réponde avec un objet sérialisé JSON avec un contrôle total du code d'état, vous devez commencer par vous assurer que vous avez inclus le AddMvc()service dans votre ConfigureServicesméthode qui se trouve généralement dans Startup.cs.

Il est important de noter que cela AddMvc()inclura automatiquement le formateur d'entrée / sortie pour JSON ainsi que la réponse à d'autres types de demandes.

Si votre projet nécessite un contrôle total et que vous souhaitez définir strictement vos services, comme par exemple comment votre WebAPI se comportera face à différents types de requêtes, y compris application/jsonet ne répondra pas à d'autres types de requêtes (comme une requête de navigateur standard), vous pouvez le définir manuellement avec le code suivant:

public void ConfigureServices(IServiceCollection services)
{
    // Build a customized MVC implementation, without using the default AddMvc(), instead use AddMvcCore().
    // https://github.com/aspnet/Mvc/blob/dev/src/Microsoft.AspNetCore.Mvc/MvcServiceCollectionExtensions.cs

    services
        .AddMvcCore(options =>
        {
            options.RequireHttpsPermanent = true; // does not affect api requests
            options.RespectBrowserAcceptHeader = true; // false by default
            //options.OutputFormatters.RemoveType<HttpNoContentOutputFormatter>();

            //remove these two below, but added so you know where to place them...
            options.OutputFormatters.Add(new YourCustomOutputFormatter()); 
            options.InputFormatters.Add(new YourCustomInputFormatter());
        })
        //.AddApiExplorer()
        //.AddAuthorization()
        .AddFormatterMappings()
        //.AddCacheTagHelper()
        //.AddDataAnnotations()
        //.AddCors()
        .AddJsonFormatters(); // JSON, or you can build your own custom one (above)
}

Vous remarquerez que j'ai également inclus un moyen pour vous d'ajouter vos propres formateurs d'entrée / sortie personnalisés, dans le cas où vous voudriez peut-être répondre à un autre format de sérialisation (protobuf, thrift, etc.).

Le morceau de code ci-dessus est principalement un double de la AddMvc()méthode. Cependant, nous implémentons chaque service "par défaut" par nous-mêmes en définissant chaque service au lieu de choisir celui pré-livré avec le modèle. J'ai ajouté le lien du référentiel dans le bloc de code, ou vous pouvez extraire AddMvc() le référentiel GitHub. .

Notez qu'il existe des guides qui essaieront de résoudre ce problème en "annulant" les valeurs par défaut, plutôt que de simplement ne pas l'implémenter en premier lieu ... Si vous tenez compte du fait que nous travaillons maintenant avec Open Source, c'est un travail redondant , mauvais code et franchement une vieille habitude qui va bientôt disparaître.

Étape 2: créer un contrôleur

Je vais vous en montrer une très simple juste pour que votre question soit triée.

public class FooController
{
    [HttpPost]
    public async Task<IActionResult> Create([FromBody] Object item)
    {
        if (item == null) return BadRequest();

        var newItem = new Object(); // create the object to return
        if (newItem != null) return Ok(newItem);

        else return NotFound();
    }
}

Étape 3: Vérifiez votre Content-TypeetAccept

Vous devez vous assurer que vos en Content-Type- Accepttêtes et dans votre demande sont correctement définis. Dans votre cas (JSON), vous voudrez le configurer pour être application/json.

Si vous souhaitez que votre WebAPI réponde en tant que JSON par défaut, indépendamment de ce que l'en-tête de la demande spécifie, vous pouvez le faire de plusieurs manières .

Méthode 1 Comme indiqué dans l'article que j'ai recommandé plus tôt ( Formatage des données de réponse ), vous pouvez forcer un format particulier au niveau Contrôleur / Action. Personnellement, je n'aime pas cette approche ... mais ici, c'est par souci d'exhaustivité:

Forcer un format particulier Si vous souhaitez restreindre les formats de réponse pour une action spécifique, vous pouvez appliquer le filtre [Produit]. Le filtre [Produit] spécifie les formats de réponse pour une action spécifique (ou un contrôleur). Comme la plupart des filtres, cela peut être appliqué au niveau de l'action, du contrôleur ou de la portée globale.

[Produces("application/json")]
public class AuthorsController

Le [Produces]filtre forcera toutes les actions dans le AuthorsControllerà renvoyer des réponses au format JSON, même si d'autres formateurs ont été configurés pour l'application et que le client a fourni un en- Accepttête demandant un format disponible différent.

Voie 2 Ma méthode préférée est que WebAPI réponde à toutes les demandes avec le format demandé. Cependant, dans le cas où il n'accepte pas le format demandé, revenez à une valeur par défaut (c'est-à-dire JSON)

Tout d'abord, vous devrez l'enregistrer dans vos options (nous devons retravailler le comportement par défaut, comme indiqué précédemment)

options.RespectBrowserAcceptHeader = true; // false by default

Enfin, en réorganisant simplement la liste des formateurs qui ont été définis dans le générateur de services, l'hébergeur Web adoptera par défaut le formateur que vous positionnez en haut de la liste (c'est-à-dire la position 0).

Plus d'informations peuvent être trouvées dans cette entrée du blog sur le développement Web et les outils .NET

Vous disposez de méthodes prédéfinies pour les codes d'état les plus courants.

• Ok(result)retourne 200avec réponse
• CreatedAtRouterenvoie 201+ nouvelle URL de ressource
• NotFound Retour 404
• BadRequestretours 400etc.

Voir BaseController.cset Controller.cspour une liste de toutes les méthodes.

Mais si vous insistez vraiment, vous pouvez utiliser StatusCodepour définir un code personnalisé, mais vous ne devriez vraiment pas car cela rend le code moins lisible et vous devrez répéter le code pour définir les en-têtes (comme pour CreatedAtRoute).

public ActionResult IsAuthenticated()
{
    return StatusCode(200, "123");
}

Avec ASP.NET Core 2.0 , le moyen idéal de renvoyer un objet à partir de Web API(qui est unifié avec MVC et utilise la même classe de base Controller) est

public IActionResult Get()
{
    return new OkObjectResult(new Item { Id = 123, Name = "Hero" });
}

Remarquerez que

1. Il revient avec le 200 OKcode de statut (c'est un Oktype de ObjectResult)
2. Il négocie le contenu, c'est-à-dire qu'il retournera en fonction de l'en- Accepttête de la demande. Si Accept: application/xmlest envoyé dans la demande, il retournera comme XML. Si rien n'est envoyé, JSONc'est la valeur par défaut.

S'il doit être envoyé avec un code d'état spécifique , utilisez ObjectResultou à la StatusCodeplace. Les deux font la même chose et prennent en charge la négociation de contenu.

return new ObjectResult(new Item { Id = 123, Name = "Hero" }) { StatusCode = 200 };
return StatusCode( 200, new Item { Id = 123, Name = "Hero" });

ou encore plus fin avec ObjectResult:

 Microsoft.AspNetCore.Mvc.Formatters.MediaTypeCollection myContentTypes = new Microsoft.AspNetCore.Mvc.Formatters.MediaTypeCollection { System.Net.Mime.MediaTypeNames.Application.Json };
 String hardCodedJson = "{\"Id\":\"123\",\"DateOfRegistration\":\"2012-10-21T00:00:00+05:30\",\"Status\":0}";
 return new ObjectResult(hardCodedJson) { StatusCode = 200, ContentTypes = myContentTypes };

Si vous souhaitez spécifiquement revenir en tant que JSON , il existe deux façons

//GET http://example.com/api/test/asjson
[HttpGet("AsJson")]
public JsonResult GetAsJson()
{
    return Json(new Item { Id = 123, Name = "Hero" });
}

//GET http://example.com/api/test/withproduces
[HttpGet("WithProduces")]
[Produces("application/json")]
public Item GetWithProduces()
{
    return new Item { Id = 123, Name = "Hero" };
}

Remarquerez que

1. Les deux s'appliquent JSONde deux manières différentes.
2. Les deux ignorent la négociation de contenu.
3. La première méthode applique JSON avec un sérialiseur spécifique Json(object).
4. La deuxième méthode fait de même en utilisant l' Produces()attribut (qui est a ResultFilter) aveccontentType = application/json

En savoir plus sur eux dans la documentation officielle . En savoir plus sur les filtres ici .

La classe de modèle simple utilisée dans les exemples

public class Item
{
    public int Id { get; set; }
    public string Name { get; set; }
}

Le moyen le plus simple que j'ai trouvé est:

var result = new Item { Id = 123, Name = "Hero" };

return new JsonResult(result)
{
    StatusCode = StatusCodes.Status201Created // Status code here 
};

C'est ma solution la plus simple:

public IActionResult InfoTag()
{
    return Ok(new {name = "Fabio", age = 42, gender = "M"});
}

ou

public IActionResult InfoTag()
{
    return Json(new {name = "Fabio", age = 42, gender = "M"});
}

Au lieu d'utiliser les codes d'état 404/201 en utilisant enum

     public async Task<IActionResult> Login(string email, string password)
    {
        if (string.IsNullOrWhiteSpace(email) || string.IsNullOrWhiteSpace(password))
        { 
            return StatusCode((int)HttpStatusCode.BadRequest, Json("email or password is null")); 
        }

        var user = await _userManager.FindByEmailAsync(email);
        if (user == null)
        {
            return StatusCode((int)HttpStatusCode.BadRequest, Json("Invalid Login and/or password"));

        }
        var passwordSignInResult = await _signInManager.PasswordSignInAsync(user, password, isPersistent: true, lockoutOnFailure: false);
        if (!passwordSignInResult.Succeeded)
        {
            return StatusCode((int)HttpStatusCode.BadRequest, Json("Invalid Login and/or password"));
        }
        return StatusCode((int)HttpStatusCode.OK, Json("Sucess !!!"));
    }

Des réponses géniales que j'ai trouvées ici et j'ai également essayé cette déclaration de retour voir StatusCode(whatever code you wish)et cela a fonctionné !!!

return Ok(new {
                    Token = new JwtSecurityTokenHandler().WriteToken(token),
                    Expiration = token.ValidTo,
                    username = user.FullName,
                    StatusCode = StatusCode(200)
                });

Veuillez vous référer au code ci-dessous, vous pouvez gérer plusieurs codes d'état avec différents types JSON

public async Task<HttpResponseMessage> GetAsync()
{
    try
    {
        using (var entities = new DbEntities())
        {
            var resourceModelList = entities.Resources.Select(r=> new ResourceModel{Build Your Resource Model}).ToList();

            if (resourceModelList.Count == 0)
            {
                return this.Request.CreateResponse<string>(HttpStatusCode.NotFound, "No resources found.");
            }

            return this.Request.CreateResponse<List<ResourceModel>>(HttpStatusCode.OK, resourceModelList, "application/json");
        }
    }
    catch (Exception ex)
    {
        return this.Request.CreateResponse<string>(HttpStatusCode.InternalServerError, "Something went wrong.");
    }
}

Ce que je fais dans mes applications Asp Net Core Api, c'est de créer une classe qui s'étend d'ObjectResult et de fournir de nombreux constructeurs pour personnaliser le contenu et le code d'état. Ensuite, toutes mes actions de contrôleur utilisent l'un des costructeurs comme approprié. Vous pouvez jeter un oeil à mon implémentation à: https://github.com/melardev/AspNetCoreApiPaginatedCrud

et

https://github.com/melardev/ApiAspCoreEcommerce

voici à quoi ressemble la classe (allez dans mon dépôt pour le code complet):

public class StatusCodeAndDtoWrapper : ObjectResult
{



    public StatusCodeAndDtoWrapper(AppResponse dto, int statusCode = 200) : base(dto)
    {
        StatusCode = statusCode;
    }

    private StatusCodeAndDtoWrapper(AppResponse dto, int statusCode, string message) : base(dto)
    {
        StatusCode = statusCode;
        if (dto.FullMessages == null)
            dto.FullMessages = new List<string>(1);
        dto.FullMessages.Add(message);
    }

    private StatusCodeAndDtoWrapper(AppResponse dto, int statusCode, ICollection<string> messages) : base(dto)
    {
        StatusCode = statusCode;
        dto.FullMessages = messages;
    }
}

Notez la base (dto) que vous remplacez dto par votre objet et vous devriez être prêt à partir.

J'ai fait fonctionner ça. Mon gros problème était que mon json était une chaîne (dans ma base de données ... et non un type spécifique / connu).

Ok, j'ai enfin réussi à faire fonctionner ça.

////[Route("api/[controller]")]
////[ApiController]
////public class MyController: Microsoft.AspNetCore.Mvc.ControllerBase
////{
                    //// public IActionResult MyMethod(string myParam) {

                    string hardCodedJson = "{}";
                    int hardCodedStatusCode = 200;

                    Newtonsoft.Json.Linq.JObject job = Newtonsoft.Json.Linq.JObject.Parse(hardCodedJson);
                    /* "this" comes from your class being a subclass of Microsoft.AspNetCore.Mvc.ControllerBase */
                    Microsoft.AspNetCore.Mvc.ContentResult contRes = this.Content(job.ToString());
                    contRes.StatusCode = hardCodedStatusCode;

                    return contRes;

                    //// } ////end MyMethod
              //// } ////end class

Il se trouve que je suis sur asp.net core 3.1

#region Assembly Microsoft.AspNetCore.Mvc.Core, Version=3.1.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60
//C:\Program Files\dotnet\packs\Microsoft.AspNetCore.App.Ref\3.1.0\ref\netcoreapp3.1\Microsoft.AspNetCore.Mvc.Core.dll

J'ai eu l'indice d'ici :: https://www.jianshu.com/p/7b3e92c42b61