Renvoyer le JSON camelCased à partir de l'API Web

Je suis en train de retourner camelcase JSON à partir d'un ASP.Net Web API 2 contrôleur. J'ai créé une nouvelle application web avec juste la ASP.Net MVC et Web API bits. J'ai détourné la ValuesController comme suit:

public class ValuesController : ApiController
{
    public class Thing
    {
        public int Id { get; set; }
        public string FirstName { get; set; }
        public string ISBN { get; set; }
        public DateTime ReleaseDate { get; set; }

        public string[] Tags { get; set; }
    }

    //GET api/values
    public IHttpActionResult Get()
    {
        var thing = new Thing
        {
            Id = 123,
            FirstName = "Brian",
            ISBN = "ABC213", 
            ReleaseDate = DateTime.Now,
            Tags = new string[] { "A", "B", "C", "D"}
        };

        return Json(thing);
    }
}

L'exécution de ce sous IE, j'obtiens les résultats suivants:

{"Id":123,"FirstName":"Brian","ISBN":"ABC213","ReleaseDate":"2014-10-20T16:26:33.6810554-04:00","Tags":["A","B","C","D"]}

Suivantes K. Scott Allen post sur le sujet, j'ai ajouté ce qui suit à la méthode Register dans le WebApiConfig.cs fichier:

public static void Register(HttpConfiguration config)
    {
        //Web API configuration and services
        var formatters = GlobalConfiguration.Configuration.Formatters;
        var jsonFormatter = formatters.JsonFormatter;
        var settings = jsonFormatter.SerializerSettings;
        settings.Formatting = Formatting.Indented;
        settings.ContractResolver = new CamelCasePropertyNamesContractResolver();

        //Web API routes
        config.MapHttpAttributeRoutes();

        config.Routes.MapHttpRoute(
            name: "DefaultApi",
            routeTemplate: "api/{controller}/{id}",
            defaults: new { id = RouteParameter.Optional }
        );
    }

Cependant, j'obtiens toujours la même, capitilization dans mes résultats. Est-il quelque chose que je suis absent? J'ai essayé quelques autres approches, mais rien ne fonctionne encore.

source d'informationauteur beaudetious

Dans votre WebApiConfig.cs assurez-vous d'ajouter ces deux lignes

//Serialize with camelCase formatter for JSON.
var jsonFormatter = config.Formatters.OfType<JsonMediaTypeFormatter>().First();
jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();

assurez-vous que vous avez installé Newtonsoft bibliothèque.

Espère que ça aide.

9

Ressemble le principal problème est que j'ai été en utilisant le JsonResult raccourci Json() action résultat de la méthode:
```
public IHttpActionResult Get([FromUri] string domain, [FromUri] string username)
{
    var authInfo = BLL.GetAuthenticationInfo(domain, username);
    return Json(authInfo);
}
```
Apparemment, il avait le plein contrôle de mise en forme les résultats. Si je commutateur à retour HttpResponseMessage alors qu'il fonctionne comme prévu:
```
public HttpResponseMessage Get([FromUri] string domain, [FromUri] string username)
{
    var authInfo = BLL.GetAuthenticationInfo(domain, username);
    return Request.CreateResponse(HttpStatusCode.OK, authInfo);
}
```
J'ai fini en utilisant le bloc de code dans le WebApiConfig fichier comme Omar.Alani suggéré (opposé à beaucoup plus de code que j'avais dans mon OP). Mais le vrai coupable était le JsonResult méthode d'action. J'espère que cela aide quelqu'un d'autre.

Vous devez utiliser OK() au lieu de Json() dans vos méthodes d'action.

//GET api/values
public IHttpActionResult Get()
{
    var thing = new Thing
    {
        Id = 123,
        FirstName = "Brian",
        ISBN = "ABC213", 
        ReleaseDate = DateTime.Now,
        Tags = new string[] { "A", "B", "C", "D"}
    };

    //Use 'Ok()' instead of 'Json()'
    return Ok(thing);
}

J'ai été en utilisant Owin et DI (AutoFac dans mon cas), de sorte que jette une autre clé dans les œuvres. Mon Démarrage.cs contient:

var apiconfig = new HttpConfiguration
{
    DependencyResolver = new AutofacWebApiDependencyResolver(container)
};
WebApiConfig.Register(apiconfig);

Ensuite dans mon WebApiConfig.cs j'ai:

using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Web.Http;
using Microsoft.Owin.Security.OAuth;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;

public static void Register(HttpConfiguration config)
    {
        //Web API routes
        config.MapHttpAttributeRoutes();

        // Setup json.Net for pretty output, easy human reading AND this formatter
        // does that ONLY for browsers - best of both worlds: useful AND efficient/performant!
        config.Formatters.Clear();
        config.Formatters.Add(new BrowserJsonFormatter());
    }

    public class BrowserJsonFormatter : JsonMediaTypeFormatter
    {
        // Since most browser defaults do not include an "accept type" specifying json, this provides a work around
        // Default to json over XML - any app that wants XML can ask specifically for it  ;)
        public BrowserJsonFormatter()
        {
            SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
            SerializerSettings.Formatting = Formatting.Indented;
            SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
            //Convert all dates to UTC
            SerializerSettings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
        }

        // Change the return type to json, as most browsers will format correctly with type as text/html
        public override void SetDefaultContentHeaders(Type type, HttpContentHeaders headers, MediaTypeHeaderValue mediaType)
        {
            base.SetDefaultContentHeaders(type, headers, mediaType);
            headers.ContentType = new MediaTypeHeaderValue("application/json");
        }
    }

Dans le Registre de la méthode de WebApiConfig, ajouter cette

config.Des formateurs.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();

Complète du Code de WebApiConfig:

    public static class WebApiConfig
    {
        public static void Register(HttpConfiguration config)
        {
            //Web API configuration and services

            //Web API routes
            config.MapHttpAttributeRoutes();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();

        }
    }

Assurez-vous d'avoir installé la dernière version de Json.Net/Newtonsoft.Json Installé et votre Action API Méthode renvoie les données de la manière suivante:

    [HttpGet]
    public HttpResponseMessage List()
    {
        try
        {
            var result = /*write code to fetch your result*/;
            return Request.CreateResponse(HttpStatusCode.OK, result);
        }
        catch (Exception ex)
        {
            return Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message);
        }
    }

Essayer aussi.

[AllowAnonymous]
[HttpGet()]
public HttpResponseMessage GetAllItems(int moduleId)
{
            HttpConfiguration config = new HttpConfiguration();
            config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
            config.Formatters.JsonFormatter.UseDataContractJsonSerializer = false;

            try
            {
                List<ItemInfo> itemList = GetItemsFromDatabase(moduleId);
                return Request.CreateResponse(HttpStatusCode.OK, itemList, config);
            }
            catch (System.Exception ex)
            {
                return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message);
            }
}

Vous devez vous connecter pour publier un commentaire.