Já há algum tempo, temos visto surgir vários projetos que possuem o JavaScript como linguagem de programação principal, e está tem sido uma tendência com o desenvolvimentos de browsers mais eficientes e confiáveis. Dessa forma, cada vez mais as linguagens de servidor (php, ruby, phyton, .net e outras) tem se preocupado em fornecer mecanismos para interfaciar a comunicação do código gerenciado pelo servidor com as APIs JavaScript. É tanto que todas as principais linguagens já possuem suporte nativo ao padrão JSON. No framework .Net, por exemplo, as implementações nativas do JSON estão disponíveis no name space “System.Web.Script.Serialization”.

Esta biblioteca nativa é muito simples de usar. Veja um exemplo:

Vamos começar definindo uma classe qualquer:

// classe comum
public class Carro
{
    public int ano { get; set; }
    public Marca marca { get; set; }
    public string cor { get; set; }
    public DateTime? datavenda { get; set; }
}

Para enriquecer o exemplo, criaremos também um enum.

// enum usado na classe Carro
public enum Marca
{
    Wolksvagem,
    Ford,
    Fiat,
    Chevrolet
}

Agora basta instanciar um objeto, definir os valores e mandar serializar.

// instanciamos o objeto e definimos
// valores para as propriedades
var fusca = new Carro();
fusca.ano = 1953;
fusca.cor = "preto";
fusca.marca = Marca.Wolksvagem;

// criamos uma instancia do 'serializer'
// e mandamos ver!
var jss = new JavaScriptSerializer();
jss.Serialize(fusca);

Nosso output é exatamente igual a este:

// string gerada a partir do objeto fusca!
{"ano":1953,"marca":0,"cor":"preto","datavenda":null}

Talvez por essa simplicidade, a classe “JavaScriptSerializer” tenha ficado um pouco rígida… permitindo poucas configurações sobre a engenharia de output da serialização dos objetos. De qualquer forma, funciona pefeitamente.

Agora vamos analisar atentamente o output gerado e pensar sobre o que pode ser refinado. Basicamente temos dois pontos chave que precisamos ‘atacar’ para obter uma estrutura JSON enxuta e mais semântica:

  • Renderizar os Enums como texto
  • Remover as propriedades nulas da serialização, pois é rendundante

É neste neste ponto que precisamos aderir a uma dessas iniciativas da comunidade: Json.NET, que é uma daquelas bibliotecas que você fica se perguntando: “por que isso não faz parte do framework?”. Este framework extende e muito nossas possibilidades para lidar com o JSON, bastando apenas configurar alguns atributos. Faça o download desta biblioteca clicando aqui. Referencie as dll´s no seu projeto e estaremos prontos para seguir em frente e melhorar nosso output de serialização.

O primeiro problema que vamos solucionar é o do Enum. Para isso, vamos adicionar na propriedade “marca” o atributo “JsonConverter” da seguinte forma:

[JsonConverter(typeof(StringEnumConverter))]
public Marca marca { get; set; }

E utilizar a classe de serialização do Json.Net:

// Serialização do Json.Net
JsonConvert.SerializeObject(fusca);

Agora nosso output fica deste jeito:

// repare que o enum foi serializado com o valor texto
{"ano":1953,"marca":"Wolksvagem","cor":"preto","datavenda":null}

Ficou bem melhor, mas ainda temos que eliminar a propriedade nula. Para isso, precisamos apenas passar para a classe JsonConverter como parâmetro do método SerializeObject um objeto JsonSerializerSettings. Neste objeto nós podemos definir a instrução para que o Json.Net não serialize as propriedades que possuam valor null. Fica assim:

var output = JsonConvert.SerializeObject(fusca,
                                         Formatting.None,
                                         new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore }
                                         );

Veja como fica nossa serialização:

// sem o null
{"ano":1953,"marca":"Wolksvagem","cor":"preto"}

Como podem ver, agora nosso output possue apenas as propriedades relevantes, além de ser mais semântico. Existem muitas outras configurações no Json.Net que o tornam a melhor opção para se trabalhar com Json em projetos .Net. Até a próxima.