Opzioni di serializzazione - Parte 2

Ci sono molti modi per serializzare i dati.
Come serializzarli dipende da un pò di fattori come: voler condividere tipi o contratti, supportare i tipi .NET esistenti etc

DataContractSerializer

E’ il meccanismo di serializzazione di default, si trova sotto il namespace System.Runtime.Serialization.
Viene usata per i contratti da condividere i tipi CLR vengono mappati su tipi definiti in XSD, in questa maniera otteniamo un’alta interoperabilità.
Ciò significa, ad esempio, che il tipo System.String di un’applicazione .NET diventerà java.lang.String in un’applicazione Java.
Quando dobbiamo condividere un tipo complesso utilizzeremo il decoratore [DataContract], per marcare il tipo da serializzare e [DataMember] per marcare i membri
e le proprietà.

public class Employee
{
    // ...
 
    private int employeeID;
    private string firstName;
    private string lastName;
 
    [DataMember]
    public int EmployeeID
    {
        get { return employeeID; }
        set { employeeID = value; }
    }
 
 
    [DataMember]
    public string FirstName
    {
        get { return firstName; }
        set { firstName = value; }
    }
 
    [DataMember]
    public string LastName
    {
        get { return lastName; }
        set { lastName = value; }
    }
}

XSD Schema:

<GetDataResponse xmlns="http://tempuri.org/">
  <GetDataResult xmlns:a="http://schemas.datacontract.org/2004/07/WcfService1" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
    <a:EmployeeID>0<a:EmployeeID>
    <a:FirstName i:nil="true" />
    <a:LastName i:nil="true" />
  <GetDataResult>
<GetDataResponse>

XML dati ottenuti:

<GetDataResponse xmlns="http://tempuri.org/">
  <GetDataResult xmlns:a="http://schemas.datacontract.org/2004/07/WcfService1" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
    <a:EmployeeID>1<a:EmployeeID>
    <a:FirstName>Salvo<a:FirstName>
    <a:LastName>Di Fazio<a:LastName>
  <GetDataResult>
<GetDataResponse>

NetDataContractSerializer

Questo tipo di serializzazione viene usata quando cerchiamo un livello di fedeltà superiore tra client e server.
La classe NetDataContractSerializer ha un livello di fedeltà maggiore rispetto alla DataContractSerializer perchè, nella fase di serializzazione, vengono inseriti ulteriori informazioni inerenti
ai tipi CLR e alle reference; oltre a questo, tra le due, non vi è alcuna differenza.
Pertanto la NetDataContractSerializer può essere utilizzata solo se le estremità di serializzazione e deserializzazione condividono gli stessi tipi CLR.
Ecco un esempio di serializzazione:

static void Main()
{
    Employee e = new Employee { EmployeeID = 1, FirstName = "Salvo", LastName = "Di Fazio" };
    FileStream fs = new FileStream("esempio.xml", FileMode.Create);
    NetDataContractSerializer ser = new NetDataContractSerializer();
    ser.WriteObject(fs, e);
    fs.Close();
}

ed eccone il risultato inerente solamente all’oggetto scambiato:

<Employee z:Id="1" z:Type="ConsoleApplication1.ServiceReference1.Employee" z:Assembly="ConsoleApplication1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" xmlns="http://schemas.datacontract.org/2004/07/WcfService1" xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/">
  <EmployeeID>1<EmployeeID>
  <FirstName z:Id="2">Salvo<FirstName>
  <LastName z:Id="3">Di Fazio<LastName>
<Employee>

XmlSerializer

Questo meccanismo di serializzazione è presente dal .NET 2.
Ci sono molti vantaggi nell’usare l’XmlSerializer: supporto per i tipi esistenti di .NET, compatibilità con gli ASP.NET Web Services e la creazione di un output XML da poter condividere.
WCF supporta l’XmlSerializer così da poter lavorare con i tipi esistenti a differenza del DataContractSerializer che è usato per i nuovi.
Si possono usare 3 approcci per lavorare con questa serializzazione:

1. Quella di default, creando un oggetto e usando questo per scrivere i dati
   
2. Usare gli attributi: [XmlElement] e [XmlAttribute] (e altri attributi)
   
3. Usare l’interfaccia IXmlSerializable per customizzare tutto il processo di serializzazione

Ecco un esempio:

public class Employee
{
    // ...
 
    private int employeeID;
    private string firstName;
    private string lastName;
 
    public int EmployeeID
    {
        get { return employeeID; }
        set { employeeID = value; }
    }
 
    public string FirstName
    {
        get { return firstName; }
        set { firstName = value; }
    }
 
    public string LastName
    {
        get { return lastName; }
        set { lastName = value; }
    }
}

static void Main()
{
    Employee e = new Employee { EmployeeID = 1, FirstName = "Salvo", LastName = "Di Fazio" };
    FileStream fs = new FileStream("esempio.xml", FileMode.Create);
    XmlSerializer ser = new XmlSerializer(typeof(Employee));
    ser.WriteObject(fs, e);
    fs.Close();
}

Senza la classe XmlSerializer vista la nuova implementazione di Employee, questa non sarebbe serializzabile.
L’attributo [XmlSerializerFormat] può essere usato per obbligare WCF ad usare l’XmlSerializer:

[ServiceContract]
[XmlSerializerFormat]
public interface IEmployeeXml
{
    [OperationContract]
    Employee GetData();
}

DataContractJsonSerializer

Supporta l’uso di JavaScript Object Notation (JSON).
Questo tipo di serializzazione è ottima se voltete chiare il vostro metodo WCF da una Web Application che utilizza AJAX o Silverlight.
Viene usata quando abilitiamo WebScriptEnablingBehavior o WebHttpBehavior e configurato l’encoding JSON.
Quando gli endpoint sono così configurati, istruiscono WCF a supportare servizi di tipo REST/POX.

static void Main()
{
   Employee e = new Employee { EmployeeID = 1, FirstName = "Salvo", LastName = "Di Fazio" };
   FileStream fs = new FileStream("esempio.xml", FileMode.Create);
   DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Employee));
   ser.WriteObject(fs, e);
   fs.Close();
}

il risultato sarà:

{"EmployeeID":1,"FirstName":"Salvo","LastName":"Di Fazio"}