CodeGym /Cursos /C# SELF /Leitura e escrita de XML: XmlSerializer

Leitura e escrita de XML: XmlSerializer

C# SELF
Nível 48, Lição 0
Disponível

1. Introdução

XML (eXtensible Markup Language) — uma linguagem de marcação extensível, formato popular para armazenamento e troca de dados estruturados complexos. Diferente do JSON, o XML não é tão compacto, mas ainda é muito usado em bancos, integrações entre serviços governamentais, documentos e integrações com 1С, SAP, Oracle etc. Alguns dados no Windows e no .NET (por exemplo, configs) ainda são guardados em XML.

Visualmente o XML lembra HTML, só que sem um conjunto fixo de tags como <body> ou <div> — você define a estrutura dos seus elementos. Exemplo:

<Person>
  <FirstName>Ivan</FirstName>
  <LastName>Petrov</LastName>
  <Age>30</Age>
</Person>

Fundamentos do XML e mapeamento para objetos C#

Diferente do JSON, o XML não tem tipos especiais para arrays ou valores booleanos — tudo é representado por elementos e atributos. Estruturas de lista são feitas por elementos repetidos com o mesmo nome.

Para trabalhar bem com XML em C# usamos o mecanismo de serialização/desserialização via XmlSerializer.

Serialização — transformar um objeto C# em uma string XML. Desserialização — o processo inverso: obter um objeto C# a partir de XML.

Isso funciona “out of the box” se suas classes obedecerem a alguns requisitos — vamos ver abaixo.

Por que usar XmlSerializer?

XmlSerializer — ferramenta padrão do .NET (namespace System.Xml.Serialization) para converter objetos em XML e vice-versa. É simples, type-safe e serve bem para import/export de dados, configs, troca entre sistemas e integrações com serviços governamentais.

2. Exemplo: serializando um objeto

Suponha que a gente tenha o modelo de usuário:

public class User
{
    public string FirstName { get; set; }
    public string LastName  { get; set; }
    public int Age          { get; set; }
}

Vamos serializar um objeto para XML:

using System.Xml.Serialization;

User user = new User { FirstName = "Ivan", LastName = "Petrov", Age = 30 };
// Para serialização é necessário o tipo
XmlSerializer serializer = new XmlSerializer(typeof(User));

// Escrevemos o XML em um arquivo
using FileStream fs = new FileStream("user.xml", FileMode.Create);
serializer.Serialize(fs, user);

O que acontece?

- Criamos um objeto da classe User.
- Criamos uma instância de XmlSerializer para o tipo User.
- Abrimos o arquivo com um FileStream.
- Chamamos o método Serialize(), que transforma o objeto em XML e grava no arquivo.

Conteúdo do arquivo user.xml:

<?xml version="1.0"?>
<User xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <FirstName>Ivan</FirstName>
  <LastName>Petrov</LastName>
  <Age>30</Age>
</User>

Simples assim — mínimo de código e XML pronto.

3. Desserialização: lendo o XML de volta para um objeto

Lendo o XML criado e recuperando o objeto C#:

// Abrimos o arquivo XML
using FileStream fs = new FileStream("user.xml", FileMode.Open);
User? loadedUser = serializer.Deserialize(fs) as User;
Console.WriteLine($"{loadedUser?.FirstName} {loadedUser?.LastName}, idade: {loadedUser?.Age}");

O método Deserialize() retorna um object, então fazemos o cast para User (usando as). Se o arquivo estiver correto e bater com o modelo — o objeto é restaurado por completo.

4. Como a serialização funciona: características típicas

A serialização para XML exige seguir algumas regras:

• A classe a ser serializada deve ter um construtor público padrão (public sem parâmetros).

• Propriedades serializáveis precisam ser públicas: ter getter e setter. Membros privados são ignorados.

• Propriedades read-only, estáticas ou abstratas não funcionam.

Se quebrar essas regras você vai receber uma InvalidOperationException com mensagem do tipo "XmlSerializer cannot serialize this type".

5. Serializando coleções: arrays e listas

Se precisar serializar vários usuários — use uma classe wrapper:

public class UserList
{
    public List<User> Users { get; set; } = new List<User>();
}

Vamos criar a coleção e serializar:

UserList users = new UserList
{
    Users = new List<User>
    {
        new User { FirstName = "Ivan", LastName = "Petrov", Age = 30 },
        new User { FirstName = "Maria", LastName = "Ivanova", Age = 25 }
    }
};

XmlSerializer serializer = new XmlSerializer(typeof(UserList));
using FileStream fs = new FileStream("users.xml", FileMode.Create);
serializer.Serialize(fs, users);

