14 12 2016

O formato JSON (JavaScript Object Notation) é atualmente o formato mais utilizado para troca de informações nas comunicações entre aplicações e APIs. Antigamente tínhamos uma predominância do XML para esse tipo de operação, mas o JSON acabou dominando a cena já faz um bom tempo.

Com essa popularização do JSON, não é raro termos que fazer a serialização ou desserialização de objetos nesse formato dentro das nossas aplicações. No .NET Framework temos nativamente a classe DataContractJsonSerializer, que implementa justamente essa funcionalidade. Porém, existem diversas outras bibliotecas que também implementam a serialização de JSON com C# e VB.NET.

No artigo de hoje eu vou mostrar um exemplo de serialização e desserialização de dados JSON utilizando a classe DataContractJsonSerializer e as bibliotecas Json.NET (Newtonsoft) e Jil. Será que tem muita diferença? Vamos conferir?

Criando uma estrutura de exemplo

Para vermos como funciona a serialização e desserialização de dados em JSON, primeiramente temos que criar uma estrutura de dados. Uma das coisas que mais me irrita em artigos que demonstram esse tipo de funcionalidade é que, na maioria das vezes, o autor utiliza uma estrutura de dados muito simples. Uma classezinha com algumas propriedades e pronto. Esse é o exemplo que você encontra aos montes por aí.

Não me leve a mal, eu sou 100% a favor de utilizarmos exemplos simples em artigos técnicos. Porém, muitas vezes alguns autores levam isso ao extremo. Nesse cenário, por exemplo, é importante entendermos como a serialização funciona quando temos classes relacionadas. Outro problema interessante de estudarmos é a utilização de propriedades do tipo DateTime, que normalmente costumam causar problemas na serialização e desserialização de objetos.

Pensando nisso, para esse artigo eu resolvi criar uma estrutura de dados um pouco mais complexa. Entretanto, ao mesmo tempo ela é simples o suficiente para conseguirmos entender o que está sendo feito. A estrutura lida com Pedidos e Itens de Pedido, além de algumas informações de “lookup” (Vendedor, Produto e Categoria do Produto). Veja só o diagrama abaixo:

E aí, conseguiu entender? Acho que não é tão difícil assim, não é mesmo? Além dos relacionamentos entre as classes, nós temos também campos do tipo DateTime, para verificarmos qual é o comportamento de cada biblioteca na hora de serializar e desserializar as informações desse tipo.

Agora que já temos a nossa estrutura definida, vamos criar um projeto do tipo “Console Application” e vamos adicionar cada uma das classes no projeto:

    // C#
    public class CategoriaProduto
    {
        public int CategoriaProdutoId { get; set; }
        public string Descricao { get; set; }
    }
    public class Produto
    {
        public int ProdutoId { get; set; }
        public CategoriaProduto CategoriaProduto { get; set; }
        public string Descricao { get; set; }
        public decimal Preco { get; set; }
    }
    public class Vendedor
    {
        public int VendedorId { get; set; }
        public string Nome { get; set; }
        public DateTime DataNascimento { get; set; }
    }
    public class Pedido
    {
        public int PedidoId { get; set; }
        public DateTime DataPedido { get; set; }
        public Vendedor Vendedor { get; set; }
        public IEnumerable<ItemPedido> ItensPedido { get; set; }
    }
    public class ItemPedido
    {
        public int ItemPedidoId { get; set; }
        public Pedido Pedido { get; set; }
        public Produto Produto { get; set; }
        public decimal Quantidade { get; set; }
        public decimal Valor { get; set; }
    }

' VB.NET
Public Class CategoriaProduto
    Public Property CategoriaProdutoId As Integer
    Public Property Descricao As String
End Class
Public Class Produto
    Public Property ProdutoId As Integer
    Public Property CategoriaProduto As CategoriaProduto
    Public Property Descricao As String
    Public Property Preco As Decimal
End Class
Public Class Vendedor
    Public Property VendedorId As Integer
    Public Property Nome As String
    Public Property DataNascimento As DateTime
End Class
Public Class Pedido
    Public Property PedidoId As Integer
    Public Property DataPedido As DateTime
    Public Property Vendedor As Vendedor
    Public Property ItensPedido As IEnumerable(Of ItemPedido)
End Class
Public Class ItemPedido
    Public Property ItemPedidoId As Integer
    Public Property Pedido As Pedido
    Public Property Produto As Produto
    Public Property Quantidade As Decimal
    Public Property Valor As Decimal
End Class

