c# – Serializzazione e deserializzazione da xml

Molti di noi avranno già affrontato questo argomento, direttamente sul campo e nelle proprie applicazioni. Non sono mai stato un grande fan del xml, ormai è diventato un po’ come il prezzemolo, viene messo ovunque e a volte viene utilizzato anche dove non ce ne sarebbe nessun motivo.

Mi è spesso capitato di dover manutenere applicazioni scritte da altri, dove nella maggior parte dei casi si faceva un uso improprio di questo supporto, ma la cosa più angosciante e terribile era vedere come veniva implementato:parser manuale, tags hardcoded, codice completamente decentralizzato e sparso per tutto il progetto. Tutta questa bella insalata, rende praticamente impossibile qualsiasi tipo di manutenzione e/o modifica in tempi brevi che come di prassi quasi tutti i clienti pretendono.

In tutte quelle situazioni, dove un formato xml viene utilizzato come data interchange, Microsoft ci mette a disposizione un ottimo tool: XSDOObjectGen

lo scopo principale di questa semplice utility è quello di generare una classe in c# o vb.net partendo da una definizione del nostro xml da trattare, per mezzo del suo descrittore xsd. Alcune volte sarà necessario ritoccare a mano il codice automaticamente generato. Ma questo tipo di intervento è sicuramente più rapido che scriversi a manina tutto quanto.

Affiancando a questo codice generato dal tool di Microsoft, un semplice helper per la serializzazione e deserializzazione di questi oggetti, avremo il pieno controllo del nostro formato xml, potendolo utilizzare come un oggetto qualsiasi all’interno delle nostre logiche di implementazione.

Una possibile soluzione per queste serializzazioni e deserializzazioni sui vostri oggetti potrebbe essere la seguente:

/// <summary>
/// To convert a Byte Array of Unicode values (UTF-8 encoded) to a complete String.
/// </summary>
/// <param name="characters">Unicode Byte Array to be converted to String</param>
/// <returns>String converted from Unicode Byte Array</returns>
private static string UTF8ByteArrayToString(byte[] characters)
{
    UTF8Encoding encoding = new UTF8Encoding();
    string constructedString = encoding.GetString(characters);
    return (constructedString);
}

/// <summary>
/// Converts the String to UTF8 Byte array and is used in De serialization
/// </summary>
/// <param name="pXmlString"></param>
/// <returns></returns>
private static Byte[] StringToUTF8ByteArray(string pXmlString)
{
    UTF8Encoding encoding = new UTF8Encoding();
    byte[] byteArray = encoding.GetBytes(pXmlString);
    return byteArray;
}

/// <summary>
/// Serialize an object into an XML string
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <returns></returns>
public static string SerializeObject<T>(T obj)
{
    try
    {
        Type t = obj.GetType();
        PropertyInfo[] infos = t.GetProperties();
        string xmlString = null;
        MemoryStream memoryStream = new MemoryStream();
        XmlSerializer xs = new XmlSerializer(typeof(T));
        XmlTextWriter xmlTextWriter = new XmlTextWriter(memoryStream, Encoding.UTF8);
        xs.Serialize(xmlTextWriter, obj);
        memoryStream = (MemoryStream)xmlTextWriter.BaseStream;
        xmlString = UTF8ByteArrayToString(memoryStream.ToArray()); return xmlString;
    }
    catch (Exception ex)
    {
        return ex.Message;
    }
}

/// <summary>
/// Reconstruct an object from an XML string
/// </summary>
/// <param name="xml"></param>
/// <returns></returns>
public static T DeserializeObject<T>(string xml)
{
    XmlSerializer xs = new XmlSerializer(typeof(T));
    MemoryStream memoryStream = new MemoryStream(StringToUTF8ByteArray(xml));
    XmlTextWriter xmlTextWriter = new XmlTextWriter(memoryStream, Encoding.UTF8);
    return (T)xs.Deserialize(memoryStream);
}