2 – Lavorare con XML

Che cosa ci viene offerto gratuitamente dal sistema

Come ho già spiegato nel precedente post, .NET è molto XML friendly, pertanto ci offre una serie di funzionalità di base al riguardo senza che dobbiamo divertirci a fare le cose a manina. Pertanto ho costruito una classe fondamentalmente inutile che però ci dimostra come tutti i tipi di dati di base di .NET sono serializzabili.

using System;
using System.Text;

namespace DnwEnitities.Entities
{
    public class Serializzabile
    {

        public Serializzabile()
        {
            TheChar = 'A';
            TheByte = 10;
            TheBool = true;
            TheShort = 100;
            TheInt = 1000;
            TheLong = 1000000;
            TheFloat = 1234.7899f;
            TheDouble = 9800000.89600;
            TheDecimal = 766000000.654390001m;
            TheString = "The string is very nice and useful.";
            TheDate = DateTime.Now;
            TheGuid = Guid.NewGuid();
            TheEnum = SerializableEnum.ALot;
        }
    
        public char TheChar
        {
            get;
            set;
        }

        public byte TheByte
        {
            get;
            set;
        }

        public bool TheBool
        {
            get;
            set;
        }

        public short TheShort
        {
            get;
            set;
        }

        public int TheInt
        {
            get;
            set;
        }

        public long TheLong
        {
            get;
            set;
        }

        public float TheFloat
        {
            get;
            set;
        }

        public double TheDouble
        {
            get;
            set;
        }

        public decimal TheDecimal
        {
            get;
            set;
        }

        public string TheString
        {
            get;
            set;
        }

        public DateTime TheDate
        {
            get;
            set;
        }

        public Guid TheGuid
        {
            get;
            set;
        }

        public SerializableEnum TheEnum
        {
            get;
            set;
        }

        public static Serializzabile ReadXml(string pSerializedData, bool pIsXmlData)
        {
            Serializzabile retP = null;
            if (!pIsXmlData)
            {
                retP = (Serializzabile)SerializeHelper.DeserializeFromFile(
                   typeof(Serializzabile), pSerializedData);
            }
            else
            {
                retP = (Serializzabile)SerializeHelper.DeserializeFromString(
                   typeof(Serializzabile), pSerializedData);
            }
            return (retP);
        }

        public virtual void WriteXml(string pFileName)
        {
            SerializeHelper.SerializeToFile(pFileName, this, typeof(Serializzabile), false, string.Empty);
        }

        public virtual string WriteXml()
        {
            return (SerializeHelper.SerializeToString(this, false, string.Empty));
        }

        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendFormat("Char: {0}", this.TheChar);
            sb.AppendLine();
            sb.AppendFormat("Byte: {0}", this.TheByte);
            sb.AppendLine();
            sb.AppendFormat("Bool: {0}", this.TheBool);
            sb.AppendLine();
            sb.AppendFormat("Short: {0}", this.TheShort);
            sb.AppendLine();
            sb.AppendFormat("Int: {0}", this.TheInt);
            sb.AppendLine();
            sb.AppendFormat("Long: {0}", this.TheLong);
            sb.AppendLine();
            sb.AppendFormat("Float: {0}", this.TheFloat);
            sb.AppendLine();
            sb.AppendFormat("Double: {0}", this.TheDouble);
            sb.AppendLine();
            sb.AppendFormat("Decimal: {0}", this.TheDecimal);
            sb.AppendLine();
            sb.AppendFormat("String: {0}", this.TheString);
            sb.AppendLine();
            sb.AppendFormat("Date: {0}", this.TheDate);
            sb.AppendLine();
            sb.AppendFormat("Guid: {0}", this.TheGuid);
            sb.AppendLine();
            sb.AppendFormat("Enum: {0}", this.TheEnum);
            sb.AppendLine();
            return (sb.ToString());
        }

    }

    public enum SerializableEnum : int
    {
        None = 0,
        All,
        Some,
        ALot
    }
    
}

Questa classe, rappresenta l’entity più grezza e semplice, contiene una serie di property pubbliche, una per ogni tipo di dato base usato in .NET, contiene i Metodi  WriteXml e ReadXml, un override del metodo ToString per permetterci di visualizzarne il contenuto ed infine una enumerazione che ci permette di mostrare che anche i dati enumerati, sono serializzati automaticamente.

Instanziando la classe e lanciando WriteXml su un file, otterremo il seguente risultato:

<?xml version="1.0" encoding="utf-8"?>
<Serializzabile xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance 
          xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    <TheChar>65</TheChar>
    <TheByte>10</TheByte>
    <TheBool>true</TheBool>
    <TheShort>100</TheShort>
    <TheInt>1000</TheInt>
    <TheLong>1000000</TheLong>
    <TheFloat>1234.78992</TheFloat>
    <TheDouble>9800000.896</TheDouble>
    <TheDecimal>766000000.654390001</TheDecimal>
    <TheString>The string is very nice and useful.</TheString>
    <TheDate>2010-11-01T09:26:13.331+01:00</TheDate>
    <TheGuid>3da90b04-ec02-4308-a177-fc6723ab8aa9</TheGuid>
    <TheEnum>ALot</TheEnum>
</Serializzabile>

Usando la ReadXml per rileggere il file, otterremo una classe equivalente a quella da noi salvata.

Se non abbiamo particolari esigenze, questo è il metodo più semplice di ottenere un entità serializzabile.