In questo articolo vedremo come effettuare la serializzazione di una classe, in particolare da un oggetto con dei valori, verrà generato un file XML.
La serializzazione degli oggetti può tornare utile per la gestione dei dati interscambio, caricamento e gestione di dati, o per altre funzionalità a livello applicativo.
Il codice utilizzato in questo articolo si può applicare in ambiente Windows Application e Web Application, in particolare con la tecnologia Asp.Net.
Il framework utilizzato è la versione 5, e l’ambiente di sviluppo, Visual Studio 2019 Community.
Vedremo come creare file XML composti, con sotto nodi che rappresentano classi di proprietà, il tutto come mostrato in figura 1.
Figura 1 -La creazione del file XML
Creazione del progetto
Si crea un nuovo progetto di tipo “App Windows Forms”, ma come anticipato il codice si può utilizzare anche in ambiente web, andiamo avanti e selezioniamo la voce 5 del Framework.
Nella form che viene aperta, aggiungiamo tre pulsanti, uno avrà la proprietà “Name” impostata su “BtnSingleClasse” in questo pulsante ci sarà il codice per la creazione di un file XML semplice per una classe singola con un solo valore. Un altro pulsante avrà impostata la proprietà “Name” con il valore “BtnClasse” in questo pulsante, il codice sarà quello di creare n dati di una lista di oggetto, ed infine l’ultimo pulsante, avrà impostato la proprietà “Name” con il valore “BtnClasseComposta” un questa avremo una classe con le proprietà di altre classi.
Creato e sistemato il progetto, non ci resta che scrivere il codice.
Stesura del codice
Dopo aver impostato la form con i tre pulsante per scoprire alcuni scenari di tecnica di serializzazione, non resta che scrivere il codice.
Passiamo in visualizzazione codice e scriviamo una semplice classe, denominata “Anagrafica” con due proprietà di tipo “String” quali Nome e Cognome.
Qui di seguito si riporta il frammento di codice delle suddette operazioni.
C#
[Serializable]
public class Anagrafica
{
public string Nome { get; set; }
public string Cognome { get; set; }
}
Prima di passare al frammento di codice per la creazione del file XML, occorre aggiungere lo spazio dei nomi per la gestione della serializzazione, dei file e dei file XML. Qui di seguito gli spazio dei nomi per utilizzare varie classi.
C#
using System.Xml.Serialization;
using System.IO;
using System.Xml.Linq;
Terminata la creazione della classe e aggiunti i vari namespace, che vanno inseriti in alto sopra ad ogni dichiarazione dove sono presenti altri spazio dei nomi, passiamo in visualizzazione grafica.
Facciamo doppio click sul pulsante con la proprietà denominata “BtnSingleClasse” in modo da passare in visualizzazione codice nell’evento click del pulsante.
Il frammento di codice qui di seguito, crea un oggetto della classe “Anagrafica” imposta alcuni valori alle proprietà, effettua la serializzazione e salva i dati in formato XML. Le modalità di salvataggio sono due, il primo caso, tramite la classe per la gestione dei file, nel secondo caso, tramite classi per la gestione XML.
Sono lo stesso modo, è solo una tecnica per far vedere al lettore i vari modi di salvataggio dei dati della classe.
Qui di seguito il frammento di codice delle suddette operazioni.
C#
private void BtnSingleClasse_Click(object sender, EventArgs e)
{
Anagrafica anagrafica = new Anagrafica();
anagrafica.Cognome = "Mattei";
anagrafica.Nome = "Emanuele";
XmlSerializer xmlSerializer = new XmlSerializer(anagrafica.GetType());
string xmlGenerato = "";
using (MemoryStream memoryStream = new MemoryStream())
{
xmlSerializer.Serialize(memoryStream, anagrafica);
memoryStream.Position = 0;
xmlGenerato = new StreamReader(memoryStream).ReadToEnd();
byte[] arrayBytes = memoryStream.ToArray();
File.WriteAllBytes("C:\\Varie\\FileXMLGenerato.xml", arrayBytes);
}
XElement xElement = XElement.Parse(xmlGenerato);
xElement.Save(@"C:\Varie\FileXMLGenerato2.xml");
}
Provate ad eseguire il codice e poi aprire il file xml creato, il risultato sarà come mostrato in figura 2.
Figura 2 – Il file creato con un solo dato
Passiamo in visualizzazione grafica della nostra form, e facciamo doppio click sul pulsante che ha impostato la proprietà “Name” con il valore “BtnClasse”, in modo che passiamo in visualizzazione codice nell’evento click di questo pulsante.
Qui di seeguito si riporta il codice dell'evento click di questo pulsante.
C# private void BtnClasse_Click(object sender, EventArgs e)
{
List<Anagrafica> anagrafiche = new List<Anagrafica>();
Anagrafica anagrafica = new Anagrafica();
anagrafica.Cognome = "Mattei";
anagrafica.Nome = "Emanuele";
anagrafiche.Add(anagrafica);
anagrafica = new Anagrafica();
anagrafica.Cognome = "Luigi";
anagrafica.Nome = "Cristaldi";
anagrafiche.Add(anagrafica);
XmlSerializer xmlSerializer = new XmlSerializer(anagrafiche.GetType());
string xmlGenerato = "";
using (MemoryStream memoryStream = new MemoryStream())
{
xmlSerializer.Serialize(memoryStream, anagrafiche);
memoryStream.Position = 0;
xmlGenerato = new StreamReader(memoryStream).ReadToEnd();
byte[] arrayBytes = memoryStream.ToArray();
File.WriteAllBytes("C:\\Varie\\FileXMLGenerato.xml", arrayBytes);
}
XElement xElement = XElement.Parse(xmlGenerato);
xElement.Save(@"C:\Varie\FileXMLGenerato2.xml");
}
Nell’esempio precedente, si è creato una list dell’oggetto di tipo Anagrafica, in questo modo i dati presenti nel file XML sono due record, il risultato sarà come mostrato in figura 3.
Figura 3 – La creazione del file XML con più record
L’ultimo esempio di utilizzo della tecnica di serializzazione riguarda la possibilità di utilizzare una classe con proprietà di altre classi.
Si crea una classe che avrà una proprietà di tipo string, ed un’altra proprietà, come list della classe anagrafica.
Qui di seguito si riporta il frammento di codice delle suddette operazioni.
C#
[Serializable]
public class Azienda
{
public string NomeAzienda { get; set; }
public List<Anagrafica> anagrafiche { get; set; }
}
Si crea un’altra classe, che sarà utilizzata nel nostro esempio, che avrà una proprietà della classe appena creata, ossia della classe “Azienda” ed una proprietà di tipo “string” che non sarà visualizzato nel file XML.
Qui di seguito il frammento di codice delle suddette operazioni.
C#
[Serializable]
public class Dati
{
public string Dato { get; set; }
public Azienda azienda { get; set; }
}
Terminata la creazione delle classe, passiamo in visualizzazione grafica, e facciamo doppio click sul pulsante con la proprietà name impostata con il valore “BtnClasseComposta”, in modo che passiamo in visualizzazione codice dell’evento click del pulsante.
In questo evento vengono impostati le varie proprietà, anche quella di tipo list della classe e poi generato il file XML.
Si riporta il frammento di codce dell'evento click di questo pulsante.
C#
private void BtnClasseComposta_Click(object sender, EventArgs e)
{
Dati dati = new Dati();
dati.azienda = new Azienda();
dati.azienda.NomeAzienda = "Iprogrammatori";
Anagrafica anagrafica = new Anagrafica();
anagrafica.Cognome = "Mattei";
anagrafica.Nome = "Emanuele";
dati.azienda.anagrafiche = new List<Anagrafica>();
dati.azienda.anagrafiche.Add(anagrafica);
anagrafica = new Anagrafica();
anagrafica.Cognome = "Luigi";
anagrafica.Nome = "Cristaldi";
dati.azienda.anagrafiche.Add(anagrafica);
XmlSerializer xmlSerializer = new XmlSerializer(dati.GetType());
string xmlGenerato = "";
using (MemoryStream memoryStream = new MemoryStream())
{
xmlSerializer.Serialize(memoryStream, dati);
memoryStream.Position = 0;
xmlGenerato = new StreamReader(memoryStream).ReadToEnd();
byte[] arrayBytes = memoryStream.ToArray();
File.WriteAllBytes("C:\\Varie\\FileXMLGenerato.xml", arrayBytes);
}
XElement xElement = XElement.Parse(xmlGenerato);
xElement.Save(@"C:\Varie\FileXMLGenerato2.xml");
}
Il risultato del file XML generato sarà come quello mostrato in figura 1.
Conclusioni
L’articolo ha voluto fornire al lettore alcune tecniche di serializzazione per trasformare una classe in un file XML.
La serializzazione è una tecnica da utilizzare in alcuni scenari dello sviluppo applicativo, soprattutto nella gestione dei dati di interscambio con altri sistemi o per rendere le applicazioni personalizzabili in un determinato contesto.
Una tecnica usata anche dalle versioni precedenti del framework ed in vari ambiti web o Windows Application.