Zurück camelCased JSON von Web-API

Ich versuche zurück zu kehren camel-cased JSON aus einer ASP.Net Web-API-2-controller. Ich habe eine neue web-Anwendung mit nur ASP.Net MVC-und Web API-bits in ihm. Ich entführte die ValuesController etwa so:

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äuft das im IE bekomme ich folgende Ergebnisse:

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

Folgenden K. Scott Allen ' s post auf das Thema, ich habe Folgendes in der Register-Methode in der WebApiConfig.cs-Datei:

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

Aber ich bekomme immer noch die gleiche, capitilization in meine Ergebnisse. Gibt es etwas, was ich bin fehlt? Ich habe versucht, ein paar andere Ansätze, aber nichts funktioniert noch.

Ist das so eine offensichtliche Antwort ist, dass die Leute denken, ich sollte das herausfinden mich? Ich habe nicht knabbern noch. Ich startete mit einem neuen Projekt und war immer noch nicht in der Lage, diese zu arbeiten.
Ich denke immer noch, Antwort von einem anderen post ist die am meisten anständige: stackoverflow.com/a/22130487/1915401

InformationsquelleAutor beaudetious | 2014-10-20

15

In Ihrem WebApiConfig.cs stellen Sie sicher, dass Sie diese zwei Zeilen
```
//Serialize with camelCase formatter for JSON.
var jsonFormatter = config.Formatters.OfType<JsonMediaTypeFormatter>().First();
jsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
```
stellen Sie sicher, dass Sie installiert Newtonsoft Bibliothek.

Hoffe, das hilft.

Nope, schon versucht und Newtonsoft bereits installiert ist. 🙁
Ich hatte ein ähnliches Problem, Sie benötigen, um das formatter form der httpconfig für owin nicht GlobalConfiguration
könnte Ihnen zeigen, einige code, wie hast du den formatter von ht httpconfig von owin?
Ich holte das jsonFormatter diese Weise: var jsonFormatter = GlobalConfiguration.Configuration.Formatters.JsonFormatter;.

InformationsquelleAutor Omar.Alani
9

Sieht aus wie das Haupt-Problem war, dass ich mit dem JsonResult Verknüpfung Json () - Aktion-Ergebnis-Methode:
```
public IHttpActionResult Get([FromUri] string domain, [FromUri] string username)
{
    var authInfo = BLL.GetAuthenticationInfo(domain, username);
    return Json(authInfo);
}
```
Er hatte offenbar die volle Kontrolle über die Formatierung der Ergebnisse. Wenn ich wechseln auf die Rückkehr HttpResponseMessage dann funktioniert es wie erwartet:
```
public HttpResponseMessage Get([FromUri] string domain, [FromUri] string username)
{
    var authInfo = BLL.GetAuthenticationInfo(domain, username);
    return Request.CreateResponse(HttpStatusCode.OK, authInfo);
}
```
Habe ich am Ende mit der code-block in der Datei WebApiConfig als Omar.Alani vorgeschlagen (im Gegensatz zu den viel längeren code hatte ich in meinem OP). Aber die wahre Schuldige wurde das JsonResult action-Methode. Ich hoffe, dies hilft jemand anderes aus.

Ich weiß, das ist eine eher späte Kommentar, aber ich fand, dass mit Ok(authInfo) gilt das Formatierungsprogramm in der Erwägung, dass mit Json(authInfo) nicht. Die Ok Methode anwenden würde, die entsprechenden formatter-auf der Grundlage der Accept header. Sie könnte dann noch zurück IHttpActionResult.

InformationsquelleAutor beaudetious

Müssen Sie OK() statt Json() in den Aktion Methoden.

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

InformationsquelleAutor Jalal

War ich mit Owin und DI (AutoFac in meinem Fall) so, dass wirft eine weitere Schraubenschlüssel in den Werken. Mein Start.cs enthält:

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

Dann in meinem WebApiConfig.cs habe ich noch:

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

InformationsquelleAutor Jester

In der Register-Methode WebApiConfig, fügen Sie diese

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

Vollständige Code der 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();

        }
    }

Stellen Sie sicher, dass Sie installiert haben die neueste version von Json.Net/Newtonsoft.Json Installiert und die API-Aktion-Methode gibt Daten in folgender Weise:

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

InformationsquelleAutor Jay Shah

Versuchen, diese auch.

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

InformationsquelleAutor Khademul Basher

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.