Serializando Objetos em .NET

Nesse artigo, vamos detalhar o que é e como funciona o processo de serialização/desserialização de objetos utilizando da tecnologia .NET

por Andrey Sanches

Com o lançamento da tecnologia .NET, há muito a se estudar e pesquisar.

Algumas das muitas técnicas que envolvem a tecnologia ainda não foram exploradas por completo e talvez algumas nem sejam com tanto detalhamento.

Nesse artigo, vamos demonstrar uma dessas técnicas, detalhar o que é e como funciona o processo de serialização/desserialização de objetos utilizando da tecnologia .NET

Resumidamente, o processo de serialização consiste em armazenarmos o estado de um objeto para fazer uso dele posteriormente para qualquer necessidade.
Desserialização é o processo inverso, onde é usado o estado do objeto que foi serializado para criarmos uma nova instância desse objeto a partir do formato serializado.

Uma das maiores vantagens do processo de serialização/desserialização, é o fato de que os objetos podem trafegar entre sistemas e até redes diferentes.

Como funciona o processo de Serialização?

Quando falamos em serialização de objetos, estamos buscando uma solução para trafegar nossos objetos entre sistemas, aplicações WEB e até mesmo entre redes.
Serializar objetos é manter o estado do mesmo para usá-lo em uma das dificuldades citadas acima, mas temos que ter consciência de alguns pontos perigosos, como por exemplo, estar disponibilizando informações do seu objeto indesejadamente, para isso, vamos detalhar a seguir o funcionamento do processo de Serializar.

Existem duas formas para serializar/desserializar objetos em .NET.

A primeira é utilizando das classes que estão no NameSpace System.Runtime.Serialization, esse modo trabalha com serialização em dois formatos: Binário ou XML/SOAP. A segunda forma de serializar é utilizando as classes nativas do .NET FrameWork, no caso, as classes do namespace System.Xml.Serialization.
As duas formas trabalham diferentemente, mas nesse artigo vamos abordar somente a primeira forma.

Esse processo, serializa os objetos utilizando os atributos do tipo private da sua classe no formato em que for especificado, no caso XML/SOAP ou Binário.