Em seguida, vamos até a classe “Program” (ou “Module1” no VB.NET) para adicionarmos um método que fará a criação de uma lista de Pedidos com dados fictícios:

        // C#
        private static List<Pedido> CriarListaDePedidos()
        {
            var lista = new List<Pedido>();

            var categoria1 = new CategoriaProduto() { CategoriaProdutoId = 1, Descricao = "Categoria 1" };
            var categoria2 = new CategoriaProduto() { CategoriaProdutoId = 1, Descricao = "Categoria 1" };
            var produto1 = new Produto() { ProdutoId = 1, CategoriaProduto = categoria1, Descricao = "Produto 1", Preco = 1.5m };
            var produto2 = new Produto() { ProdutoId = 2, CategoriaProduto = categoria2, Descricao = "Produto 2", Preco = 2.5m };
            var vendedor1 = new Vendedor() { VendedorId = 1, Nome = "Vendedor 1", DataNascimento = new DateTime(2016, 11, 16) };
            var vendedor2 = new Vendedor() { VendedorId = 2, Nome = "Vendedor 2", DataNascimento = new DateTime(2016, 11, 17) };
            var pedido1 = new Pedido() { PedidoId = 1, DataPedido = DateTime.Now, Vendedor = vendedor1 };
            var pedido2 = new Pedido() { PedidoId = 2, DataPedido = DateTime.Now, Vendedor = vendedor2 };
            var itemPedido1 = new ItemPedido() { ItemPedidoId = 1, Pedido = pedido1, Produto = produto1, Quantidade = 1, Valor = 1.5m };
            var itemPedido2 = new ItemPedido() { ItemPedidoId = 2, Pedido = pedido1, Produto = produto2, Quantidade = 2, Valor = 5 };
            var itemPedido3 = new ItemPedido() { ItemPedidoId = 3, Pedido = pedido2, Produto = produto1, Quantidade = 3, Valor = 4.5m };
            var itemPedido4 = new ItemPedido() { ItemPedidoId = 4, Pedido = pedido2, Produto = produto2, Quantidade = 4, Valor = 10 };
            pedido1.ItensPedido = new[] { itemPedido1, itemPedido2 };
            pedido2.ItensPedido = new[] { itemPedido3, itemPedido4 };

            lista.Add(pedido1);
            lista.Add(pedido2);

            return lista;
        }

    ' VB.NET
    Private Function CriarListaDePedidos() As List(Of Pedido)
        Dim Lista = New List(Of Pedido)

        Dim Categoria1 = New CategoriaProduto() With {.CategoriaProdutoId = 1, .Descricao = "Categoria 1"}
        Dim Categoria2 = New CategoriaProduto() With {.CategoriaProdutoId = 1, .Descricao = "Categoria 1"}
        Dim Produto1 = New Produto() With {.ProdutoId = 1, .CategoriaProduto = Categoria1, .Descricao = "Produto 1", .Preco = 1.5D}
        Dim Produto2 = New Produto() With {.ProdutoId = 2, .CategoriaProduto = Categoria2, .Descricao = "Produto 2", .Preco = 2.5D}
        Dim Vendedor1 = New Vendedor() With {.VendedorId = 1, .Nome = "Vendedor 1", .DataNascimento = New DateTime(2016, 11, 16)}
        Dim Vendedor2 = New Vendedor() With {.VendedorId = 2, .Nome = "Vendedor 2", .DataNascimento = New DateTime(2016, 11, 17)}
        Dim Pedido1 = New Pedido() With {.PedidoId = 1, .DataPedido = DateTime.Now, .Vendedor = Vendedor1}
        Dim Pedido2 = New Pedido() With {.PedidoId = 2, .DataPedido = DateTime.Now, .Vendedor = Vendedor2}
        Dim ItemPedido1 = New ItemPedido() With {.ItemPedidoId = 1, .Pedido = Pedido1, .Produto = Produto1, .Quantidade = 1, .Valor = 1.5D}
        Dim ItemPedido2 = New ItemPedido() With {.ItemPedidoId = 2, .Pedido = Pedido1, .Produto = Produto2, .Quantidade = 2, .Valor = 5}
        Dim ItemPedido3 = New ItemPedido() With {.ItemPedidoId = 3, .Pedido = Pedido2, .Produto = Produto1, .Quantidade = 3, .Valor = 4.5D}
        Dim ItemPedido4 = New ItemPedido() With {.ItemPedidoId = 4, .Pedido = Pedido2, .Produto = Produto2, .Quantidade = 4, .Valor = 10}
        Pedido1.ItensPedido = New ItemPedido() {ItemPedido1, ItemPedido2}
        Pedido2.ItensPedido = New ItemPedido() {ItemPedido3, ItemPedido4}

        Lista.Add(Pedido1)
        Lista.Add(Pedido2)

        Return Lista
    End Function

E agora vamos criar um outro método que fará a impressão de uma lista de Pedidos. Nós utilizaremos esse método para conferirmos se o resultado da desserialização está correto ou não:

        // C#
        private static void ImprimirPedidos(List<Pedido> pedidos)
        {
            foreach (var pedido in pedidos)
            {
                Console.WriteLine("==========");
                Console.WriteLine("Pedido {0}:", pedido.PedidoId);
                Console.WriteLine("Data = {0:G}, Vendedor = {1}, Data Nascimento Vendedor = {2:G}", pedido.DataPedido, pedido.Vendedor.Nome, pedido.Vendedor.DataNascimento);
                Console.WriteLine("Itens do Pedido:");
                foreach (var item in pedido.ItensPedido)
                {
                    Console.WriteLine("Produto = {0}, Categoria Produto = {1}, Valor Unitário = {2}, Quantidade = {3}, Valor Total = {4}", item.Produto.Descricao, item.Produto.CategoriaProduto.Descricao, item.Produto.Preco, item.Quantidade, item.Valor);
                }
                Console.WriteLine("==========");
            }
        }

    ' VB.NET
    Private Sub ImprimirPedidos(Pedidos As List(Of Pedido))
        For Each Pedido In Pedidos
            Console.WriteLine("==========")
            Console.WriteLine("Pedido {0}:", Pedido.PedidoId)
            Console.WriteLine("Data = {0:G}, Vendedor = {1}, Data Nascimento Vendedor = {2:G}", Pedido.DataPedido, Pedido.Vendedor.Nome, Pedido.Vendedor.DataNascimento)
            Console.WriteLine("Itens do Pedido:")
            For Each Item In Pedido.ItensPedido
                Console.WriteLine("Produto = {0}, Categoria Produto = {1}, Valor Unitário = {2}, Quantidade = {3}, Valor Total = {4}", Item.Produto.Descricao, Item.Produto.CategoriaProduto.Descricao, Item.Produto.Preco, Item.Quantidade, Item.Valor)
            Next
            Console.WriteLine("==========")
        Next
    End Sub

Por fim, no nosso método “Main“, vamos criar uma lista de Pedidos e, logo em seguida, vamos imprimi-la na tela para ver se tudo está funcionando corretamente:

        // C#
        static void Main(string[] args)
        {
            var lista = CriarListaDePedidos();

            Console.WriteLine("==========");
            Console.WriteLine("Dados originais:");
            ImprimirPedidos(lista);
            Console.WriteLine("==========");
            Console.ReadLine();
        }

    ' VB.NET
    Sub Main()
        Dim Lista = CriarListaDePedidos()

        Console.WriteLine("==========")
        Console.WriteLine("Dados originais:")
        ImprimirPedidos(Lista)
        Console.WriteLine("==========")
        Console.ReadLine()
    End Sub

Execute a aplicação e veja o resultado:

Agora que já temos os nossos dados de exemplo, vamos ver como podemos serializar e desserializar esses dados no formato JSON utilizando 3 bibliotecas diferentes.

Opção 1: DataContractJsonSerializer

A primeira classe que vamos utilizar vem do próprio .NET Framework. A classe DataContractJsonSerializer pode ser utilizada justamente para fazermos a serialização e desserialização de dados no formato JSON. Para utilizarmos essa classe, nós primeiramente temos que adicionar uma referência ao assembly “System.Runtime.Serialization“:

O construtor da classe DataContractJsonSerializer espera o tipo de dados que deverá ser serializado ou desserializado. Uma vez criada uma instância dessa classe, nós podemos utilizar os métodos WriteObject (para serializarmos um objeto) ou ReadObject (para desserializarmos um objeto). Ambos os métodos trabalham com Streams para fazer a gravação e leitura do resultado. Dessa forma, se você quiser escrever os dados em memória, você poderia trabalhar com uma MemoryStream. Se, por outro lado, você quiser escrever os dados em um arquivo, você terá que trabalhar com um FileStream.

