Como serializar um tipo anônimo de C # em uma string JSON?

Estou tentando usar o seguinte código para serializar um tipo anônimo para JSON:

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

No entanto, recebo a seguinte exceção quando isso é executado:

Digite '<> f__AnonymousType1`3 [System.Int32, System.Int32, System.Object []]' não pode ser serializado. Considere marcá-lo com o atributo DataContractAttribute e marcar todos os seus membros que você deseja serializar com o atributo DataMemberAttribute. Consulte a documentação do Microsoft .NET Framework para outros tipos suportados.

Não posso aplicar atributos a um tipo anônimo (tanto quanto eu sei). Existe outra maneira de fazer essa serialização ou estou faltando alguma coisa?

Experimente o JavaScriptSerializer em vez do DataContractJsonSerializer

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

Como outros já mencionaram, o Newtonsoft JSON.NET é uma boa opção. Aqui está um exemplo específico para serialização JSON simples:

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

Eu achei uma biblioteca muito flexível e versátil.

Você pode experimentar meu ServiceStack JsonSerializer , é o serializador .NET JSON mais rápido no momento. Ele suporta serialização de DataContract, qualquer tipo de POCO, interfaces, objetos com ligação tardia, incluindo tipos anônimos, etc.

Exemplo básico

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

Nota: Use o Microsofts JavaScriptSerializer apenas se o desempenho não for importante para você, pois tive que deixá-lo fora dos meus benchmarks, pois é até 40x-100x mais lento que os outros serializadores JSON.

Observe que isso é de 2008. Hoje eu argumentaria que o serializador deve ser incorporado e que você provavelmente pode usar os atributos swagger + para informar os consumidores sobre seu endpoint e retornar dados.

Eu argumentaria que você não deveria serializar um tipo anônimo . Eu conheço a tentação aqui; você deseja gerar rapidamente alguns tipos descartáveis ​​que serão usados ​​em um ambiente de tipo vagamente conhecido como Javascript no navegador. Ainda assim, eu criaria um tipo real e o decoraria como serializável. Então você pode digitar fortemente seus métodos da web. Embora isso não importe um pingo para Javascript, ele adiciona alguma autodocumentação ao método. Qualquer programador razoavelmente experiente poderá olhar para a assinatura da função e dizer: "Oh, esse é o tipo Foo! Eu sei como isso deve parecer no JSON".

Dito isto, você pode tentar o JSON.Net para fazer a serialização. Eu não tenho idéia se vai funcionar

A maneira mais rápida que encontrei foi esta:

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

Espaço para nome: System.Web.Script.Serialization.JavaScriptSerializer

Você poderia usar o Newtonsoft.Json.

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

Supondo que você esteja usando isso para um serviço da Web, basta aplicar o seguinte atributo à classe:

[System.Web.Script.Services.ScriptService]

Em seguida, o seguinte atributo para cada método que deve retornar o Json:

[ScriptMethod(ResponseFormat = ResponseFormat.Json)]

E defina o tipo de retorno para os métodos como "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);
        }
    }
}