Trabalhando com XmlSerializer para serialização em XML

1. Introdução

XML — abreviação de eXtensible Markup Language. Imagine um JSON muito rígido e tagarelo, capaz de repetir várias vezes “sou estruturado, acredita em mim!”. XML é um formato textual onde os dados são embrulhados em tags:

<Player>
  <Name>Aragorn</Name>
  <Health>100</Health>
</Player>

Por que serializar objetos em XML hoje em dia?

• XML continua sendo muito usado na integração entre sistemas grandes (frequentemente “legacy”), onde é necessária não só a estrutura, mas validação por schemas rígidos (XSD).
• XML é frequentemente usado em configurações corporativas (por exemplo, App.config e Web.config em versões antigas do .NET).
• XML cai bem em cenários onde a “auto-descrição” da estrutura dos dados é importante.

Fato interessante: XML foi projetado desde o começo pra ser o mais “extensível” e validável possível; daí vem o nome. Dá pra validar com um schema, coisa que o JSON não tem “out of the box”.

XmlSerializer: o protagonista

No .NET a classe responsável por serializar objetos em XML é System.Xml.Serialization.XmlSerializer.

• Ela transforma propriedades e campos públicos do objeto em elementos XML, e o contrário: a partir do XML reconstrói o objeto.
• Funciona só com tipos e membros públicos.
• Não serializa campos e propriedades privadas — só o que é público!
• Requer que a classe tenha um construtor sem parâmetros para funcionar.

Repare: Se sua classe não cumprir esses requisitos, o XmlSerializer não vai conseguir trabalhar com ela — vai lançar uma exceção durante serialização ou desserialização.

2. Exemplo simples — serializando um objeto em XML

Vamos ver como serializar nossa classe favorita Player em XML.

Passo 1. Descrevendo a classe

public class Player
{
    public string Name { get; set; }
    public int Health { get; set; }
    public bool IsAlive { get; set; }

    // Importante: precisa de um construtor público sem parâmetros!
    public Player() { }

    // Opcional: por conveniência
    public Player(string name, int health, bool isAlive)
    {
        Name = name;
        Health = health;
        IsAlive = isAlive;
    }
}

Passo 2. Serializando para arquivo

using System.Xml.Serialization;

Player aragorn = new Player("Aragorn", 100, true);

// 1. Criamos o serializer para o tipo Player
XmlSerializer serializer = new XmlSerializer(typeof(Player));

// 2. Abrimos o arquivo para escrita (vai criar se não existir)
using FileStream fs = new FileStream("player.xml", FileMode.Create);

// 3. Serializamos o objeto em XML
serializer.Serialize(fs, aragorn);

Resultado (player.xml):

<?xml version="1.0"?>
<Player xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
        xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Name>Aragorn</Name>
  <Health>100</Health>
  <IsAlive>true</IsAlive>
</Player>

Esquema visual do processo mais simples

Objeto na memória  --->  XmlSerializer.Serialize()  --->  Arquivo XML no disco

3. Desserialização — “revivendo” o objeto a partir do XML

Quando precisamos ler um objeto serializado anteriormente, o processo é o inverso:

using FileStream fs = new FileStream("player.xml", FileMode.Open);
XmlSerializer serializer = new XmlSerializer(typeof(Player));
Player player = (Player)serializer.Deserialize(fs);

Console.WriteLine($"Nome: {player.Name}, Saúde: {player.Health}, Vivo: {player.IsAlive}");

Como resultado o programa vai mostrar: Nome: Aragorn, Saúde: 100, Vivo: True

4. Serializar para string — nem só arquivo

Serializando para string

Nem sempre a gente quer serializar em arquivo. Às vezes, por exemplo, precisa enviar o XML como string pela rede ou mostrar na tela.

using System.IO;
using System.Xml.Serialization;

Player player = new Player("Frodo", 42, true);

XmlSerializer serializer = new XmlSerializer(typeof(Player));
StringWriter stringWriter = new StringWriter();
serializer.Serialize(stringWriter, player);

string xmlString = stringWriter.ToString();
Console.WriteLine(xmlString); // A string inteira do XML — na tela!

Desserializando de string

Você também pode desserializar não de um arquivo, mas de uma string:

string xml = "<Player Name=\"Frodo\"><HP>42</HP></Player>";
XmlSerializer serializer = new XmlSerializer(typeof(Player));

using StringReader stringReader = new StringReader(xml);
Player frodo = (Player)serializer.Deserialize(stringReader);
Console.WriteLine(frodo.Name); // Frodo

5. Customizando o XML: atributos para controlar a estrutura

Às vezes o comportamento padrão não te serve. O XML fica muito verboso ou as tags não batem com o que você precisa. Aí entram vários atributos “mágicos” — eles dizem pro serializer como representar os membros da classe.

Os mais úteis:

• [XmlElement]

  — nomeia o elemento.

• [XmlAttribute]

  — transforma o campo em um atributo XML, em vez de elemento.

• [XmlIgnore]

  — exclui a propriedade da serialização.

• [XmlArray]

  e

  [XmlArrayItem]

  — controlam o envelope de coleções.

Exemplo de uso:

public class Player
{
    [XmlAttribute]
    public string Name { get; set; }
    [XmlElement("HP")]
    public int Health { get; set; }
    [XmlIgnore]
    public bool IsTempSessionPlayer { get; set; }
}

XML resultante:

<Player Name="Aragorn">
  <HP>100</HP>
</Player>

Tabela dos principais atributos para serialização

[XmlAttribute]

<Player Name="Aragorn">...</Player>

[XmlElement]

<HP>100</HP>

<Health>100</Health>

[XmlIgnore]

[XmlArray]

<Heroes> ... </Heroes>

[XmlArrayItem]

<Hero>...</Hero>

Exemplo de serialização complexa de uma coleção:

public class GameWorld
{
    [XmlArray("Heroes")]
    [XmlArrayItem("Hero")]
    public List<Player> Players { get; set; } = new List<Player>();
}

XML:

<GameWorld>
  <Heroes>
    <Hero Name="Legolas">
      <HP>90</HP>
    </Hero>
    <!-- ... -->
  </Heroes>
</GameWorld>

Você vai aprender mais sobre customização de XML nas próximas aulas! :P

2

Tarefa

C# SELF, nível 44, lição 2

Bloqueado

Serialização e desserialização de uma lista de objetos

Serialização e desserialização de uma lista de objetos

Abrir