O XML (Extensible Markup Language) é uma linguagem de marcação amplamente utilizada para armazenar e transportar dados de forma estruturada. Sua principal vantagem é a flexibilidade na representação de dados e a capacidade de ser lido por diferentes sistemas e plataformas. No desenvolvimento de software, XML é frequentemente utilizado para troca de dados entre sistemas e persistência de configurações.
Conceitos básicos de XML
O XML usa tags para definir a estrutura de dados, com a possibilidade de criar um formato hierárquico. Um arquivo XML pode ser representado por uma série de elementos (tags) com atributos e valores:
<livros>
<livro>
<titulo>O Pequeno Príncipe</titulo>
<autor>Antoine de Saint-Exupéry</autor>
<ano>1943</ano>
</livro>
<livro>
<titulo>1984</titulo>
<autor>George Orwell</autor>
<ano>1949</ano>
</livro>
</livros>
O exemplo acima mostra uma estrutura XML contendo uma tag “<livros>” que contém vários “<livro>”, e cada “<livro>” com elementos como “<titulo>”, “<autor>” e “<ano>”. Se fizermos uma analogia com C# teriamos uma coleção de “livros” que possui vários objetos “livro” e cada objeto “livro”, possui as propriedades “titulo”, ”autor”, ”ano”.
Serializando e desserializando objetos com XmlSerializer
No C#, a classe “XmlSerializer” é usada para converter objetos em XML e vice-versa. Vamos ver como serializar e desserializar objetos.
Serialização
A serialização é o processo de converter um objeto C# em um formato XML. Para isso podemos criar uma classe C#:
public class Livro
{
public string Titulo { get; set; }
public string Autor { get; set; }
public int Ano { get; set; }
}
Para serializar um objeto “Livro” em XML, usamos o seguinte código:
using System.IO;
using System.Xml.Serialization;
var livro = new Livro
{
Titulo = "O Pequeno Príncipe",
Autor = "Antoine de Saint-Exupéry",
Ano = 1943
};
XmlSerializer serializer = new XmlSerializer(typeof(Livro));
using (StringWriter writer = new StringWriter())
{
serializer.Serialize(writer, livro);
string xml = writer.ToString();
Console.WriteLine(xml);
}
No código acima, após criar um objeto do tipo “Livro”, criamos um objeto do tipo “XmlSerializer”, passando o tipo “Livro” para indicar que será serializado. Em seguida, utilizamos um “StringWriter”, que é um tipo de “TextWriter” para armazenar o XML em memória. O “using” é usado para garantir que o “StringWriter” seja descartado corretamente.
O “serializer.Serialize” converte o objeto “livro” em uma string XML, que é armazenada no “StringWriter”. Finalmente, a string XML gerada é recuperada com “ToString()” e exibida no console.
A saída será um arquivo XML representando o objeto:
<Livro>
<Titulo>O Pequeno Príncipe</Titulo>
<Autor>Antoine de Saint-Exupéry</Autor>
<Ano>1943</Ano>
</Livro>
Desserialização
A desserialização é o processo de converter um XML de volta para um objeto C#. Para isso, usamos o método “Deserialize” da classe “XmlSerializer”.
string xml = @"<Livro>
<Titulo>O Pequeno Príncipe</Titulo>
<Autor>Antoine de Saint-Exupéry</Autor>
<Ano>1943</Ano>
</Livro>";
XmlSerializer serializer = new XmlSerializer(typeof(Livro));
using (StringReader reader = new StringReader(xml))
{
Livro livro = (Livro)serializer.Deserialize(reader);
Console.WriteLine($"Título: {livro.Titulo}, Autor: {livro.Autor}, Ano: {livro.Ano}");
}
No código acima, temos uma string xml armazenada na variável “xml” que contém um XML representando um objeto “Livro”. Criamos um “XmlSerializer” passando o tipo “Livro” para indicar que queremos desserializar o XML para esse tipo de objeto. Em seguida, utilizamos um “StringReader”, que é um tipo de “TextReader” usado para ler o XML armazenado na variável “xml”. A chamada “serializer.Deserialize(reader)” converte o XML em um objeto “Livro”, e os valores do objeto são exibidos no console.
A saída será:
“Título: O Pequeno Príncipe, Autor: Antoine de Saint-Exupéry, Ano: 1943”
Manipulando arquivos XML com o XDocument
Além de serializar e desserializar objetos, também podemos manipular diretamente arquivos XML usando as classes “XDocument” que é parte do LINQ to XML, que oferece uma maneira moderna e fluente de trabalhar com XML.
var livro = new Livro{
Titulo = "O Pequeno Príncipe",
Autor = "Antoine de Saint-Exupéry",
Ano = 1943
};
XDocument doc = new XDocument(
new XElement("Livros",
new XElement(nameof(Livro),
new XElement(nameof(Livro.Titulo), livro.Titulo),
new XElement(nameof(Livro.Autor), livro.Autor),
new XElement(nameof(Livro.Ano), livro.Ano)
)
)
);
doc.Save(@"D:\livro.xml");
No código acima nós estamos transformando um objeto manualmente para XML, e para isso, após criar o objeto “Livro”, o código cria um documento XML utilizando as classes “XDocument” e “XElement”. O “XDocument” é usado como o contêiner principal do documento XML, enquanto o “XElement” representa os elementos do XML.
O primeiro parâmetro de “XElement” define a tag do elemento, e os parâmetros seguintes contêm os elementos filhos que estarão dentro desse elemento (new XElement(“Tag”, “Elementos”)). Nesse caso, a tag raiz é chamada “Livros”, e dentro dela, há um elemento chamado “Livro”, que contém elementos como “Titulo”, “Autor” e “Ano”.
O uso do “nameof” garante que os nomes dos elementos XML correspondam exatamente aos nomes das propriedades da classe. Essa abordagem melhora a consistência e flexibilidade do código.
Por fim, o método “Save” é utilizado para armazenar o XML gerado em um arquivo específico, permitindo que os dados sejam persistidos de forma eficiente e possam ser utilizados posteriormente.
Lendo e editando um documento XML
Agora vamos ver como é possível ler e editar um arquivo XML.
Leitura
XDocument doc = XDocument.Load(@"D:\livro.xml");
foreach (var livro in doc.Descendants("Livro"))
{
Console.WriteLine($"Título: {livro.Element("Titulo").Value}, Autor: {livro.Element("Autor").Value}, Ano: {livro.Element("Ano").Value}");
}
Para realizar a leitura de um arquivo XML, podemos utilizar o método “Load” da classe “XDocument”. Quando fornecemos o caminho do arquivo XML como parâmetro, o método carrega o arquivo XML em memória, permitindo que possamos manipulá-lo.
Após carregar o documento, podemos usar o método “Descendants” para acessar todos os elementos de um determinado tipo dentro do XML. No caso do nosso código, estamos procurando por todos os elementos “<Livro>”, que são os registros de livros dentro do XML.
Dentro do “foreach”, percorremos cada elemento “<Livro>”. Para acessar os dados de cada livro, utilizamos o método “Element”, passando o nome do elemento que queremos acessar (por exemplo, “titulo” ou “autor”). O método “Element” retorna um “XElement”, e a propriedade “Value” é usada para obter o valor contido nesse elemento.
Edição
doc.Descendants("Livro").First().Element("Ano").Value = "1945";
doc.Save(@"D:\livro.xml");
Para editar o XML, usamos o método “Descendants” para localizar todos os elementos “<Livro>”.
Em seguida, o método “First()” é utilizado para acessar o primeiro elemento da coleção retornada. O “First()” é útil quando você quer alterar apenas o primeiro elemento que corresponde ao critério (neste caso, o primeiro “<Livro>”). Se desejasse acessar outro elemento específico, poderia usar métodos como “Where” para filtrar os elementos com base em suas propriedades.
O método “Element(“Ano”)” é utilizado para acessar o subelemento “<Ano>”, e com “Value = “1945””, alteramos o valor do ano de “1943” para “1945”.
Por fim, o método “Save” salva a alteração no arquivo XML especificado.
Acelere a sua carreira conosco!
Se você é Desenvolvedor .NET Júnior e quer acelerar sua carreira até nível Pleno com salário de R$7k+, ou mesmo busca a primeira vaga, conheça a Mentoria .NET Start: Clique aqui
Se é Desenvolvedor .NET Pleno ou Sênior e quer virar referência técnica em sua equipe e mercado, com salário de R$10k+, conheça a Mentoria .NET Expert: Clique aqui
Conclusão
Trabalhar com XML em C# no .NET proporciona uma abordagem fácil e flexível para manipulação de dados estruturados. Ferramentas como “XmlSerializer” e “XDocument” oferecem soluções eficientes tanto para serialização quanto para edição de documentos XML, permitindo que você trabalhe com dados de maneira intuitiva e sem complexidade. Essa combinação de recursos não apenas facilita o processo de manipulação de XML, mas também torna a integração com sistemas complexos mais confiável, escalável e de fácil manutenção.