CodeGym /Cursos /C# SELF /Principais formatos de serialização: XML, JSON, CSV, ...

Principais formatos de serialização: XML, JSON, CSV, Protobuf

C# SELF
Nível 43, Lição 2
Disponível

1. Por que escolher um formato? Lembrete rápido

Qualquer objeto .NET na memória é um conjunto de endereços, referências, campos, estruturas internas e outros "detalhes de máquina". Mas não dá pra salvar isso direto em um arquivo: arquivos precisam ser estruturados num formato que outras pessoas e programas consigam ler (e de preferência escrever). É aí que entra a escolha do formato de serialização.

Principais objetivos de um formato de serialização:

  • Compacidade: espaço no disco ou velocidade de transmissão pela rede.
  • Legibilidade (por humanos!): dá para abrir o arquivo num editor de texto e entender o que tem dentro.
  • Universalidade: serve para integração com outros sistemas e linguagens.
  • Suporte a estruturas complexas: aninhamentos, coleções, referências, tipos.
  • Segurança e compatibilidade.

2. Serialização binária (Binary Serialization)

Serialização binária representa os dados como um fluxo "cru" de bytes. Imagine que você não só embalou as coisas numa caixa, mas as cimentou — rápido, compacto, mas depois você não acha suas meias sem uma marreta.

// Exemplo só para referência histórica:
using System.Runtime.Serialization.Formatters.Binary;

// ... criação do objeto
var user = new User { Name = "Ivan", Age = 42 };

// Serialização
using var fs = new FileStream("user.bin", FileMode.Create);
var formatter = new BinaryFormatter();
formatter.Serialize(fs, user);

Prós:

  • Compacidade: ocupa o mínimo de espaço em disco, alta velocidade.
  • Suporte nativo a tipos "do .NET".

Contras:

  • Formato totalmente ilegível — abra no Bloco de Notas e você verá a Matrix (ou seja, um monte de caracteres sem sentido).
  • Totalmente não universal: só para .NET (e ainda assim só para a mesma versão!).
  • Vulnerável a problemas de compatibilidade entre versões.

Onde era usado?

Dentro do .NET, quando era preciso "dump" rápido de objetos entre processos na mesma máquina. Hoje não é recomendado, especialmente se você liga para segurança e manutenção a longo prazo. Usar BinaryFormatter em projetos modernos é má prática.

3. Formato XML (Extensible Markup Language)

XML — formato legível por humanos e máquinas, baseado em tags, como HTML, mas sem as piadas sobre <body>.

<User>
  <Name>Ivan</Name>
  <Age>42</Age>
</User>

Exemplo de serialização:

using System.Xml.Serialization;

var user = new User { Name = "Ivan", Age = 42 };

var serializer = new XmlSerializer(typeof(User));
using var fs = new FileStream("user.xml", FileMode.Create);
serializer.Serialize(fs, user);

Prós:

  • Legibilidade: dá pra abrir e ver a estrutura com os próprios olhos.
  • Universalidade: muitos idiomas e programas sabem ler XML.
  • Flexibilidade (suporte a schemas, validação, namespaces etc.).
  • Bom para estruturas complexas e objetos aninhados.

Contras:

  • "Barulhento" e pesado: ocupa muito espaço e tráfego.
  • Parsing mais lento que formatos binários.
  • Imprecisão em serializar certos tipos (por exemplo, datas e horários).
  • Requer configuração extra para suportar algumas coleções ou objetos não padrão.

Onde se aplica?

Troca de dados entre sistemas corporativos, configs, integração com sistemas que exigem estrutura rígida.

4. Formato JSON (JavaScript Object Notation)

JSON — formato compacto, leve e fácil de ler, vindo do mundo JavaScript e que conquistou quase todo o universo pra troca de dados por sua concisão e simplicidade.

{
  "Name": "Ivan",
  "Age": 42
}

Exemplo de serialização:

using System.Text.Json;

var user = new User { Name = "Ivan", Age = 42 };

string json = JsonSerializer.Serialize(user);
File.WriteAllText("user.json", json);

Prós:

  • Muito legível tanto por humanos quanto por máquinas.
  • Integração fácil com tecnologias web (API, JavaScript e afins).
  • Mais compacto que XML.
  • Serialização/deserialização rápida em bibliotecas modernas (System.Text.Json, Newtonsoft.Json).

