1. Introdução
Lembrete: Serialização é a forma de salvar o estado de um objeto como uma string, arquivo ou stream, para depois restaurar esse objeto (desserializar) — e aí você volta a ter um objeto com os mesmos dados.
Situação típica:
1) Você tem um objeto, por exemplo, um usuário com nome e idade.
2) Precisa salvar isso — enviar pela rede, gravar em arquivo ou, por exemplo, no formato JSON.
3) Depois pega os dados da string/arquivo e restaura o objeto — e pronto, o objeto está de volta!
Em C# isso se faz em poucas linhas. Vamos ver como.
Nosso aplicativo
Estamos desenvolvendo um pequeno app "Gerenciador de contatos". Suponha que temos a classe Person que queremos serializar.
public class Person
{
// Propriedades públicas são necessárias para serialização!
public string Name { get; set; }
public int Age { get; set; }
// Construtor sem parâmetros é obrigatório para XmlSerializer
public Person() { }
public Person(string name, int age)
{
Name = name;
Age = age;
}
}
Se você ainda não conhece essa sintaxe, relaxa — mais adiante no curso vamos detalhar classes e propriedades. Por enquanto encare isso como um modelo de dados para os exemplos. Repare: as propriedades públicas Name e Age são importantes para a serialização, e para o XmlSerializer é preciso ter um construtor público sem parâmetros.
2. Serialização em JSON com System.Text.Json
Exemplo simples
Prometido é devido — aqui vai um exemplo de serialização para JSON:
using System;
using System.Text.Json;
Person person = new Person("Alice", 28);
// Serialização: transformando o objeto em uma string JSON
string json = JsonSerializer.Serialize(person);
Console.WriteLine("JSON:");
Console.WriteLine(json);
O que aparecerá no console?
JSON:
{"Name":"Alice","Age":28}
É simples: objeto → JSON. A mágica acontece aqui!
Desserialização — trazendo de volta
Agora a operação inversa — vamos restaurar um objeto a partir de uma string JSON:
string json = "{\"Name\":\"Bob\",\"Age\":35}";
// Desserialização: restaurando um objeto do tipo Person a partir da string JSON
Person restored = JsonSerializer.Deserialize<Person>(json);
Console.WriteLine("Objeto restaurado:");
Console.WriteLine($"Nome: {restored.Name}, idade: {restored.Age}");
Resultado:
Objeto restaurado:
Nome: Bob, idade: 35
Repare: se a estrutura de dados não bater (por exemplo, faltar uma propriedade), o campo correspondente ficará com o valor padrão (null para tipos de referência, 0 para números, etc).
3. Serialização/desserialização em XML com XmlSerializer
Serialização em XML — primeira olhada
using System;
using System.IO;
using System.Xml.Serialization;
Person person = new Person("Katia", 22);
// Criamos o serializer para o tipo Person
var serializer = new XmlSerializer(typeof(Person));
// Escreve o XML em um arquivo
using (var stream = new FileStream("person.xml", FileMode.Create))
{
serializer.Serialize(stream, person);
// O stream será fechado automaticamente ao final do bloco using
}
Console.WriteLine("Arquivo XML criado!");
No arquivo person.xml vai aparecer algo assim:
<?xml version="1.0"?>
<Person xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<Name>Katia</Name>
<Age>22</Age>
</Person>
Ponto importante:
Para serializar em arquivo usamos um stream (Stream, por exemplo FileStream). Se quiser serializar para uma string (por exemplo, para enviar pela rede), use StringWriter:
var serializer = new XmlSerializer(typeof(Person));
using (var sw = new StringWriter())
{
serializer.Serialize(sw, person);
string xmlString = sw.ToString();
Console.WriteLine(xmlString);
}
Desserialização a partir de XML
using (var stream = new FileStream("person.xml", FileMode.Open))
{
// Não esqueça de converter para o tipo correto!
Person restored = (Person)serializer.Deserialize(stream);
Console.WriteLine($"Nome: {restored.Name}, idade: {restored.Age}");
}
Reforçando: XmlSerializer exige que a classe a ser serializada tenha um construtor público sem parâmetros.
4. Trabalhando com arquivos e strings: o que escolher?
Na prática, você pode serializar direto para uma string (para enviar pela rede/armazenar no DB) ou para um arquivo (para armazenamento persistente).
Serializar para string (por exemplo, para enviar via API):
- JSON: use JsonSerializer.Serialize(obj).
- XML: use StringWriter.
Serializar para arquivo (por exemplo, export/backup):
- JSON: salve a string em arquivo com os métodos normais de I/O.
- XML: escreva direto no stream com XmlSerializer.
Exemplo: serializar em arquivo e ler de volta (JSON)
using System.IO;
using System.Text.Json;
Person person = new Person("Tom", 42);
// Serialização para string
string json = JsonSerializer.Serialize(person);
// Grava em arquivo
File.WriteAllText("contact.json", json);
// Leitura do arquivo
string readJson = File.ReadAllText("contact.json");
Person restored = JsonSerializer.Deserialize<Person>(readJson);
Console.WriteLine($"{restored.Name}, idade: {restored.Age}");
5. Comparação JSON vs XML
Visualização do processo
Pra não se confundir, aqui vai o esquema do processo de serialização e desserialização:
flowchart LR
A[Objeto] -- serialização --> B[String/Arquivo/Stream]
B -- desserialização --> C[Objeto]
A -. JSON ou XML .-> B
B -. JSON ou XML .-> C
Você pode imaginar que serialização é "fazer as malas", e desserialização é "desfazer as malas" em casa.
Tabela de comparação
| Funcionalidade | JSON (System.Text.Json) | XML (XmlSerializer) |
|---|---|---|
| Leitura/gravação em string | ++ | + |
| Leitura/gravação em arquivo | ++ | ++ |
| Exige construtor sem parâmetros | Não | Sim |
| Legibilidade humana | ++ | + |
| Esquema de dados rígido (validação) | - | ++ |
| Flexibilidade (atributos de customização) | + | ++ |
| Performance | ++ | + |
| Compatibilidade com a internet | ++ | + |
++ — muito bom, + — ok, - — não suportado
6. Como adicionar serialização ao nosso aplicativo
Imagina que o "Gerenciador de contatos" precisa salvar a lista de contatos em arquivo e restaurá-la depois.
Contexto: temos uma lista de contatos (List<Person>).
List<Person> contacts = new List<Person>
{
new Person("Vasya", 30),
new Person("Petya", 25),
new Person("Masha", 27)
};
// Salvamos todos os contatos — serializamos em JSON
string jsonContacts = JsonSerializer.Serialize(contacts);
File.WriteAllText("contacts.json", jsonContacts);
// Restauramos a lista de contatos
string readContactsJson = File.ReadAllText("contacts.json");
List<Person> restored = JsonSerializer.Deserialize<List<Person>>(readContactsJson);
foreach (var c in restored)
{
Console.WriteLine($"{c.Name}, idade: {c.Age}");
}
O mesmo pode ser feito com XML, mas há particularidades. Para serializar coleções com XmlSerializer normalmente envolve embrulhar a lista em uma classe contêiner (elemento raiz) — assim fica mais fácil controlar o formato e os nomes dos elementos.
7. Erros típicos na serialização e desserialização
Erro #1: incompatibilidade de tipos entre serialização e desserialização.
Serializou List<Person> — deve desserializar também para List<Person>, não para List<object> ou IEnumerable<Person>. Caso contrário dá erro ou resultados inesperados.
Erro #2: tentar serializar campos e propriedades não públicas.
Serializadores comuns (JsonSerializer, XmlSerializer) trabalham com membros públicos. Se a propriedade não tiver getter/setter públicos, o valor pode não ir para o JSON/XML e você vai se perguntar por que está null.
Erro #3: falta de construtor sem parâmetros.
Para XmlSerializer o construtor público padrão é obrigatório. Se não existir — vai lançar exceção na desserialização.
Erro #4: interpretação errada de referências a objetos.
Se um objeto referencia outro, a serialização costuma ser "por valor" (como objeto aninhado). Referências em si não são preservadas, o que pode causar duplicação de dados ou problemas com referências cíclicas.
Erro #5: misturar formatos de serialização.
XML e JSON são formatos diferentes e têm serializadores diferentes. Não dá para passar uma string JSON para XmlSerializer e vice-versa — vai dar erro.
GO TO FULL VERSION