Vamos obter XML:

<?xml version="1.0"?>
<UserList xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Users>
    <User>
      <FirstName>Ivan</FirstName>
      <LastName>Petrov</LastName>
      <Age>30</Age>
    </User>
    <User>
      <FirstName>Maria</FirstName>
      <LastName>Ivanova</LastName>
      <Age>25</Age>
    </User>
  </Users>
</UserList>

Dá para serializar diretamente uma List<User>? Dá, mas o elemento raiz vira chamado ArrayOfUser, o que nem sempre é aceitável em integrações.

6. Atributos para controlar a serialização

Com atributos você controla o formato do XML: renomear elementos, serializar como atributos, ignorar campos etc. Atributos úteis: [XmlElement], [XmlAttribute], [XmlArray], [XmlIgnore].

Serializando como atributos

Vamos gravar nome e sobrenome como atributos, e idade como elemento:

public class User
{
    [XmlAttribute]
    public string FirstName { get; set; }

    [XmlAttribute]
    public string LastName { get; set; }

    [XmlElement]
    public int Age { get; set; }
}

Resultado:

<User FirstName="Ivan" LastName="Petrov">
  <Age>30</Age>
</User>

Controlando nomes de elementos

Vamos renomear tags para algo legível:

public class User
{
    [XmlElement("Nome")]
    public string FirstName { get; set; }

    [XmlElement("Sobrenome")]
    public string LastName { get; set; }

    [XmlElement("Idade")]
    public int Age { get; set; }
}

XML resultante:

<User>
  <Nome>Ivan</Nome>
  <Sobrenome>Petrov</Sobrenome>
  <Idade>30</Idade>
</User>

Ignorando propriedades

Se uma propriedade não deve ser serializada — marque com [XmlIgnore]:

public class User
{
    public string FirstName { get; set; }

    [XmlIgnore]
    public string InternalCode { get; set; }
}

7. Serializando hierarquias e objetos aninhados

Classes aninhadas viram elementos XML aninhados facilmente:

public class Address
{
    public string City { get; set; }
    public string Street { get; set; }
}

public class User
{
    public string FirstName { get; set; }
    public Address Address { get; set; }
}
var user = new User
{
    FirstName = "Anna",
    Address = new Address { City = "Neongrad", Street = "Vyazovaya" }
};

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

XML:

<User>
  <FirstName>Anna</FirstName>
  <Address>
    <City>Neongrad</City>
    <Street>Vyazovaya</Street>
  </Address>
</User>

8. Serialização para/de string (sem arquivos)

Serializando para string

using System.Text;

var serializer = new XmlSerializer(typeof(User));
using var stringWriter = new StringWriter();

serializer.Serialize(stringWriter, user);
string xml = stringWriter.ToString();
Console.WriteLine(xml);

Desserializando a partir de string

var xml = "<User><FirstName>Anna</FirstName></User>";
using var stringReader = new StringReader(xml);
User user = (User)serializer.Deserialize(stringReader);
Console.WriteLine(user.FirstName);

9. Exemplo: export e import de dados da aplicação

Export/import da lista de usuários para um arquivo XML:

public static void ExportUsers(UserList users, string path)
{
    var serializer = new XmlSerializer(typeof(UserList));
    using var fs = new FileStream(path, FileMode.Create);
    serializer.Serialize(fs, users);
}

public static UserList ImportUsers(string path)
{
    var serializer = new XmlSerializer(typeof(UserList));
    using var fs = new FileStream(path, FileMode.Open);
    return (UserList)serializer.Deserialize(fs);
}

Aplicações: backup, troca com outros serviços, integrações. Em entrevistas, perguntas sobre XmlSerializer aparecem mais do que parece — especialmente em empresas que trabalham com serviços governamentais e bancos.

10. Erros típicos e detalhes de funcionamento

Se um campo não for public, ele não será serializado.

Propriedades somente de leitura são ignoradas.

Propriedades com tipo de interface ou classe abstrata não são suportadas pelo serializer.

O tipo DateTime é serializado no formato XSD (veja a documentação).

Coleções como arrays e List<T> funcionam de forma previsível, já ObservableCollection<T> pode causar surpresas em sistemas terceiros.

Nuances de encodings: ao escrever via StreamWriter sem especificar encoding, o resultado pode ficar em UTF-16; para compatibilidade normalmente esperam UTF-8 — então especifique a codificação explicitamente.

2
Tarefa
C# SELF, nível 48, lição 0
Bloqueado
Serialização de uma lista de objetos
Serialização de uma lista de objetos
Comentários
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION