¿Cómo devuelvo JSON limpio de un servicio WCF?

Estoy tratando de devolver algo de JSON de un servicio WCF. Este servicio simplemente devuelve parte del contenido de mi base de datos. Puedo obtener los datos. Sin embargo, me preocupa el formato de mi JSON. Actualmente, el JSON que se devuelve tiene el siguiente formato:

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

En realidad, me gustaría que mi JSON tenga el formato más limpio posible. Creo (puedo ser incorrecto) que la misma colección de resultados, representada en JSON limpio, debería verse así:

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

No tengo idea de dónde viene la "d". Tampoco tengo idea de por qué se están insertando los caracteres de escape. Mi entidad tiene el siguiente aspecto:

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

El servicio responsable de devolver el contenido se define como:

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

¿Cómo devuelvo JSON "limpio" de un servicio WCF? ¡Gracias!

Cambia el tipo de retorno de tus GetResults para que sea List<Person>.
Elimine el código que usa para serializar la Lista en una cadena json; WCF lo hace automáticamente.

Usando su definición para la clase Persona, este código funciona para mí:

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

resultados:

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

(Todo en una línea)

También usé este atributo en el método:

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

WebInvoke with Method = "GET" es lo mismo que WebGet, pero como algunos de mis métodos son POST, utilizo todo WebInvoke para mantener la coherencia.

UriTemplate establece la URL en la que está disponible el método. Entonces puedo hacer un GET http://myserver/myvdir/JsonService.svc/playersy simplemente funciona.

También revise IIRF u otra reescritura de URL para deshacerse del .svc en el URI.

Si desea un buen JSON sin atributos de codificación en sus clases de servicio,

utilizar <webHttp defaultOutgoingResponseFormat="Json"/>en su configuración de comportamiento

Esto se logra en web.config para su servicio web. Establezca el enlaceBehavior en <webHttp> y verá el JSON limpio. El "[d]" adicional se establece por el comportamiento predeterminado que debe sobrescribir.

Vea además este blog: http://blog.clauskonrad.net/2010/11/how-to-expose-json-endpoint-from-wcf.html

Me enfrenté al mismo problema y lo resolví cambiando el valor de atributo BodyStyle a "WebMessageBodyStyle.Bare":

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

El objeto devuelto ya no se envolverá.

Cuando utiliza el método GET, el contrato debe ser este.

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

con esto tenemos un json sin el parámetro de arranque

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

En su IServece.cs agregue la siguiente etiqueta: BodyStyle = WebMessageBodyStyle.Bare

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

    List<personClass> Getperson(string id);