Vamos criar um método que receberá a nossa lista de Pedidos e fará a serialização dos dados, guardando o resultado dentro do arquivo “pedidos1.json“:

        // C#
        private static void SerializarDataContractJsonSerializer(List<Pedido> pedidos)
        {
            using (var stream = new System.IO.FileStream("pedidos1.json", System.IO.FileMode.Create))
            {
                var serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(List<Pedido>));
                serializer.WriteObject(stream, pedidos);
            }
        }

    ' VB.NET
    Private Sub SerializarDataContractJsonSerializer(Pedidos As List(Of Pedido))
        Using Stream = New System.IO.FileStream("pedidos1.json", System.IO.FileMode.Create)
            Dim Serializer = New System.Runtime.Serialization.Json.DataContractJsonSerializer(GetType(List(Of Pedido)))
            Serializer.WriteObject(Stream, Pedidos)
        End Using
    End Sub

Simples, não? Primeiro, criamos uma FileStream apontando para o arquivo “pedidos1.json” (que será criado caso ainda não exista ou substituído caso já exista). Em seguida, criamos um DataContractJsonSerializer passando o tipo “lista de Pedidos“, que é justamente o tipo que queremos serializar. Por fim, chamamos o método WriteObject passando a Stream e a lista de Pedidos.

Agora que já temos o código correspondente à serialização, vamos implementar um outro método que carregará o conteúdo do arquivo “pedidos1.json” e fará a desserialização utilizando a classe DataContractJsonSerializer:

        // C#
        private static List<Pedido> DeserializarDataContractJsonSerializer()
        {
            using (var stream = new System.IO.FileStream("pedidos1.json", System.IO.FileMode.Open))
            {
                var serializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(List<Pedido>));
                return (List<Pedido>)serializer.ReadObject(stream);
            }
        }

    ' VB.NET
    Private Function DeserializarDataContractJsonSerializer() As List(Of Pedido)
        Using Stream = New System.IO.FileStream("pedidos1.json", System.IO.FileMode.Open)
            Dim Serializer = New System.Runtime.Serialization.Json.DataContractJsonSerializer(GetType(List(Of Pedido)))
            Return DirectCast(Serializer.ReadObject(Stream), List(Of Pedido))
        End Using
    End Function

Como você pode perceber, grande parte do código é idêntica à serialização. As únicas diferenças são a abertura do arquivo em modo leitura (e não escrita) e a utilização do método ReadObject, ao invés do método WriteObject.

Agora que nós já criamos os métodos para fazer a serialização e desserialização dos dados via DataContractJsonSerializer, vamos adicionar as suas chamadas no nosso método “main“:

            // C#
            Console.WriteLine("==========");
            Console.WriteLine("Resultado DataContractJsonSerializer:");
            SerializarDataContractJsonSerializer(lista);
            ImprimirPedidos(DeserializarDataContractJsonSerializer());
            Console.WriteLine("==========");
            Console.ReadLine();

        ' VB.NET
        Console.WriteLine("==========")
        Console.WriteLine("Resultado DataContractJsonSerializer:")
        SerializarDataContractJsonSerializer(Lista)
        ImprimirPedidos(DeserializarDataContractJsonSerializer())
        Console.WriteLine("==========")
        Console.ReadLine()

Vamos executar a aplicação para ver se o nosso código está funcionando corretamente? Como nada funciona “de primeira” no mundo do desenvolvimento de software, veja só a exceção que receberemos com o código atual:

Esse erro acontece porque nós temos uma referência cíclica na nossa estrutura de dados. Se você reparar, a classe Pedido tem uma lista de Itens de Pedido e a classe Item de Pedido tem uma referência ao Pedido (pai). Não existe uma maneira do serializador resolver essa referência cíclica automaticamente, então, ele acaba disparando essa exceção.

Se quisermos manter essa estrutura de referência cíclica, nós teremos que, de alguma forma, indicar para o serializador qual a propriedade que deve ser ignorada na serialização, de forma que a referência cíclica possa ser resolvida. No nosso caso, nós podemos ignorar a propriedade que faz o link do Item de Pedido com o Pedido pai, que é a propriedade “Pedido” dentro da classe “ItemPedido“. Para indicarmos que essa propriedade deve ser ignorada na serialização, nós temos que decorá-la com o atributo IgnoreDataMember:

    // C#
    public class ItemPedido
    {
        public int ItemPedidoId { get; set; }
        [System.Runtime.Serialization.IgnoreDataMember]
        public Pedido Pedido { get; set; }
        public Produto Produto { get; set; }
        public decimal Quantidade { get; set; }
        public decimal Valor { get; set; }
    }