Contras:

  • Sem suporte a comentários (seu JSON não pode brincar consigo mesmo).
  • Limitações de estrutura: não serializa, por exemplo, referências entre objetos ou tipos complexos (como dicionários com chaves não-string).
  • Diferenças no formato de datas/horários entre implementações.

Onde se aplica?

Praticamente em todo lugar que precisa trocar informação entre plataformas: web services, apps mobile, REST APIs etc.

5. CSV (Comma-Separated Values)

CSV — formato de texto simples que representa dados como tabela (linhas e colunas), onde campos são separados por vírgulas ou outro delimitador.

Name,Age
Ivan,42
Olga,27

Exemplo de escrita CSV manual:

// Para simplicidade, escrevendo com StreamWriter comum
var lines = new List<string>
{
    "Name,Age",
    "Ivan,42",
    "Olga,27"
};
File.WriteAllLines("users.csv", lines);

Prós:

  • Suportado por um monte de programas (Excel, Google Docs, DBs etc.).
  • Conciso e conveniente para dados tabulares.

Contras:

  • Não serve para objetos aninhados ou complexos (só estruturas "planas").
  • Não guarda tipos de dados (tudo vira string).
  • Problemas de escaping quando os dados contém vírgulas, aspas ou quebras de linha.

Onde se aplica?

Export/import entre DBs, troca de conjuntos simples de registros, extrações de apps.

6. Protocolos e formatos fortemente tipados

Protocol Buffers (protobuf) e MessagePack — formatos binários com contratos (schemas) que tornam a serialização ainda mais compacta e rápida. Eles pedem uma descrição prévia da estrutura dos dados.

Exemplo em protobuf (simplificado):

Não faz parte do padrão .NET, é necessário o pacote Google.Protobuf.

message User {
  string name = 1;
  int32 age = 2;
}

Prós:

  • Máxima velocidade e compacidade.
  • Cross-platform (muitas linguagens suportam protobuf).

Contras:

  • Mais complicado de aprender e configurar.
  • Requer geração de código a partir do schema.
  • Nem sempre necessário, se seu projeto não lida com milhões de mensagens por segundo.

Onde se aplica?

Sistemas de alta carga, troca de dados entre microservices, jogos, IoT.

7. Observações úteis

Tabela-comparativa de formatos

Formato Legibilidade Compacidade Universalidade Objetos complexos Padrão no .NET 9 Segurança
Binary (.NET) Não Sim Não Sim Não Não
XML Sim Não Sim Sim Sim Sim
JSON Sim Sim Sim Parcialmente Sim Sim
CSV Sim Sim Sim Não Não Sim
Protobuf Não O melhor Sim Sim Não Sim

Como escolher o formato para sua aplicação?

Se você salva estruturas complexas e quer legibilidade humana — use XML ou JSON.

Se precisa transmitir muitos dados rapidamente entre serviços que você controla — considere protobuf ou MessagePack.

Se está exportando relatórios para análise no Excel ou DB — use CSV.

Se escreve config para serviços ou CI/CD — YAML te ajuda bastante.

Compacidade, velocidade e suporte a referências entre objetos são críticos? Procure formatos binários, mas lembre dos problemas de segurança e compatibilidade.

8. Armadilhas e erros comuns

Se você decidir guardar dados em formato binário por "sigilo", lembre: dump binário não é segurança. Um atacante ainda pode "desmontar" esse fluxo. Use criptografia quando necessário.

Problema comum: esquecer da codificação ao trabalhar com formatos textuais (XML/JSON/CSV) — use UTF-8. Nem todos editores e sistemas gostam de BOM.

XML, embora pareça "antigo", é ótimo para protocolos contratuais onde é importante uma descrição validadora rígida (por exemplo, schemas XSD), enquanto JSON é para trocas rápidas e flexíveis.

Ao serializar coleções de objetos complexos, nem todos os formatos suportam corretamente estruturas aninhadas ou recursivas. JSON e XML lidam bem com arrays e listas; CSV não.

2
Tarefa
C# SELF, nível 43, lição 2
Bloqueado
Serialização de objeto no formato JSON
Serialização de objeto no formato JSON
Comentários
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION