CodeGym /Cursos /C# SELF /Mais fundo no formato binário e seus problemas

Mais fundo no formato binário e seus problemas

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

1. Introdução

Resumindo: o formato binário de serialização transforma um objeto numa sequência de bytes que codificam de forma o mais compacta possível sua estrutura e valores. Imagine que você não está só descrevendo o objeto em palavras (como em JSON ou XML), mas gravando cada bit exatamente como ele é armazenado na memória.

No formato textual os dados são como uma carta para um amigo em russo (cada caractere é compreensível por uma pessoa). No formato binário é mais como código Morse, onde cada ponto e traço é gravado da forma mais curta possível, e ler "na mão" é praticamente impossível.

Esquema: comparação de formatos

Formato Legível por humano Tamanho do arquivo Velocidade (gravação/leitura) Compatibilidade
XML/JSON Sim Grande Mais lento Boa
Binário Não Pequeno Muito rápido Limitada

Como funciona a serialização binária no .NET?

No ecossistema .NET historicamente havia a ferramenta principal para serialização binária — a classe BinaryFormatter. Mas com a evolução da plataforma ela foi considerada insegura e removida do .NET 9. Hoje o padrão são outros caminhos: BinaryWriter/BinaryReader, e para objetos complexos — bibliotecas de terceiros (por exemplo, protobuf-net).

Breve histórico

BinaryFormatter sabia pegar qualquer classe marcada com o atributo [Serializable] e transformar em bytes, e na desserialização reconstruir a estrutura do objeto. Parece mágico, mas isso escondia muitos problemas (vamos falar disso abaixo).

Ferramentas modernas

Para tipos primitivos e estruturas simples é cômodo usar as classes BinaryWriter e BinaryReader. Para objetos complexos — bibliotecas de terceiros (por exemplo, protobuf-net, MessagePack-CSharp e outras).

2. Serialização de primitivos com BinaryWriter

Vamos continuar desenvolvendo nosso aplicativo de estudo. Por exemplo, queremos gravar as configurações do usuário (nome do usuário, quantidade de pontos, horário de login) num arquivo binário.

public class UserProfile
{
    public string Name { get; set; }
    public int Score { get; set; }
    public DateTime LoginTime { get; set; }
}

public static Task SaveUserProfile(UserProfile profile, string filePath)
{
    // Abrimos o arquivo para escrita
    using var stream = new FileStream(filePath, FileMode.Create, FileAccess.Write, FileShare.None);
    using var writer = new BinaryWriter(stream);

    // Gravamos os dados por partes. Primeiro a string, depois o número, depois a data
    writer.Write(profile.Name ?? string.Empty); // string
    writer.Write(profile.Score);                // número inteiro
    writer.Write(profile.LoginTime.ToBinary()); // data convertida para "long"
}

Agora um exemplo de leitura:

public static Task<UserProfile> LoadUserProfile(string filePath)
{
    using var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
    using var reader = new BinaryReader(stream);

    string name = reader.ReadString();
    int score = reader.ReadInt32();
    long dateData = reader.ReadInt64();
    DateTime loginTime = DateTime.FromBinary(dateData);

    return new UserProfile { Name = name, Score = score, LoginTime = loginTime };
}

Características da serialização binária de primitivos

Com BinaryWriter serializamos cada propriedade separadamente. É um modo confiável e previsível: se a estrutura dos dados mudar, você vê isso no código.

3. Problemas da serialização binária clássica

Agora vamos olhar o outro lado da moeda. Por que, afinal, a Microsoft condenou tão fortemente o uso do BinaryFormatter e até proibiu seu uso?

Fragilidade do formato (Schema Evolution Hell)

Os dados binários são fortemente vinculados à estrutura da classe. Mudou a classe (renomeou um campo, adicionou um novo, removeu um antigo) — os arquivos binários antigos ficam ilegíveis. Mudou a ordem das propriedades — também dá problema.

Ilustração:

// Ontem
public class Profile
{
    public string Name;
    public int Score;
}

// Hoje
public class Profile
{
    public string Name;
    public double Rating; // Novo campo adicionado
    public int Score;
}

Ler um arquivo antigo vai causar erro ou vai ler campos com dados "misturados". Ao contrário de JSON ou XML, onde elementos ausentes podem ser ignorados, o formato binário não se adapta às mudanças — é como uma estrada de concreto: se você sair um pouco da rota, a bicicleta cai na hora.

Vulnerabilidades na desserialização

O maior problema do BinaryFormatter é a potencial vulnerabilidade. Se seu software desserializa dados binários recebidos de uma fonte não confiável (por exemplo, de um usuário pela internet), um atacante pode injetar um "objeto" malicioso. No passado isso levou até a execução remota de código na máquina da vítima.

Cross-platform e compatibilidade

O serializador binário é fortemente dependente da representação interna dos dados no .NET e da versão do runtime, do compilador e da arquitetura (por exemplo, x64/ARM). Se você serializar no Windows e tentar desserializar no Linux — surpresas aparecerão! Mesmo entre versões do .NET podem ocorrer incompatibilidades.

Dificuldade de diagnóstico

Quando há problemas com formatos textuais dá pra abrir o arquivo, olhar o conteúdo e entender o que deu errado. Um arquivo binário é um enigma. Tudo que seus olhos veem é um fluxo sem sentido de bytes. "Analisar" esse arquivo é um hobby para poucos.

4. Serialização binária de objetos complexos

Referências

BinaryFormatter conseguia lembrar das relações entre objetos (por exemplo, se duas propriedades apontavam para o mesmo objeto), mas o BinaryWriter e a maioria das bibliotecas de terceiros não fazem essa mágica. Normalmente a serialização acontece no modo "embute um objeto no outro e grava em sequência".

Referências cíclicas

Serializar objetos com referências cíclicas (por exemplo, a "mãe" tem a propriedade Child, e a "criança" tem a propriedade Parent que aponta para o pai) ou causa erro, ou leva a um loop infinito.

Exemplo:

public class Node
{
    public Node? Next { get; set; }
    public Node? Prev { get; set; }
}

Tentar serializar esse objeto "do jeito ingênuo" vai levar à ciclagem.

5. Serialização binária e portabilidade

Qualquer formato binário (especialmente feito à mão) é um formato "só para os seus". Se você pretende trocar dados com outros programas ou armazená-los "pra sempre" — escolha padrões abertos: JSON, XML ou ProtoBuf.

Quando a serialização binária faz sentido?

  • Se os dados vivem dentro de uma única aplicação e são salvos "por curto prazo".
  • Se velocidade e compactação são importantes (por exemplo, para logs grandes ou troca entre serviços dentro de uma mesma ecoesfera).
  • Se você controla estritamente ambos os lados: serialização e desserialização.

Alternativas: protobuf, MessagePack e outras

  • protobuf-net: porta do Google Protocol Buffers para .NET, adequada para trocas cross-platform e compatibilidade.
  • MessagePack-CSharp: implementação rápida de MessagePack para .NET.

Ao contrário do "puro" BinaryWriter, essas bibliotecas implementam schemas, suportam evolução de formato, cross-platform e segurança. Use-as se você planeja qualquer compatibilidade com outros sistemas.

6. Serialização binária "manual"

Se você realmente precisa gravar dados binários (por exemplo, em apps onde performance importa), use BinaryWriter/BinaryReader — e sempre codifique explicitamente a ordem e o tipo dos dados.

Dicas:

  • Sempre grave os dados na mesma ordem em que planeja lê-los.
  • Ao mudar a estrutura do arquivo mantenha um número de versão ou escreva um "magic header" (Magic Header).
  • Adicione o comprimento de strings/arrays antes de gravar os próprios dados.
  • Documente a estrutura do arquivo: caso contrário daqui a um ano você mesmo não vai entender seu formato.

Exemplo: versionamento

// Gravamos o número da versão do formato na primeira posição
writer.Write((byte)1); // Versão 1

writer.Write(profile.Name ?? "");
writer.Write(profile.Score);
writer.Write(profile.LoginTime.ToBinary());

/*
Permite, ao mudar o formato depois, adicionar condições de leitura
*/

7. Erros típicos ao trabalhar com serialização binária

Codificou os campos numa ordem, e na leitura trocou a ordem. Como resultado os valores "deslizam": uma string é lida como int, um int vira data etc.

Gravou 10 objetos, mas lê 11. O fluxo é quebrado: vai ocorrer exceção de fim de arquivo.

Mudou a estrutura da classe e os arquivos binários antigos não podem ser lidos — perde-se todo o histórico de dados.

Esqueceu de tratar exceções ao ler um arquivo importante — o aplicativo cai no primeiro erro no disco (por exemplo, EndOfStreamException).

Tentam trocar arquivos binários entre linguagens sem formato explícito — em 99% dos casos isso é dor na certa.

Desserializam dados recebidos pela rede de usuários desconhecidos — olá, vulnerabilidades! Nunca use BinaryFormatter; valide a entrada e use formatos seguros.

2
Tarefa
C# SELF, nível 43, lição 3
Bloqueado
Gravando dados do usuário em um arquivo binário
Gravando dados do usuário em um arquivo binário
Comentários
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION