C# - Convertendo XML para JSON e vice-versa

Hoje veremos como converter XML para JSON e vice-versa na plataforma .NET.

O formato JSON é o formato preferido para transferência de dados em aplicativos web modernos.

No entanto, às vezes você precisa lidar com o formato de dados XML. Além disso, você pode querer lidar com JSON e XML no mesmo aplicativo. Por exemplo, você pode estar recebendo dados em JSON de uma Web API e, em seguida, pode desejar alimentá-los para outro serviço que espera entrada no formato XML. Essas situações são comuns quando você integra sistemas de software novos e antigos.

Em tais cenários, você pode querer converter dados XML em seu equivalente JSON e vice-versa. Pode haver duas abordagens para lidar com essa conversão de formato de dados:

  1. Conversão Texto para Texto
  2. Conversão Texto para Objeto

Na primeira abordagem, você converte XML diretamente em seu equivalente JSON e vice-versa. Nesta abordagem, você não precisa ter nenhum objeto C# que mapeie para os dados sendo convertidos. É mais como analisar um formato e convertê-lo em outro formato sem se preocupar muito com o objeto subjacente. Você pode escrever sua própria lógica de análise ou usar alguma biblioteca de terceiros, como Json.NET, para realizar essa conversão.

Na segunda abordagem, você primeiro desserializa os dados XML em um objeto C# e, em seguida, serializa o objeto C# em JSON. Se você deseja converter de JSON para XML, um processo semelhante será seguido - JSON para objeto  # e objeto C# para XML. Para seguir essa abordagem, você pode usar as classes XmlSerializer e JsonSerializer da plataforma .NET Core.

Neste artigo vamos focar na segunda opção para converter os formatos XML e JSON.

Convertendo Cliente para XML

Vamos criar um projeto do tipo Console usando o .NET Core SDK 5.0 no VS 2019 Community.

Como exemplo vamos criar no projeto a classe Cliente que trata dados dos clientes em uma aplicação:

    public class Cliente
    {
        public int ClienteId { get; set; }
        public string Nome { get; set; }
        public string Email { get; set; }
        public DateTime Nascimento { get; set; }
    }

Em primeiro lugar, vamos ver como um objeto Cliente pode ser serializado nos formatos XML e JSON usando as classes JsonSerializer e XmlSerializer, respectivamente.

Vamos escrever uma classe auxiliar para esse propósito chamada - JsonXmlHelper, e nesta classe vamos criar o método estático ClienteToXml():

using System.IO;
using System.Text.Json;
using System.Xml.Serialization;

namespace XML_JSON1
{
    public class JsonXmlHelper
    {
        public static string ClienteToXml(Cliente cliente)
        {
            XmlSerializer xmlSerializer = new XmlSerializer(typeof(Cliente));

            using (StringWriter textWriter = new StringWriter())
            {
                xmlSerializer.Serialize(textWriter, cliente);
                return textWriter.ToString();
            }
        }
    }
}

O método ClienteToXml() aceita um objeto Cliente e retorna seu XML equivalente ao chamador.

No método ClienteToXml() usamos a classe XmlSerializer do namespace System.Xml.Serialization e passamos o tipo da classe que desejamos serializar (Cliente) para o construtor da classe.

A seguir, criamos uma nova instância de StringWriter e o XmlSerializer grava neste StringWriter quando o método Serialize() for chamado. O método Serialize() usa dois parâmetros :

  1. Uma implementação TextWriter (StringWriter neste caso)
  2. E um objeto para serializar;

Serializar Cliente para JSON

Agora que sabemos como serializar um objeto Cliente em XML, vamos fazer a serialização para o formato JSON, e,  para isso vamos criar o método ClienteToJson() na classe JsonXmlHelper mostrado abaixo:

using System.IO;
using System.Text.Json;
using System.Xml.Serialization;

namespace XML_JSON1
{
    public class JsonXmlHelper
    {
        public static string ClienteToXml(Cliente cliente)
        {
            XmlSerializer xmlSerializer = new XmlSerializer(typeof(Cliente));

            using (StringWriter textWriter = new StringWriter())
            {
                xmlSerializer.Serialize(textWriter, cliente);
                return textWriter.ToString();
            }
        }

        public static string ClienteToJson(Cliente cliente)
        {
             return JsonSerializer.Serialize(cliente);
        }
     }
}

Este código é muito simples e direto. Ele usa a classe JsonSerializer do namespace System.Text.Json e o método Serialize() de JsonSerializer aceita um objeto a ser serializado e retorna uma string JSON ao chamador.

Para testar as nossas implementações vamos definir o código abaixo no método Main da classe Program:

using System;