Para que uma classe possa ser serializada, é necessário informar o atributo <Serializable()> em [VB.NET] ou [Serializable()] em [C#] antes da declaração da classe, isso faz com que o FrameWork “ permita” que essa classe seja serializada e dessa forma mantendo o estado do objeto no formato especificado.

O código abaixo mostra a classe Pedido.cs preparada para ser serializada, demonstra também quais atributos vão ser e quais não vão ser serializados.

///<summary> /// Classe que identifica um Cliente ///</summary> [Serializable()]public class Pedido { private int _id; private DateTime _data; [NonSerialized]private string _obs; private Cliente _cliente; ///<summary> /// Método construtor da Classe Pedido ///</summary> ///<param name="id">id do pedido</param> ///<param name="data">data do pedido</param> ///<param name="obs">observações gerais do pedido</param> ///<param name="cli">Cliente do pedido</param> public Pedido(int id, DateTime data, string obs, Cliente cli) { _id = id; _data = data; _obs = obs; _cliente = cli; } ///<summary> /// Property que retorna o ID do Pedido ///</summary> public int id { get{return _id;} } ///<summary> /// Property que retorna a data do Pedido ///</summary> public DateTime data { get{return _data;} } ///<summary> /// Property que retorna uma observaçao do Pedido ///</summary> public string obs { get{return _obs;} } ///<summary> /// Property que retorna o Cliente (o objeto inteiro será serializado) ///</summary> public Cliente cliente { get{return _cliente;} } }

Você pode notar facilmente o atributo _obs marcado para não ser serializado. Essa técnica é muito útil quando se tem um objeto e algumas das informações não devem ser serializadas, para isso, é só marcar o atributo (como mostra o código acima) que o mesmo não será publicado.

Vemos agora o código da classe Cliente.cs onde demonstramos a estrutura que é serializada junto ao objeto Pedido (Pedido.xml).

///<summary> /// Classe que identifica um Cliente ///</summary> [Serializable()]public class Cliente { private int _id; private string _nome; [NonSerialized]private double _limiteCredito; ///<summary> /// Método Construtor da Classe Cliente ///</summary> ///<param name="id">id do cliente</param> ///<param name="nome">nome do cliente</param> ///<param name="limite">limite de crédito do cliente</param> public Cliente(int id, string nome, double limite) { _id = id; _nome = nome; _limiteCredito = limite; } ///<summary> /// Property que retorna o ID do Cliente ///</summary> public int id { get{return _id;} } ///<summary> /// Property que retorna o Nome do Cliente ///</summary> public string nome { get{return _nome;} } ///<summary> ///Property que retona o limite de Credito do Cliente ///</summary> public double limiteCredito { get{return _limiteCredito;} } }

Da mesma forma, a classe é marcada para ser serializada e o atributo _limiteCredito (uma informação confidencial) não será publicada na serialização.
Em seguinda vamos conferir como é feito a serialização, Não esqueça de importar os seguintes namespaces.

Obs: para utilizar do formato Soap é necessário importar a dll System.Runtime.Serialization.Formatters.Soap (nativa do FrameWork)

using System.Runtime.Serialization; using System.Runtime.Serialization.Formatters.Soap; using System.IO; //define o formato criando uma instância da classe SoapFormatter IFormatter formato = new SoapFormatter(); //definindo o Stream onde será salvo o xml com o estado do objeto // (neste caso, será criado na pasta Debug/Release do projeto Stream file = new FileStream("Pedido.xml", FileMode.Create,FileAccess.Write, FileShare.None); //criando a instância do pedido que será serializado Pedido ped = new Pedido(10, DateTime.Now, "Pedido devolvido por falta de produtos na entrega", new Cliente(10, "Linha de Código", 15)); //agora sim, vamos serializar o objeto formato.Serialize(file, ped); //Stream fechado file.Close();

O Processo é relativamente simples: define-se o formato, o destino para onde irá o .xml com o estado do objeto, serializa o objeto informando o
stream e o objeto que deseja serializar e por fim fecha-se o stream.

Para fazer o mesmo processo utilizando o formato binário, troca-se somente a instância para BinaryFormatter , o namespace para
“Binaty” e nomeando o arquivo para Pedido.bin.

Abaixo, podemos ver o arquivo Pedido.xml gerado a partir da serialização:

Veja que os atributos de Pedido foram serializados normalmente com excessão do atributo _obs e sem que tenhamos que codificar nada, serializou também o objeto Cliente que está em Pedido, da mesma o atributo _limiteCredito não foi serializado. No xml a referência para atributos tipados é feita a partir do atributo xml href , no caso #ref-3 e logo abaixo as especificações da #ref-3 com todos os valores.

Como funciona o processo de Desserialização?

Simples como o processo de serialização, desserializar um objeto é exatamente o inverso.
Temos o arquivo Pedido.xml que foi serializado e “carregaremos” em um objeto do Tipo Pedido (vazio) e o mesmo terá todo o conteúdo do arquivo .xml, veja abaixo:

using System.Runtime.Serialization; using System.Runtime.Serialization.Formatters.Soap; using System.IO; //definindo o formato e criando uma instância da classe SoapFormatter IFormatter formato = new SoapFormatter(); //definindo o Stream de onde será lido o arquivo .xml Stream file = new FileStream("Pedido.xml", FileMode.Open ,FileAccess.Read , FileShare.Read ); //criando uma variável do tipo Pedido (vazia) Pedido ped; //agora sim, vamos desserializar o objeto ped = (Pedido)formato.Deserialize(file); //Stream fechado file.Close();

Da mesma forma que serializar, muda-se somente alguns valores, como os parâmetros da criação do FileStream, a criação de uma variável do tipo Pedido e a execução do método Deserialize passando por parâmetro o objeto stream e convertendo para o tipo Pedido.
Veja abaixo o conteúdo do objeto ped após a desserialização.

Conclusão

É muito fácil utilizar o processo de serialização/desserialização de objetos em .NET, basta identificar a necessidade e aplicar a técnica de forma correta sempre pensando em fazer uma aplicação de qualidade.

Para sugestões/críticas envie um email para andrey.sanches@uol.com.br

Até o próximo