Comment renvoyer du JSON propre à partir d'un service WCF?

J'essaie de renvoyer du JSON à partir d'un service WCF. Ce service renvoie simplement du contenu de ma base de données. Je peux obtenir les données. Cependant, je suis préoccupé par le format de mon JSON. Actuellement, le JSON qui est retourné est formaté comme ceci:

{"d":"[{\"Age\":35,\"FirstName\":\"Peyton\",\"LastName\":\"Manning\"},{\"Age\":31,\"FirstName\":\"Drew\",\"LastName\":\"Brees\"},{\"Age\":29,\"FirstName\":\"Tony\",\"LastName\":\"Romo\"}]"} 

En réalité, j'aimerais que mon JSON soit formaté le plus proprement possible. Je crois (je peux me tromper) que la même collection de résultats, représentée en JSON propre, devrait ressembler à ceci:

[{
  "Age": 35,
  "FirstName": "Peyton",
  "LastName": "Manning"
}, {
  "Age": 31,
  "FirstName": "Drew",
  "LastName": "Brees"
}, {
  "Age": 29,
  "FirstName": "Tony",
  "LastName": "Romo"
}]

Je n'ai aucune idée d'où vient le «d». Je ne sais pas non plus pourquoi les caractères d'échappement sont insérés. Mon entité ressemble à ceci:

[DataContract]
public class Person
{
    [DataMember]
    public string FirstName { get; set; }

    [DataMember]
    public string LastName { get; set; }

    [DataMember]
    public int Age { get; set; }

    public Person(string firstName, string lastName, int age)
    {
        this.FirstName = firstName;
        this.LastName = lastName;
        this.Age = age;
    }
}

Le service chargé de renvoyer le contenu est défini comme:

[ServiceContract(Namespace = "")]
[AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
public class TestService
{
    [OperationContract]
    [WebGet(ResponseFormat = WebMessageFormat.Json)]
    public string GetResults()
    {
        List<Person> results = new List<Person>();
        results.Add(new Person("Peyton", "Manning", 35));
        results.Add(new Person("Drew", "Brees", 31));
        results.Add(new Person("Tony", "Romo", 29));

        // Serialize the results as JSON
        DataContractJsonSerializer serializer = new DataContractJsonSerializer(results.GetType());
        MemoryStream memoryStream = new MemoryStream();
        serializer.WriteObject(memoryStream, results);

        // Return the results serialized as JSON
        string json = Encoding.Default.GetString(memoryStream.ToArray());
        return json;
    }
}

Comment renvoyer un JSON «propre» à partir d'un service WCF? Je vous remercie!

Modifiez le type de retour de vos GetResults List<Person>.
Éliminez le code que vous utilisez pour sérialiser la liste en une chaîne json - WCF le fait automatiquement pour vous.

En utilisant votre définition de la classe Person, ce code fonctionne pour moi:

public List<Person> GetPlayers()
{
    List<Person> players = new List<Person>();
    players.Add(new  Person { FirstName="Peyton", LastName="Manning", Age=35 } );
    players.Add(new  Person { FirstName="Drew", LastName="Brees", Age=31 } );
    players.Add(new  Person { FirstName="Brett", LastName="Favre", Age=58 } );

    return players;
}

résultats:

[{"Age":35,"FirstName":"Peyton","LastName":"Manning"},  
 {"Age":31,"FirstName":"Drew","LastName":"Brees"},  
 {"Age":58,"FirstName":"Brett","LastName":"Favre"}]

(Tout sur une seule ligne)

J'ai également utilisé cet attribut sur la méthode:

[WebInvoke(Method = "GET",
           RequestFormat = WebMessageFormat.Json,
           ResponseFormat = WebMessageFormat.Json,
           UriTemplate = "players")]

WebInvoke avec Method = "GET" est le même que WebGet, mais comme certaines de mes méthodes sont POST, j'utilise tous WebInvoke pour la cohérence.

L'UriTemplate définit l'URL à laquelle la méthode est disponible. Je peux donc faire un GET http://myserver/myvdir/JsonService.svc/playerset ça fonctionne.

Consultez également IIRF ou un autre réécriveur d'URL pour vous débarrasser du .svc dans l'URI.

Si vous voulez un json sympa sans attributs de codage en dur dans vos classes de service,

utiliser <webHttp defaultOutgoingResponseFormat="Json"/>dans votre configuration de comportement

Ceci est accompli dans web.config pour votre service Web. Définissez le bindingBehavior sur <webHttp> et vous verrez le JSON propre. Le "[d]" supplémentaire est défini par le comportement par défaut que vous devez remplacer.

Voir en plus ce blogpost: http://blog.clauskonrad.net/2010/11/how-to-expose-json-endpoint-from-wcf.html

J'ai rencontré le même problème et l'ai résolu en modifiant la valeur d'attribut BodyStyle en "WebMessageBodyStyle.Bare":

[OperationContract]
[WebGet(BodyStyle = WebMessageBodyStyle.Bare, RequestFormat = WebMessageFormat.Json,
        ResponseFormat = WebMessageFormat.Json, UriTemplate = "GetProjectWithGeocodings/{projectId}")]
GeoCod_Project GetProjectWithGeocodings(string projectId);

L'objet retourné ne sera plus encapsulé.

Lorsque vous utilisez la méthode GET, le contrat doit être le suivant.

[WebGet(UriTemplate = "/", BodyStyle = WebMessageBodyStyle.Bare, ResponseFormat = WebMessageFormat.Json)]
List<User> Get();

avec cela, nous avons un json sans le paramètre de démarrage

Aldo Flores @alduar http://alduar.blogspot.com

Dans votre IServece.cs, ajoutez la balise suivante: BodyStyle = WebMessageBodyStyle.Bare

 [WebInvoke(Method = "GET", ResponseFormat = WebMessageFormat.Json, BodyStyle = WebMessageBodyStyle.Bare, UriTemplate = "Getperson/{id}")]

    List<personClass> Getperson(string id);