namespace XML_JSON1
{
    class Program
    {
        static void Main(string[] args)
        {
            Cliente cliente = new Cliente()
            {
                ClienteId = 1,
                Nome = "Nancy",
                Email = "Davolio",
                Nascimento = new  DateTime(1964, 12, 8)
            };

            string xml = JsonXmlHelper.ClienteToXml(cliente);
            string json = JsonXmlHelper.ClienteToJson(cliente);

            Console.WriteLine($"Cliente para XML  :\n {xml}\n\n");
            Console.WriteLine($"Cliente para JSON :\n {json}");
            Console.ReadLine();
        }
    }
}

Executando o código teremos o resultado a seguir:



Como vemos temos a conversão para o formato XML e JSON.

Convertendo XML para JSON

Vamos agora converter XML para JSON para isso precisamos primeiro desserializar o XML para obter um objeto Cliente. Em seguida, podemos serializar o objeto Cliente em JSON usando o método XmlToJson() que iremos criar na classe Helper com o seguinte código:

       public static string XmlToJson(string xmlDados)
        {
            Cliente cliente;

            XmlSerializer xmlSerializer =  new XmlSerializer(typeof(Cliente));

            using (StringReader textReader = new StringReader(xmlDados))
            {
                cliente = (Cliente)xmlSerializer.Deserialize(textReader);
            }
            return ClienteToJson(cliente);
        }

O método XmlToJson() aceita uma string contendo a versão XML de um objeto Cliente e retorna uma string JSON que representa os mesmos dados Cliente.

No método criamos objetos XmlSerializer e StringReader. A string XML passada ao método XmlToJson() é fornecida ao StringReader. O StringReader é então fornecido ao método Deserialize() de XmlSerializer e este método desserializa os dados XML em um objeto Cliente.

O objeto Cliente é então passado para o método ClienteToJson () para obter seu equivalente JSON que retorna a string JSON ao chamador.

Para testar vamos usar o código abaixo :

        static void Main(string[] args)
        {
            Cliente cliente = new Cliente()
            {
                ClienteId = 1,
                Nome = "Nancy",
                Email = "Davolio",
                Nascimento = new DateTime(1964, 12, 8)
            };

             Console.WriteLine("Convertendo XML para JSON \n");

            string xml1 = JsonXmlHelper.ClienteToXml(cliente);
            string json1 = JsonXmlHelper.XmlToJson(xml1);

            Console.WriteLine($"Cliente para XML  :\n {xml1}\n\n");
            Console.WriteLine($"XML para JSON :\n {json1}");
            Console.ReadLine();
        }

Neste exemplo após criar o XML a partir do Cliente convertemos o XML para JSON usando o método XmlToJson().

Convertendo JSON para XML

Vamos agora criar o método JsonToXml() para converter a versão JSON de Cliente para a versão XML. Para isso inclua o código abaixo neste método:

vamos criar a classe Produto que herda da classe ProdutoBase:

        public static string JsonToXml(string jsonDados)
        {
            var options = new JsonSerializerOptions
            {
                PropertyNameCaseInsensitive = true
            };

            Cliente emp = JsonSerializer.Deserialize<Cliente>(jsonDados, options);

            return ClienteToXml(emp);
        }

O método JsonToXml() aceita uma string contendo JSON que representa um Cliente, e retorna uma string que representa os dados no formato XML.

A seguir usamos o método Deserializer() de JsonSerializer para desserializar JSON em um objeto Cliente.

Usamos o método ClienteToXml() para então converter o objeto Cliente em string XML equivalente.

Para testar podemos usar o código abaixo:

        static void Main(string[] args)
        {
            Cliente cliente = new Cliente()
            {
                ClienteId = 1,
                Nome = "Nancy",
                Email = "Davolio",
                Nascimento = new DateTime(1964, 12, 8)
            };          

            Console.WriteLine("Convertendo JSON para XML \n");

            string json = JsonXmlHelper.ClienteToJson(cliente);
            string xml = JsonXmlHelper.JsonToXml(json);

            Console.WriteLine($"Cliente para JSON  :\n {json}\n\n");
            Console.WriteLine($"JSON para XML :\n {xml}");
            Console.ReadLine();
        }

Executando o projeto teremos:

   

Temos assim a conversão de Cliente para JSON e deste para XML.

Pegue o código do projeto aqui :  XML_JSON1.zip

"Guia-me na tua verdade, e ensina-me, pois tu és o Deus da minha salvação; por ti estou esperando todo o dia."
Salmos 25:5

Referências:
  • Padrões de Projeto
  • Padrões de Projeto - O modelo MVC - Model View Controller
  • O padrão Singleton
  • VB.NET - Permitindo uma única instância da sua aplicação
  • Design Patterns - o padrão Factory
  • Conceitos sobre projetos - Decomposição
  • Usando o padrão Strategy
  • SRP - O princípio da responsabilidade única
  • Boas Práticas - O padrão inversão de controle (IoC)
  • http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod
  • Conceitos sobre projetos - Decomposição
    •

    José Carlos Macoratti