Serializing and deserializing classes in C#

When we send data to a different system, is usual to use xml formats. If we use C # as a programming language, there are some framework methods that help us a lot. In the version 3.5 of the framework we can use the "exstension Method" and can equip any class of additional methods, in relation to the type.
Combining the two things you can write methods for serializing and deserializing classes and make them generic.
For example:

With the following "Extension Method"

        /// <summary>
        /// Serializes to XML.
        /// </summary>
        /// <param name="value">The object to serialize.</param>
        /// <returns>
        /// a XElement rappresenting the class serialization
        /// </returns>
        public static XElement SerializeToXML(this object value)
        {
            XmlSerializer x = new XmlSerializer(value.GetType());
            XDocument doc = new XDocument();
            using (XmlWriter xw = doc.CreateWriter())
            {
                x.Serialize(xw, value);
                xw.Close();
            }
            return doc.Root;
        }


        /// <summary>
        /// Deserializes the specified string to an object of type T.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="value">The value containing an xml.</param>
        /// <returns>
        /// an object of type T
        /// </returns>
        public static T Deserialize<T>(this string value)
        {
            XElement xElement = XElement.Parse(value);

            return xElement.Deserialize<T>();

        }

        /// <summary>
        /// Deserializes the specified string to an object of type T.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="value">The value containing an xml.</param>
        /// <returns>
        /// an object of type T
        /// </returns>
        public static T Deserialize<T>(this XElement value)
        {
            XmlSerializer x = new XmlSerializer(typeof(T));
            T result;
            using (XmlReader xr = value.CreateReader())
            {
                result = (T)x.Deserialize(xr);
                xr.Close();
            }
            return result;
        }

In this way, you'll just have to serialize a class writing

MyClass a = new MyClass();

XElement xml = a.SerializeToXML();
MyClass b = xml.Deserialize<MyClass>(xml)

Serializzazione e deserializzazione in c#

Nell'interscambio di dati è usuale utilizzare formati xml. Se usiamo c# come linguaggio di programmazione, ci sono dei metodi del framework che ci aiutano parecchio. Inoltre dalla versione 3.5 del framework potete usare gli "Exstension Method", ovvero potete dotare qualsiasi classe di metodi aggiuntivi, in relazione al tipo.
Combinando le due cose potete scrivere dei metodi per la serializzazione e deserializzazione di classi e renderli generici. Ad esempio:

Con i seguenti "Extension Method"

        /// <summary>
        /// Serializes to XML.
        /// </summary>
        /// <param name="value">The object to serialize.</param>
        /// <returns>
        /// a XElement rappresenting the class serialization
        /// </returns>
        public static XElement SerializeToXML(this object value)
        {
            XmlSerializer x = new XmlSerializer(value.GetType());
            XDocument doc = new XDocument();
            using (XmlWriter xw = doc.CreateWriter())
            {
                x.Serialize(xw, value);
                xw.Close();
            }
            return doc.Root;
        }


        /// <summary>
        /// Deserializes the specified string to an object of type T.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="value">The value containing an xml.</param>
        /// <returns>
        /// an object of type T
        /// </returns>
        public static T Deserialize<T>(this string value)
        {
            XElement xElement = XElement.Parse(value);

            return xElement.Deserialize<T>();

        }

        /// <summary>
        /// Deserializes the specified string to an object of type T.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="value">The value containing an xml.</param>
        /// <returns>
        /// an object of type T
        /// </returns>
        public static T Deserialize<T>(this XElement value)
        {
            XmlSerializer x = new XmlSerializer(typeof(T));
            T result;
            using (XmlReader xr = value.CreateReader())
            {
                result = (T)x.Deserialize(xr);
                xr.Close();
            }
            return result;
        }

In questo modo, per serializzare una classe dovrete semplicemente scrivere

MyClass a = new MyClass();

XElement xml = a.SerializeToXML();
MyClass b = xml.Deserialize<MyClass>(xml)

Come esporre in xml i dati delle proprie applicazioni

Sembra una cosa semplice. E difatti lo è. Oggigiorno, indipendentemente dal linguaggio di programmazione utilizzato, esporre i propri dati in formato xml è semplicissimo. Il linguaggio xml è poi molto adatto all'interscambio di dati, in quanto semplice e autoesplicante.

Allora perché ci sono sempre un sacco di incomprensioni e problemi quando 2 aziende devono scambiarsi informazioni? Perché i programmatori delle suddette aziende passano settimane e telefonarsi per cercare di far funzione quelle benedette interfacce di scambio dati?

Perché non vengono seguite poche semplici regole. Il linguaggio XML non è magia. Non si spiega da solo. Come una qualsiasi lingua parlata, se le parole vengono messe insieme senza senso, l'ascoltatore non può recepire il messaggio. Inoltre non prendiamoci in giro: difficilmente il programmatore che scrive l'algoritmo di export XML ha poi anche il tempo di scrivere una documentazione per chi utilizzerà il file generato. Cerchiamo quindi di generare file che non necessitino di spiegazioni.

Semplici regole quando si scrive un file XML:

1. Scrivete tutto in una lingua (preferibilmente in inglese).
   Sembra una cosa da poco, ma chi leggerà il vostro file lo leggerà in maniera più veloce, senza dover interpretare ogni parola
2. Nominate nodi ed attributi in maniera estesa. Non lasciate alla fantasia di chi utilizzata il vostro XML il dover capire se "SecCode" sia "Codice Secondario", "Codice Settore", o altro.
3. Le date e le cifre vanno scritte in formato inglese. In questo modo i parser dei vari linguaggi di programmazione possono interpretarle correttamente
4. Sfruttate gli attributi per tutte le informazioni che non hanno altre informazioni collegate. Questo vi permette di risparmiare dei caratteri e soprattutto permette a chi legge l'xml di capire quali informazioni possono averne altre di collegate.
5. Scegliete se scrivere tutto in "Camel Case" o in "Pascal Case"
   
   
   es

<customers>
  <customer key="100" name="Marco" surname="Rossi">
    <orders>
      <order key="200" date="2010-01-01" total="10.00" >
        <product title="lavastoviglie XYZ"></product>
      </order>
    </orders>
  </customer>
  <customer>
    ...
  </customer>
</customers>

Ovviamente ci sono altre best practice che in questo pos mi sono dimenticato.

Grazie per aver letto questo articolo.