¿Cómo serializo un tipo anónimo C # en una cadena JSON?

Estoy intentando usar el siguiente código para serializar un tipo anónimo a JSON:

var serializer = new DataContractJsonSerializer(thing.GetType());
var ms = new MemoryStream();
serializer.WriteObject(ms, thing);
var json = Encoding.Default.GetString(ms.ToArray()); 

Sin embargo, obtengo la siguiente excepción cuando se ejecuta esto:

El tipo '<> f__AnonymousType1`3 [System.Int32, System.Int32, System.Object []]' no se puede serializar. Considere marcarlo con el atributo DataContractAttribute y marcar todos los miembros que desea serializar con el atributo DataMemberAttribute. Consulte la documentación de Microsoft .NET Framework para otros tipos compatibles.

No puedo aplicar atributos a un tipo anónimo (que yo sepa). ¿Hay otra forma de hacer esta serialización o me falta algo?

Pruebe el JavaScriptSerializer en lugar del DataContractJsonSerializer

JavaScriptSerializer serializer = new JavaScriptSerializer();
var output = serializer.Serialize(your_anon_object);

Como otros han mencionado, Newtonsoft JSON.NET es una buena opción. Aquí hay un ejemplo específico para la serialización JSON simple:

return JsonConvert.SerializeObject(
    new
    {
       DataElement1,
       SomethingElse
    });

He encontrado que es una biblioteca muy flexible y versátil.

Puede probar mi ServiceStack JsonSerializer , es el serializador .NET JSON más rápido en este momento. Admite la serialización de DataContract, cualquier tipo de POCO, interfaces, objetos enlazados tarde, incluidos los tipos anónimos, etc.

Ejemplo básico

var customer = new Customer { Name="Joe Bloggs", Age=31 };
var json = customer.ToJson();
var fromJson = json.FromJson<Customer>(); 

Nota: Solo use Microsofts JavaScriptSerializer si el rendimiento no es importante para usted, ya que he tenido que dejarlo fuera de mis puntos de referencia, ya que es hasta 40x-100x más lento que los otros serializadores JSON.

Tenga en cuenta que esto es de 2008. Hoy diría que el serializador debería estar integrado y que probablemente pueda usar los atributos swagger + para informar a los consumidores sobre su punto final y los datos de retorno.

Yo diría que no deberías estar serializando un tipo anónimo . Sé la tentación aquí; desea generar rápidamente algunos tipos desechables que solo se utilizarán en un entorno de tipo flexible, también conocido como Javascript, en el navegador. Aún así, crearía un tipo real y lo decoraría como serializable. Entonces puede escribir fuertemente sus métodos web. Si bien esto no importa un ápice para Javascript, sí agrega algo de autodocumentación al método. Cualquier programador con experiencia razonable podrá mirar la firma de la función y decir: "¡Oh, este es el tipo Foo! Sé cómo debería verse en JSON".

Dicho esto, puede intentar JSON.Net para hacer la serialización. No tengo idea si funcionará

La forma más rápida que encontré fue esta:

var obj = new {Id = thing.Id, Name = thing.Name, Age = 30};
JavaScriptSerializer serializer = new JavaScriptSerializer();
string json = serializer.Serialize(obj);

Espacio de nombres: System.Web.Script.Serialization.JavaScriptSerializer

Podrías usar Newtonsoft.Json.

var warningJSON = JsonConvert.SerializeObject(new {
                warningMessage = "You have been warned..."
            });

Suponiendo que está utilizando esto para un servicio web, puede aplicar el siguiente atributo a la clase:

[System.Web.Script.Services.ScriptService]

Luego, el siguiente atributo para cada método que debería devolver Json:

[ScriptMethod(ResponseFormat = ResponseFormat.Json)]

Y establezca el tipo de retorno para que los métodos sean "objeto"

public static class JsonSerializer
{
    public static string Serialize<T>(this T data)
    {
        try
        {
            DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(T));
            var stream = new MemoryStream();
            serializer.WriteObject(stream, data);
            string jsonData = Encoding.UTF8.GetString(stream.ToArray(), 0, (int)stream.Length);
            stream.Close();
            return jsonData;
        }
        catch
        {
            return "";
        }
    }
    public static T Deserialize<T>(this string jsonData)
    {
        try
        {
            DataContractJsonSerializer slzr = new DataContractJsonSerializer(typeof(T));
            var stream = new MemoryStream(Encoding.UTF8.GetBytes(jsonData));
            T data = (T)slzr.ReadObject(stream);
            stream.Close();
            return data;
        }
        catch
        {
            return default(T);
        }
    }
}