' VB.NET
Public Class ItemPedido
    Public Property ItemPedidoId As Integer
    <System.Runtime.Serialization.IgnoreDataMember()>
    Public Property Pedido As Pedido
    Public Property Produto As Produto
    Public Property Quantidade As Decimal
    Public Property Valor As Decimal
End Class

Agora sim. Se executarmos o projeto novamente teremos o resultado esperado:

Note também que o arquivo “pedidos1.json” foi gerado com sucesso no diretório da aplicação:

Opção 2: Json.NET (Newtonsoft)

A segunda biblioteca de serialização de JSON que eu quero mostrar para vocês neste artigo é a Json.NET (também conhecida como Newtonsoft). Para instalá-la no nosso projeto, utilizamos o NuGet, procurando por “Json” ou através do comando “Install-Package Newtonsoft.Json” no Package Manager Console (se ficar com alguma dúvida na utilização do NuGet, confira este artigo):

Você perceberá rapidamente que essa biblioteca possui alguns métodos utilitários que facilitam muito a nossa vida. Com a classe “JsonConvert” (do namespace Newtonsoft.Json), nós conseguimos rapidamente serializar um objeto através do método “SerializeObject” e desserializar um conteúdo JSON através do método “DeserializeObject“. Veja só como fica o código para serializar e desserializar a nossa lista de Pedidos com o Json.NET:

        // C#
        private static void SerializarNewtonsoft(List<Pedido> pedidos)
        {
            using (var streamWriter = new System.IO.StreamWriter("pedidos2.json"))
            {
                var json = Newtonsoft.Json.JsonConvert.SerializeObject(pedidos);
                streamWriter.Write(json);
            }
        }
        private static List<Pedido> DeserializarNewtonsoft()
        {
            var json = System.IO.File.ReadAllText("pedidos2.json");
            return Newtonsoft.Json.JsonConvert.DeserializeObject<List<Pedido>>(json);
        }

    ' VB.NET
    Private Sub SerializarNewtonsoft(Pedidos As List(Of Pedido))
        Using StreamWriter = New System.IO.StreamWriter("pedidos2.json")
            Dim Json = Newtonsoft.Json.JsonConvert.SerializeObject(Pedidos)
            StreamWriter.Write(Json)
        End Using
    End Sub
    Private Function DeserializarNewtonsoft() As List(Of Pedido)
        Dim Json = System.IO.File.ReadAllText("pedidos2.json")
        Return Newtonsoft.Json.JsonConvert.DeserializeObject(Of List(Of Pedido))(Json)
    End Function

Em seguida, vamos adicionar o código que faz a chamada dessas funcionalidades dentro do método “main“:

            // C#
            Console.WriteLine("==========");
            Console.WriteLine("Resultado Newtonsoft:");
            SerializarNewtonsoft(lista);
            ImprimirPedidos(DeserializarNewtonsoft());
            Console.WriteLine("==========");
            Console.ReadLine();

        ' VB.NET
        Console.WriteLine("==========")
        Console.WriteLine("Resultado Newtonsoft:")
        SerializarNewtonsoft(Lista)
        ImprimirPedidos(DeserializarNewtonsoft())
        Console.WriteLine("==========")
        Console.ReadLine()

Se executarmos o nosso projeto, veremos que o resultado é idêntico ao da classe DataContractJsonSerializer:

Opção 3: Jil

Por fim, vamos testar a biblioteca chamada Jil, que é famosa por ser mais performática que as outras bibliotecas. Inclusive o Carlos dos Santos já escreveu um artigo uns tempos atrás demonstrando um exemplo simples de serialização e desserialização com essa biblioteca. Confira o artigo aqui.

Porém, o exemplo do artigo do Carlos dos Santos abordou somente propriedades do tipo int e string. Vamos conferir se o Jil não tem alguma complicação com outros tipos de dados, como DateTime?

Primeiramente, temos que adicionar a referência através do NuGet. Você pode fazer isso procurando por “Jil” na tela de gerenciamento de pacotes do NuGet ou digitando “Install-Package Jil” no Package Manager Console (mais uma vez, se ficar com alguma dúvida sobre a utilização do NuGet no Visual Studio, confira este artigo):

A serialização e desserialização de dados com a biblioteca Jil também é extremamente simples. Através da classe “JSON“, podemos serializar objetos através do método “Serialize” e desserializar um conteúdo JSON através do método “Deserialize“:

        // C#
        private static void SerializarJil(List<Pedido> pedidos)
        {
            using (var streamWriter = new System.IO.StreamWriter("pedidos3.json"))
            {
                var json = Jil.JSON.Serialize(pedidos);
                streamWriter.Write(json);
            }
        }
        private static List<Pedido> DeserializarJil()
        {
            var json = System.IO.File.ReadAllText("pedidos3.json");
            return Jil.JSON.Deserialize<List<Pedido>>(json);
        }

    ' VB.NET
    Private Sub SerializarJil(Pedidos As List(Of Pedido))
        Using StreamWriter = New System.IO.StreamWriter("pedidos3.json")
            Dim Json = Jil.JSON.Serialize(Pedidos)
            StreamWriter.Write(Json)
        End Using
    End Sub
    Private Function DeserializarJil() As List(Of Pedido)
        Dim Json = System.IO.File.ReadAllText("pedidos3.json")
        Return Jil.JSON.Deserialize(Of List(Of Pedido))(Json)
    End Function

Em seguida, adicionamos as chamadas para essas funcionalidades no método “main“:

            // C#
            Console.WriteLine("==========");
            Console.WriteLine("Resultado Jil:");
            SerializarJil(lista);
            ImprimirPedidos(DeserializarJil());
            Console.WriteLine("==========");
            Console.ReadLine();

        ' VB.NET
        Console.WriteLine("==========")
        Console.WriteLine("Resultado Jil:")
        SerializarJil(Lista)
        ImprimirPedidos(DeserializarJil())
        Console.WriteLine("==========")
        Console.ReadLine()

Agora vamos executar a aplicação para compararmos os resultados da biblioteca Jil com as outras bibliotecas. Veja só a diferença nos campos DateTime:

Eu particularmente achei muito confuso o jeito que a biblioteca Jil lida com DateTimes. Pesquisei extensivamente no repositório da biblioteca e não encontrei nenhum jeito de configurá-la de maneira que os DateTimes sejam serializados e desserializados mantendo as informações de fuso horário e horário de verão. A única maneira de fazer com que o valor fique idêntico ao das outras bibliotecas é alterar as nossas propriedades DateTime para DateTimeOffset nas classes Vendedor e Pedido, aí sim os valores de fuso horário são mantidos:

    // C#
    public class Vendedor
    {
        public int VendedorId { get; set; }
        public string Nome { get; set; }
        public DateTimeOffset DataNascimento { get; set; }
    }
    public class Pedido
    {
        public int PedidoId { get; set; }
        public DateTimeOffset DataPedido { get; set; }
        public Vendedor Vendedor { get; set; }
        public IEnumerable<ItemPedido> ItensPedido { get; set; }
    }

' VB.NET
Public Class Vendedor
    Public Property VendedorId As Integer
    Public Property Nome As String
    Public Property DataNascimento As DateTimeOffset
End Class
Public Class Pedido
    Public Property PedidoId As Integer
    Public Property DataPedido As DateTimeOffset
    Public Property Vendedor As Vendedor
    Public Property ItensPedido As IEnumerable(Of ItemPedido)
End Class

Outras opções? Qual é a melhor?

Obviamente, essas não são as únicas bibliotecas de serialização de JSON no .NET – existem inúmeras outras bibliotecas. Essas foram as 3 opções que eu notei que são as mais utilizadas no mercado. Entretanto, se você pesquisar no Google por comparação de bibliotecas JSON no .NET, você encontrará dezenas de opções. Para mais informações, confira estes links:

Most efficient way to parse JSON in C#

Binary and Json benchmarks updated

Concluindo

Existem diversas opções de classes e bibliotecas para fazermos a serialização e desserialização de JSON no .NET. Neste artigo você conferiu como utilizar a classe DataContractJsonSerializer, bem como as bibliotecas Json.NET (Newtonsoft) e Jil.

E você, já precisou fazer o parse de JSON nas suas aplicações? Qual biblioteca você acabou utilizando? Como foi a sua experiência? Conte mais detalhes nos comentários deste post!

Por fim, convido você a inscrever-se na minha newsletter. Ao fazer isso, você receberá um e-mail toda semana sobre o artigo publicado e ficará sabendo também em primeira mão sobre o artigo da próxima semana, além de receber dicas “bônus” que eu só compartilho por e-mail. Inscreva-se utilizando o formulário logo abaixo.

Até a próxima!

André Lima

Image by Linux Screenshots used under Creative Commons
https://www.flickr.com/photos/xmodulo/14636491710

Juntando executável e dlls em um arquivo só com o ILMerge Apresentação DevWeek 2016 – Ferramentas gratuitas para geração de relatórios no .NET