1  La sérialisation 

La sérialisation 

Sommaire 
La sérialisation ....................................................................................................................................... 1 
1  Introduction ..................................................................................................................................... 2 
2  Les bases de la sérialisation ............................................................................................................. 3 
2.1  Sérialisation Binaire ................................................................................................................. 3 
2.2  Dé‐sérialiser un objet .............................................................................................................. 5 
2.3  Rendre ses classes sérialisable ................................................................................................ 6 
2.3.1  Empêcher la sérialisation d'un membre .......................................................................... 6 
2.3.2  Gestion de version d'objets sérialisable .......................................................................... 8 
2.4  Sérialisation SOAP ................................................................................................................... 9 
2.4.1  Avoir accès à SoapFormatter ........................................................................................... 9 
2.4.2  Utilisation de SoapFormatter ........................................................................................ 11 
2.5  Sérialisation personnalisée .................................................................................................... 13 
2.5.1  Les évènements de sérialisation ................................................................................... 15 
2.5.2  Obtenir un contexte de sérialisation ............................................................................. 18 
3  Sérialisation XML ........................................................................................................................... 19 
3.1  Sérialisation/Dé‐sérialisation d'objets en XML...................................................................... 19 
3.2  Contrôler la sérialisation ....................................................................................................... 23 
3.3  Utilisation de schémas XML .................................................................................................. 26 
4  Conclusion ..................................................................................................................................... 27 
 

18 juillet 2008
 
2  La sérialisation 
 

1 Introduction 
Dans  les  chapitres  précédents,  nous  avions  vu  comment  accéder  aux  données  via  les  flux, 
comment utiliser le bon encodage et comment stocker ces données dans des tableaux dynamiques.

 
 
Dans  cette  partie,  nous  allons  aborder  un  aspect  important  du  stockage  de  données  :  La 
sérialisation. La sérialisation, c'est le fait de faire une copie des données d'un objet en mémoire à un 
instant T dans un fichier, un flux réseaux etc. (Pour envoyer des objets à travers un réseau (utilisation 
de Webservices, Remoting…) ou enregistrer le travail d'une application, d'un jeu vidéo…). 
 
Dans  un  premier  temps,  nous  verrons  comment  sérialiser  nos  données  lorsque  celles‐ci  sont 
destinées  à  d'autres  applications  .NET  ;  puis  nous  verrons  comment  sérialiser  en  XML.  Pour  finir, 
nous verrons comment créer nos propres formats de sérialisation. 
L’espace de nom  System.Runtime.Serialization  contient la majorité des outils donnant 
accès à la sérialisation des objets. 
 
 
 
 
 
 
 
 
 
 
 
 
 

18 juillet 2008
 
3  La sérialisation 
 

2 Les bases de la sérialisation 
2.1 Sérialisation Binaire 
La sérialisation d’un objet en binaire  est la plus basique.  Elle convertit un objet en une suite 
d’octets  peu  lisibles  (voir  pas  du  tout).  La  sérialisation  binaire  est  la  seule  à  pouvoir  sérialiser  des 
objets courant comme des objets de type de graphique. 
Elle  se  fait  très  facilement  en  utilisant  les  deux  espaces  de  nom 
System.Runtime.Serialization  et 
System.Runtime.Serialization.Formatters.Binary

Nous allons également utiliser un flux pour enregistrer l’objet sérialisé dans un fichier: 
'VB
<Serializable()> _
Class Personnage
Private _nom As String
Private _age As Integer
Private _infos As String
Public Property infos() As String
Get
Return _infos
End Get
Set(ByVal value As String)
_infos = value
End Set
End Property
Public Property nom() As String
Get
Return _nom
End Get
Set(ByVal value As String)
_nom = value
End Set
End Property
Public Property age() As Integer
Get
Return _age
End Get
Set(ByVal value As Integer)
_age = value
End Set
End Property
End Clas
Sub Main()
Dim perso As Personnage = New Personnage()
perso.infos = "Informations sur votre personnage"
Dim fichierIn As FileStream = New FileStream("c:\serialized.txt",
FileMode.Create)
Dim bf As BinaryFormatter = New BinaryFormatter()
bf.Serialize(fichierIn, perso)
fichierIn.Close()
End Sub
 

18 juillet 2008
 
4  La sérialisation 
 

//C#
[Serializable]
class Personnage
{
private string _nom;
private int _age;
private string _infos;

public string infos { get { return _infos; } set{ _infos = value; } }

public string nom { get { return _nom; } set{ _nom = value; } }
public int age { get { return _age; } set{ _age = value; } }
}

static void Main(string[] args)

{
string infos = "Informations sur votre personnage";
Personnage perso = new Personnage();
perso.infos = infos;

FileStream fichierIn = new FileStream(@"c:\serialized.txt",

FileMode.Create);
BinaryFormatter bf = new BinaryFormatter();

bf.Serialize(fichierIn, perso);
fichier.Close();
}
 
Nous  avons  donc  créé  une  classe,  qui  est  sérialisable  (elle  est  précédé  par  l'attribut 
Serializable,  nous  reviendrons  sur  cette  notion  plus  bas)  et  qui  possède  trois  attributs  et  trois 
accesseurs. 
Dans  notre  Main,  nous  créons  une  chaine  de  caractère,  nous  instancions  un  objet  de  type 
Personnage et nous lui assignons la chaine d’information. 
Ensuite  nous  créons  un  fichier  qui  va  contenir  les  données  et  le  BinaryFormatter  qui  va 
formater  nos  données  en  binaire.  Enfin  nous  utilisons  la  méthode  Serialize  de  notre 
BinaryFormatter  qui  prend  le  fichier  en  premier  paramètre  et  l’objet  à  sérialiser  en  second.  On 
n’oublie pas de fermer le flux sur le fichier. 
 
Si nous ouvrons notre fichier, voila ce que nous pouvons lire : 

 
Nous  devinons  les  divers  membres  et  données  enregistrées  sous  forme  ASCII  ainsi  que  des 
caractères étranges qui décrivent les données en vue de les dé‐sérialiser. 
 
 
 
 
 
 
 
 
 
 
 

18 juillet 2008
 
5  La sérialisation 
 

2.2 Dé­sérialiser un objet 
Nous  avons  vu  comme  sérialiser  un  objet,  nous  allons  maintenant  voir  comment  le  dé‐
sérialiser. La manipulation n’est guère plus compliquée, en effet le processus est similaire : 
'VB
Sub Main()
Dim bf As BinaryFormatter = New BinaryFormatter()
Dim fichierOut As FileStream = New FileStream("c:\serialized.txt",
FileMode.Open)
Dim NewPerso As Personnage = CType(bf.Deserialize(fichierOut),
Personnage)
fichierOut.Close()
Console.WriteLine(NewPerso.infos)
Console.Read()
End Sub

//C#
static void Main(string[] args)
{
FileStream fichierOut = new FileStream(@"c:\serialized.txt",
FileMode.Open);

BinaryFormatter bf = new BinaryFormatter();

Personnage NewPerso = (Personnage) bf.Deserialize(fichierOut);

fichierOut.Close();

Console.WriteLine(NewPerso.infos);
Console.Read();
}
 
Informations sur votre personnage 
On  ouvre  donc  le  fichier  à  dé‐sérialiser,  et  on  crée  notre  objet  BinaryFormatter  qui  va  nous 
permettre de dé‐sérialiser (on peut aussi réutiliser le précédent dans notre exemple). 
Ensuite nous créons un objet "NewPerso" de type Personnage et on lui assigne le contenu du 
fichier, dé‐sérialisé par la méthode Deserialize et casté en type Personnage. Le cast est important 
car  l’objet  dé‐sérialisé  est  de  type  Object.  Si  vous  omettez  le  cast,  il  y  aura  une  erreur  à  la 
compilation. 
Enfin on affiche le champ infos de "NewPerso", et on voit qu’il est identique à celui qui a été 
sérialisé. 
 

18 juillet 2008
 
6  La sérialisation 
 

2.3 Rendre ses classes sérialisable 
Nous  avons  vu  dans  la partie  2.1  qu’il  fallait  utiliser  un  attribut  spécial  au  dessus  des  classes 
que nous voulons sérialiser. Cet attribut indique par défaut au Runtime que l’on souhaite sérialiser 
toute la classe, y compris les membres « private ». 
'VB
<Serializable()>

//C#
[Serializable]
 
Si  vous  ne  savez  pas  si  vous  allez  sérialiser  votre  classe  plus  tard,  ou  si  un  développeur  aura 
besoin de sérialiser une classe héritant de la votre, ajoutez l’attribut dans le doute. 
Vous pouvez  également  configurer votre classe pour indiquer des champs à ne pas sérialiser 
ou gérer la comptabilité entre deux versions d’un logiciel. 
 

2.3.1 Empêcher la sérialisation d'un membre 
Vous pouvez avoir besoin, dans vos classes, de créer des variables qui n'ont pas besoin d'être 
sérialisées (variable contenant le résultat de calculs en général). Aussi, pour limiter la taille des objets 
sérialisés, nous pouvons utiliser l'attribut  NonSerialized placé avant chaque membre qui ne doit 
pas nécessairement être sérialisé (Les accesseurs ne sont pas indiqués ici mais doivent toujours être 
placés dans vos codes): 
'VB
<Serializable()> _
Class Personnage
Private _nom As String
<NonSerialized()> Private _age As Integer
Private _infos As String
End Class

//C#
[Serializable]
class Personnage
{
private string _nom;
[NonSerialized] private int _age;
private string _infos;
}  
Après la dé‐sérialisation, le membre _age n’existe pas, il n’est donc pas instancié. Voici ce qui 
est retourné si on affiche _age : 
0 
 
Si vous utilisez _age dans une méthode qui sera sérialisé, aucune exception ou erreur ne sera 
renvoyée, en revanche, la valeur qui aura été assigné à _age sera perdue. 
 
 
 
 
 
 
 
 
 
 

18 juillet 2008
 
7  La sérialisation 
 

Il  est  possible,  en  implémentant  l'interface  IDeserializationCallback,  d'utiliser  la 

méthode  OnDeserialization  qui va vous permettre de définir le comportement de la classe lors 
d’une dé‐sérialisation. Cela permet d'effectuer quelques opérations pour, par exemple, retrouver la 
valeur des membres qui n'ont pas été sérialisés. 
Afin de mieux comprendre, voici un exemple : 
'VB
<Serializable()> _
Class Personnage
Implements IDeserializationCallback

Private _nom As String

<NonSerialized()> Private _age As Integer
Private _infos As String

Public Sub New()

End Sub
Public Sub OnDeserialization(ByVal sender As Object) Implements
System.Runtime.Serialization.IDeserializationCallback.OnDeserialization
_age = 42
End Sub
End Class

//C#
[Serializable]
class Personnage : IDeserializationCallback
{
private string _nom;
[NonSerialized] private int _age;
private string _infos;

public Personnage()
{;}

public void OnDeserialization(object sender)

{
_age = 42;
}
}
 
Si nous affichons la valeur de _age après dé‐sérialisation : 
42 
La valeur de _age a été assignée à la dé‐sérialisation, on ne retrouve aucunes traces de _age 
dans le fichier serialized.txt. 
 
 
 
 
 
 
 
 
 
 
 

18 juillet 2008
 
8  La sérialisation 
 

2.3.2 Gestion de version d'objets sérialisable 
Il  se  peut  que  lorsque  vous  développez  votre  programme,  vous  soyez  amené  à  modifier  une 
classe,  pour  lui  rajouter  des  membres  par  exemple.  Si  vous  aviez  sérialisé  un  objet  de  la  version 
précédente  de  votre  classe  et  que  vous  tentez  de  le  dé‐sérialiser  sur  la  nouvelle  version,  il  est 
possible que des erreurs inattendues apparaissent. Aussi, le Framework .NET fournit également des 
outils  permettant  de  gérer  la  compatibilité  d’un  objet  sérialisé  entre  plusieurs  versions  différentes 
d’un programme. 
Pour cela, nous pouvons : 
¾ Créer un sérialiseur personnalisé qui peut gérer les multiples versions (traité dans la partie 
2.5). 
¾ Utiliser l’attribut OptionalField pour rendre optionnels certains membres d’une classe. 
Voyons un exemple de l’utilisation d’OptionalField : 
'VB
<Serializable()> _
Class Personnage
Implements IDeserializationCallback

Private _nom As String

<NonSerialized()> Private _age As Integer
Private _infos As String
<OptionalField()> Private _region As String
Private _majeur As Boolean

Public Sub New()

_age = 18
End Sub

Public Sub OnDeserialization(ByVal sender As Object) Implements

System.Runtime.Serialization.IDeserializationCallback.OnDeserialization
_majeur = _age > 18
_region = "Groland"
End Sub
End Class
 
//C#
[Serializable]
class Personnage : IDeserializationCallback
{
private string _nom;
[NonSerialized] private int _age;
private string _infos;
[NonSerialized] private string _region;

public Personnage()
{
_age = 18;
}

public void OnDeserialization(object sender)

{
_majeur = _age > 18;
_region = "Groland";
}
}
 
Nous avons donc notre champ region qui est optionnel, c'est‐à‐dire que si nous souhaitons dé‐
sérialiser  un  objet  qui  ne  possédait  pas  encore  ce  membre,  la  région  sera  retrouvée  à  la  dé‐
sérialisation et mise par défaut à la valeur "Groland". 

18 juillet 2008
 
9  La sérialisation 
 

2.4 Sérialisation SOAP 
Nous  avons  utilisé  jusque  là  un  format  binaire  pour  sérialiser  nos  objets.  Sachez  qu’il  existe 
également dans l’espace de nom System.Runtime.Serialization.Formatters.Soap un autre 
format pour sérialiser les objets : SoapFormatter.

SoapFormatter  permet  de  sérialiser  les  objets  dans  un  format  dérivé  du  XML  dans  le  but 
d’utiliser  votre  application  avec  des  WebServices  SOAP  (Simple  Object  Access  Protocol).  Il  est 
possible d’utiliser  SoapFormatter  pour envoyer des données vers des applications capable de lire 
du XML, mais préférez l’utilisation de la sérialisation XML standard (sera abordée plus bas). 
Dans tous les cas, SoapFormatter est plus portable que BinaryFormatter, mais plus lourd. 
 

2.4.1 Avoir accès à SoapFormatter 
Alors que BinaryFormatter est disponible par défaut dans votre projet, il vous faudra rajouter 
manuellement l'assembly contenant SoapFormatter.  
 
¾ Ajouter la référence en C# 
Pour se faire, cliquez avec le bouton droit sur References dans l’explorateur de solutions puis 
faites "Ajouter une référence…" 

 
 
Ensuite,  cherchez  dans  la  liste  System.Runtime.Serialization.Formatters.Soap  et 
faites "Ok" : 

18 juillet 2008
 
10  La sérialisation 
 

 
 
 
¾ Ajouter la référence en VB.NET 
Cliquez droit sur votre projet et faites "Propriétés".  

 
 
 
 

18 juillet 2008
 
11  La sérialisation 
 

Une fois dans les propriétés, allez sur l'onglet "Références" et cliquez sur le bouton "Ajouter". 
Vous  devriez  avoir  la  même  fenêtre  de  sélection  des  références  qu'en  C#.  Suivez  les  mêmes 
opérations et validez. 
 
Il ne vous reste plus qu’a rajouter au début de votre projet : 
'VB
Imports System.Runtime.Serialization.Formatters.Soap

//C#
using System.Runtime.Serialization.Formatters.Soap;
 
 

2.4.2 Utilisation de SoapFormatter 
L’utilisation de SoapFormatter est en fait totalement identique à celle de BinaryFormatter. Si 
vous  changez  le  code  précédent  en  utilisant  la  classe  SoapFormatter,  voila  ce  que  vous  obtenez  si 
vous sérialisez la classe Personnage et que vous essayez de le lire avec un éditeur de texte : 

 
 
Nous  avons  indenté  un  petit  peu  le  code  et  coupé  une  partie  pour  que  vous  vous  rendiez 
mieux  compte.  Nous  retrouvons  donc  nos  variables  _nom  et  _age  à  null  car  on  ne  leur  assigne 
aucune valeur et _infos contient la chaine "Informations sur votre personnage". 
 

18 juillet 2008
 
12  La sérialisation 
 

Vous pouvez également configurer la façon dont les données sont sérialisés grâce à quelques 
attributs spécifiques à SoapFormatter. Vous en apprendrez plus sur l’utilisation de ces attributs dans 
la  partie  suivante.  Sachez  que  les  attributs  de  Soap  se  trouvent  dans  l’espace  de  nom 
System.Xml.Serialization : 
Attribut  S’applique sur   Description 
SoapAttribute Champ publique,  Spécifie à XmlSerializer que l'élément sera sérialisé 
propriété,  en tant qu'attribut. 
paramètres, valeurs 
de retour 
SoapElement Champ publique,  Spécifie à XmlSerializer que le membre sera sérialisé 
propriété,  en tant qu'élément. 
paramètres, valeurs 
de retour 
SoapEnum Valeurs  Indique des propriétés de sérialisation des valeurs à 
d'énumérations  l'intérieur d'une énumération. 
SoapIgnore Propriété et champs  La propriété ou le champ est ignoré au moment de la 
publics  sérialisation 
SoapInclude Classe parente de  Permet à l'outil de sérialisation d'inclure un type 
classe dérivée ou  particulier lors d'une sérialisation ou d'une dé‐
valeur de retour de  sérialisation. 
méthodes dans des 
documents WSDL 
  

18 juillet 2008
 
13  La sérialisation 
 

2.5 Sérialisation personnalisée 
Bien  que  les  méthodes  de  sérialisation  vues  précédemment  couvrent  un  bon  nombre  de 
besoins, il se peut que vous ayez besoin de customiser le processus de sérialisation. 
 
Pour  cela,  vous  devez  remplacer  le  processus  de  sérialisation  du  Framework  .NET  en 
implémentant l’interface ISerializable dans vos classes. 
Cette  interface  propose  la  méthode  GetObjectData qui  sera  appelée  au  moment  de  la 
sérialisation et vous devez créer un constructeur qui sera appelé quand la classe sera dé‐sérialisée. 
 
ATTENTION : Seul la méthode GetObjetData est à implémenter obligatoirement ! Le constructeur 
de dé‐sérialisation n'est pas obligatoire mais si vous ne le mettez pas, vous ne pourrez pas dé‐
sérialiser votre objet.  
 
Dans la méthode  GetObjetData vous allez devoir remplir un objet  SerializationInfo en 
ajoutant tous les attributs que vous souhaitez sérialiser grâce à la méthode  AddValue qui prend en 
premier paramètre une clé et en second votre variable. 
Le constructeur dédié à la dé‐sérialisation va pouvoir récupérer les valeurs grâces à leurs clés. 
 
Voici un exemple en reprenant notre classe calcul : 
'VB
<Serializable()> _
Class Personnage
Implements IDeserializationCallback, ISerializable

Private _nom As String

<NonSerialized()> Private _age As Integer
Private _infos As String
<OptionalField()> Private _region As String
Private _majeur As Boolean
Public Sub New()
_age = 18
End Sub
Public Sub GetObjectData(ByVal info As
System.Runtime.Serialization.SerializationInfo, ByVal context As
System.Runtime.Serialization.StreamingContext) Implements
System.Runtime.Serialization.ISerializable.GetObjectData
info.AddValue("Nom", _nom)
info.AddValue("Info", _infos)
info.AddValue("Majeur", _majeur)
End Sub
Public Sub New(ByVal info As
System.Runtime.Serialization.SerializationInfo, ByVal context As
System.Runtime.Serialization.StreamingContext)
_majeur = info.GetBoolean("Majeur")
_infos = info.GetString("Info")
_nom = info.GetString("Nom")
End Sub
Public Sub OnDeserialization(ByVal sender As Object) Implements
System.Runtime.Serialization.IDeserializationCallback.OnDeserialization
_majeur = _age > 18
_region = "Groland"
End Sub
End Class
 
 
 
 

18 juillet 2008
 
14  La sérialisation 
 

//C#
[Serializable]
class Personnage : IDeserializationCallback, ISerializable
{
private string _nom;
[NonSerialized] private int _age;
private string _infos;
[OptionalField] private string _region;
private bool _majeur;

public Personnage()
{
_age = 18;
}

public void OnDeserialization(object sender)

{
_majeur = _age > 18;
_region = "Groland";
}

public void GetObjectData(SerializationInfo info, StreamingContext

context)
{
info.AddValue("Nom", nom);
info.AddValue("Majeur", majeur);
info.AddValue("Info", infos);
}
public Personnage(SerializationInfo info, StreamingContext context)
{
majeur = info.GetBoolean("Majeur");
nom = info.GetString("Nom");
infos = info.GetString("Info");
}
}
 
On  a  donc  deux  constructeurs  :  un  ne  prenant  aucun  argument  et  celui  appelé 
automatiquement à la dé‐sérialisation. A l’intérieur on récupère les valeurs avec les clés, on spécifie 
que ce sont des booléen et des chaines de caractères, mais nous aurions pu récupérer tous les types 
de base du Framework. Cela dépend du type de donnée qui a été sérialisée. 
La  méthode  GetObjectData  ajoute  à  l'objet  SerializationInfo  les  valeurs  que  l'on  souhaite 
sérialiser, référencés par les clés "Nom", "Info" et "Majeur". 
 
 
 
 
 
 
 
 
 
 
 
 

18 juillet 2008
 
15  La sérialisation 
 

2.5.1 Les évènements de sérialisation 
Quand  vous  utilisez  le  formateur  BinaryFormatter  pour  sérialiser  vos  données,  vous  pouvez 
utiliser  des  évènements  sous  forme  d’attributs  afin  d’agir  pendant  les  processus  de  sérialisation  et 
désérialisation. 
¾ Serializing, généré au cours du processus de sérialisation. 
¾ Serialized, généré une fois que l'objet a été sérialisé. 
¾ Deserializing, généré pendant la dé‐sérialisation. 
¾ Deserialized, généré quand l'objet a été dé‐sérialisé. 
 
Le schéma ci‐dessous nous montre l'ordre d'appel des évènements: 

 
 
 
Ces évènements sont un peu particuliers. En effet, nous avions vu qu'il était possible de créer 
des évènements en utilisant les délégués. Dans ce cas‐ci, les évènements sont des attributs à placer 
avant  la  ou  les  méthodes  qui  seront  appelée  lors  de  l'évènement  indiqué.  Chaque  méthode  doit 
prendre en argument un objet de type StreamingContext: 

18 juillet 2008
 
16  La sérialisation 
 

'VB
<OnDeserialized()> _
Public Sub SetAge(ByVal context As StreamingContext)
End Sub

//C#
[OnDeserialized]
public void SetAge(StreamingContext context){}
 
 
Il faut savoir qu'il est tout à fait possible de faire en sorte qu'une seule méthode soit appelée 
dans plusieurs évènements. Pour cela, il suffit d'ajouter plusieurs attributs au dessus de la méthode à 
exécuter. 
 
L'exemple ci‐dessous présente comment utiliser l'utiliser l'évènement OnDeserialized : 
'VB
<Serializable()> _
Class Personnage
Implements IDeserializationCallback

Private _nom As String

<NonSerialized()> Private _age As Integer
Private _infos As String
<OptionalField()> Private _region As String
Private _majeur As Boolean
Public Sub New()
_age = 18
End Sub
<OnDeserialized()> _
Public Sub SetAge(ByVal context As StreamingContext)
_age = 42
End Sub
Public Sub GetObjectData(ByVal info As
System.Runtime.Serialization.SerializationInfo, ByVal context As
System.Runtime.Serialization.StreamingContext) Implements
System.Runtime.Serialization.ISerializable.GetObjectData
info.AddValue("Nom", _nom)
info.AddValue("Info", _infos)
info.AddValue("Majeur", _majeur)
End Sub
Public Sub New(ByVal info As
System.Runtime.Serialization.SerializationInfo, ByVal context As
System.Runtime.Serialization.StreamingContext)
_majeur = info.GetBoolean("Majeur")
_infos = info.GetString("Info")
_nom = info.GetString("Nom")
End Sub
Public Sub OnDeserialization(ByVal sender As Object) Implements
System.Runtime.Serialization.IDeserializationCallback.OnDeserialization
_majeur = _age > 18
_region = "Groland"
End Sub
End Class
 

18 juillet 2008
 
17  La sérialisation 
 

[Serializable]
class Personnage : IDeserializationCallback, ISerializable
{
private string _nom;
[NonSerialized] private int _age;
private string _infos;
[OptionalField] private string _region;
private bool _majeur;

public Personnage()
{
_age = 18;
}

[OnDeserialized]
public void SetAge(StreamingContext context)
{
_age = 42;
}

public void OnDeserialization(object sender)

{
_majeur = _age > 18;
_region = "Groland";
}

public void GetObjectData(SerializationInfo info, StreamingContext

context)
{
info.AddValue("Nom", nom);
info.AddValue("Majeur", majeur);
info.AddValue("Info", infos);
}
public Personnage(SerializationInfo info, StreamingContext context)
{
majeur = info.GetBoolean("Majeur");
nom = info.GetString("Nom");
infos = info.GetString("Info");
}
}

 
Comme vous pouvez le voir, nous avons utilisé l’attribut OnDeserialized au dessus de notre 
méthode "SetAge" afin de calculer le total après la dé‐sérialisation des membres. 
Notre  méthode  "SetAge"  prend  en  paramètre  un  objet  StreamingContext  et  retourne  un 
void. 
 
Utiliser  les  attributs  de  BinaryFormatter  simplifie  le  développement,  préférez  les  à 
ISerializable si vous utilisez BinaryFormatter. 
 

18 juillet 2008
 
18  La sérialisation 
 

2.5.2 Obtenir un contexte de sérialisation 
La classe  StreamingContext permet d’obtenir le contexte dans lequel l’objet a été sérialisé. 
Ce  contexte  peut  contenir  n'importe  quelles  informations,  comme  par  exemple  l'origine  ou  la 
destination de l'objet. La classe compte deux propriétés Context et State : 
 
¾ La propriété Context contient une référence vers les informations du contexte. 
¾ La propriété State permet de définir et de récupérer l’origine et la destination des objets 
sérialisés et dé‐sérialisés. Vous devez utiliser l’énumération StreamingContextStates
pour définir les valeurs. 
 
Voici les différents membres de l’énumération StreamingContextStates : 
Membre  Description 
CrossProcess Indique que la source ou la destination est un processus différent sur une 
même machine. 
CrossMachine Spécifie que la source ou la destination est sur une machine différente. 
File Indique que la source ou la destination est un fichier. 
Persistence Indique que la source ou la destination est un fichier, une base de donnée ou 
autre stockage dit persistant (ou non‐volatile) 
Remoting Réfère à une source ou une destination distante inconnue. On ne peut savoir si 
c’est sur la même machine ou une autre machine.  
Other La source ou la destination est inconnue. 
Clone Clone le contexte de l’objet, la dé‐sérialisation devra se faire dans le même 
contexte que la sérialisation.  
CrossAppDomain La source ou la destination sont sur un domaine d'application différent. 
All La source ou la destination peuvent être n’importe lequel des contextes 
précédents. C’est la valeur par défaut. 
 
Si  vous  utilisez  BinaryFormatter  ou  SoapFormatter,  vous  ne  pourrez  pas  assigner  un 
contexte personnalisé, celui‐ci sera toujours null pour la propriété  Context et All pour la propriété 
State. 
Pour pouvoir modifier le contexte, il vous faudra créer votre propre formateur de sérialisation. 
Afin  de  créer  un  formateur  personnalisé,  vous  devez  implémenter  l’interface  IFormatter 
pour  un  formateur  simple  ou  bien  IGenericFormatter  si  vous  souhaitez  sérialiser  des  types 
génériques. 
Sachez que BinaryFormatter et SoapFormatter implémentent l’interface IFormatter. 
La  classe  FormatterServices  met  à  disposition  des  méthodes  statiques  (dont 
GetObjectData) afin de faciliter la création de votre formateur. 
 
La création d’un formateur sort du cadre de ce cours. 
 

18 juillet 2008
 
19  La sérialisation 
 

3 Sérialisation XML 
Le .NET Framework fourni, en plus d'une sérialisation Binaire et SOAP, une sérialisation XML. 
Ce type de sérialisation peut être utile si vous souhaitez par exemple échanger des informations avec 
des applications qui ne sont pas créés avec les technologies .NET, ou encore permettre à l'utilisateur 
de personnaliser l'application en modifiant les paramètres de l'objet sérialisé en XML. 
En  contrepartie,  la  sérialisation  XML  ne  peut  sérialiser  que  des  éléments  dont  la  portée  est 
définie en Publique. Il est également impossible de sérialiser des objets graphiques (Des images par 
exemples) ; seuls les objets standards sont sérialisable. 
 

3.1 Sérialisation/Dé­sérialisation d'objets en XML 
Le  principe  de  sérialisation  et  de  dé‐sérialisation  des  données  reste  grossièrement  le  même 
que ce qui a été vu dans la partie 2 : 
¾ On créé un flux vers un fichier qui contiendra nos données 
¾ On instancie la classe de sérialisation adaptée 
¾ On utilise la méthode Serialise pour sérialiser ou Deserialise pour effectuer 
l'opération inverse. 
 
Les  outils  nécessaires  à  la  sérialisation  XML  se  trouvent  dans  l'espace  de  nom 
System.Xml.Serialisation et  la  classe  utilisée  pour  sérialiser  en  XML  s'appelle 
XmlSerializer.  
 
L'exemple ci‐dessous se contente de sérialiser un objet DateTime dans le fichier serialise.xml. 
Ensuite, nous remettons le curseur du flux au début du flux et nous dé‐sérialisons l'objet sérialisé. 
'VB
Sub Main()
Dim fichier As FileStream = New FileStream("serialise.xml",
FileMode.Truncate, FileAccess.ReadWrite)
Dim serializer As XmlSerializer = New
XmlSerializer(GetType(DateTime))
Dim time As DateTime = DateTime.Now
serializer.Serialize(fichier, time)
fichier.Seek(0, SeekOrigin.Begin)
Dim timedeserial As DateTime =
CType(serializer.Deserialize(fichier), DateTime)
Console.WriteLine(timedeserial.ToString())
Console.Read()
End Sub 

//C#
static void Main(string[] args)
{
FileStream fichier = new FileStream(@"serialise.xml",
FileMode.Truncate, FileAccess.ReadWrite);
XmlSerializer serializer = new XmlSerializer(typeof(DateTime));
DateTime time = DateTime.Now;
serializer.Serialize(fichier, time);
fichier.Seek(0, SeekOrigin.Begin);
DateTime timedeserial = (DateTime) serializer.Deserialize(fichier);
Console.WriteLine(timedeserial.ToString());
Console.Read();
}
 
Voici le contenu du fichier serialise.xml après exécution du programme: 

18 juillet 2008
 
20  La sérialisation 
 

 
Et ici, le résultat affiché dans la console: 
17/07/2008 10:57:16 
 
Nous pouvons également sérialiser nos propres objets. La différence avec les autres méthodes 
de sérialisation est que cette fois‐ci, il n'est plus nécessaire de spécifier l'attribut Serializable 
avant les classes qui doivent être sérialisées. 
Retenez juste que la classe de sérialisation XML procède comme suit: 
¾ Elle sérialise tous les éléments déclarés en public 
¾ Elle ignore tous les autres éléments déclarés private ou protected. 
¾ Si dans votre classe, vous créez un constructeur qui prend au moins un paramètre, 
vous êtes également obligé de créer un constructeur qui n'en prend aucun! 
 
 
Note  :  S'il  est  impossible  d'effectuer  ces  opérations  sur  des  objets  de  type  graphique,  il  est 
possible de sérialiser des objets DataSet utilisés pour créer des mini‐bases de données en mémoire 
vive. Un exemple rapide est fourni dans le projet‐type fourni sur le site DotnetFrance. Sachez juste 
que sérialiser un DataSet est exactement pareil que sérialiser un objet courant. 

18 juillet 2008
 
21  La sérialisation 
 

Dans l'exemple suivant, nous créons une classe Personnage que nous instancions et sérialisons 
dans le même fichier que précédemment: 
'VB
Public Enum Yeux
Bleu
Vert
Rouge
Marron
End Enum
Public Class Personnage
Public _nom As String
Public _age As Integer
Public _taille As Short
Public _naissance As DateTime
Public ye As Yeux
Public Sub New()
_nom = "Kikoo"
_age = 31
_taille = 183
_naissance = New DateTime(1, 1, 1, 0, 0, 23)
ye = Yeux.Rouge
End Sub
End Class
Sub Main()
Dim fichier As FileStream = New FileStream("serialise.xml",
FileMode.Truncate, FileAccess.ReadWrite)
Dim serializer As XmlSerializer = New
XmlSerializer(GetType(Personnage))
Dim toserial As Personnage = New Personnage()
serializer.Serialize(fichier, toserial)
fichier.Close()
End Sub 
 
 

18 juillet 2008
 
22  La sérialisation 
 

//C#
public enum yeux
{
Bleu,
Vert,
Rouge,
Marron
}
public class Personnage
{
public string _nom;
public int _age;
public short _taille;
public DateTime _naissance;
public yeux ye;
public string[] _infos;

public Personnage()
{
_infos = new String[4]{"kikoo", null, "lol", "juloe"};
_nom = "Kikoo";
_age = 31;
_taille = 183;
_naissance = new DateTime(1, 1, 1, 0, 0, 23);
ye = yeux.Rouge;
}
}
static void Main(string[] args)
{
FileStream fichier = new FileStream(@"serialise.xml",
FileMode.Truncate, FileAccess.ReadWrite);
serializer = new XmlSerializer(typeof(Personnage));
Personnage toserial = new Personnage();
serializer.Serialize(fichier, toserial);
fichier.Close();
}
 
Le contenu du fichier est présenté ci‐dessous : 

 
 
 

18 juillet 2008
 
23  La sérialisation 
 

3.2 Contrôler la sérialisation 
Tout  comme  la  sérialisation  SOAP,  il  est  possible  de  contrôler  la  sérialisation  XML  grâce  à 
certains attributs indiqués ci‐dessous avec leur description: 
Attributs  Utilisable avec  Description 
XmlAnyAttribute Propriété, champ public,  Indique que le membre contient des 
paramètre ou valeur de  attributs XML qui n'ont pas 
retour contenant un tableau  d'équivalent dans la classe en cours de 
d'objets de type  sérialisation. 
XmlAttribute. 
XmlAnyElement Propriété, champ public,  Indique que le membre contient des 
paramètre ou valeur de  éléments XML (XmlElement ou 
retour contenant un tableau  XmlNode) qui n'ont pas d'équivalent 
d'objets de type XmlElement.  dans la classe en cours de sérialisation. 
XmlAttribute Propriété, champ public,  L'élément sera sérialisé en tant 
paramètre ou valeur de  qu'attribut. 
retour. 
XmlElement Propriété, champ public,  L'élément sera sérialisé en tant 
paramètre ou valeur de  qu'élément XML. 
retour. 
XmlArray Propriété, champ public,  L'élément sera sérialisé en tant que 
paramètre ou valeur de  tableau d'éléments XML. 
retour de type Array. 
XmlArrayItem Propriété, champ public,  Spécifie les types qui peuvent être 
paramètre ou valeur de  insérés dans un tableau d'objets. 
retour de type Array. 
XmlChoiceIdentifier Propriété, champ public,  Indique à l'outil de sérialisation qu'on 
paramètre ou valeur de  peut identifier des membres avec des 
retour.  valeurs d'une énumération. 
XmlEnum Membre d'une énumération  Spécifie la manière dont l'outil de 
sérialisation va sérialiser un élément 
d'une énumération. 
XmlIgnore Champs et propriétés  Permet d'ignorer un élément lors de la 
publiques  sérialisation. 
XmlInclude Classe parente de classe  Permet à l'outil de sérialisation 
dérivée ou valeur de retour  d'inclure un type particulier lors d'une 
de méthodes dans des  sérialisation ou d'une dé‐sérialisation. 
documents WSDL 
XmlRoot Classe publique  Permet de modifier les propriétés de 
l'élément XML racine. 
XmlType Classe publique  Permet de modifier le nom et l'espace 
de nom du document XML. 
XmlText Champs et propriétés  L'élément sera sérialisé sous forme de 
publiques  texte. 
 
 
 
 
 
 

18 juillet 2008
 
24  La sérialisation 
 

Si nous reprenons l'exemple précédent, nous pouvons modifier quelques données en ajoutant 
quelques‐uns de ces attributs (Le code de sérialisation restant inchangé, il n'est pas repris dans cet 
exemple): 
'VB
Public Enum Yeux
<XmlEnum("BlueEyes")> Bleu
<XmlEnum("GreenEyes")> Vert
<XmlEnum("RedEyes")> Rouge
<XmlEnum("BrownEyes")> Marron
End Enum

<XmlRoot("RoutedCharacter"), XmlType(AnonymousType:=False,
IncludeInSchema:=False, Namespace:="Personnage")> _
Public Class Personnage
<XmlAttribute("Nom")> Public _nom As String
<XmlElement("Age")> Public _age As Integer
<XmlIgnore()> Public _taille As Short
<XmlElement("Naissance")> Public _naissance As DateTime
<XmlElement("Yeux")> Public ye As Yeux
<XmlArray("Informations")> Public _info(4) As String

Public Sub New()

_info = New String() {"kikoo", Nothing, "lol", "juloe"}
_nom = "Kikoo"
_age = 31
_taille = 183
_naissance = New DateTime(1, 1, 1, 0, 0, 23)
ye = Yeux.Rouge
End Sub
End Class
 

18 juillet 2008
 
25  La sérialisation 
 

//C#
public enum yeux
{
[XmlEnum("BlueEyes")] Bleu,
[XmlEnum("GreenEyes")] Vert,
[XmlEnum("RedEyes")] Rouge,
[XmlEnum("BrownEyes")] Marron
}

[XmlRoot("RoutedCharacter"), XmlType(AnonymousType=false,
IncludeInSchema=false, Namespace="Personnage")]
public class Personnage
{
[XmlAttribute("Nom")] public string _nom;
[XmlElement("Age")] public int _age;
[XmlIgnore()] public short _taille;
[XmlElement("Naissance")] public DateTime _naissance;
[XmlElement("Yeux")] public yeux ye;
[XmlArray("Informations")] public string[] _infos;

public Personnage()
{
_infos = new String[4]{"kikoo", null, "lol", "juloe"};
_nom = "Kikoo";
_age = 31;
_taille = 183;
_naissance = new DateTime(1, 1, 1, 0, 0, 23);
ye = yeux.Rouge;
}
} 
 
Le fichier contient à présent : 

 
 
 
 

18 juillet 2008
 
26  La sérialisation 
 

3.3 Utilisation de schémas XML 
L'XML  permet  notamment  l'interopérabilité  des  informations  sérialisées.  Seulement,  ce 
procédé ne saurait être efficace si le schéma XML est différent d'une application à l'autre. 
Pour  assurer  que  tous  les  documents  XML  générés  auront  la  même  forme,  on  utilise  des 
schémas XML qui dictent comment sont agencés les éléments XML, quels attributs ils peuvent avoir… 
. 
Ces schémas de description sont contenus dans des fichiers et sont eux‐mêmes des documents 
XML.  Pour  plus  de  détails  sur  les  schémas 
XML, je vous invite à visiter Wikipedia ou le 
W3C. 
 
Une  fois  que  vous  possédez  un 
schéma  XML  dans  un  fichier  .xsd,  vous 
devez  le  transformer  en  classe  exploitable 
dans votre code. Pour ce faire, vous ouvrez 
la console Visual Studio.  
Dans cette console, vous utiliserez la 
commande suivante : 
 
Xsd.exe 
<chemin_vers_votre_schéma.xsd>  /classes 
/language:<CS ou VB> 
 
Une  fois  cette  commande  exécutée, 
un fichier .cs ou .vb sera généré (le chemin 
d'accès  du  fichier  généré  est  indiqué  dans 
la  console).  Il  vous  suffira  ensuite 
d'importer  ce  code  source  dans  votre 
solution.  La  classe  sera  prise  en  compte  automatiquement  à  chaque  fois  que  vous  sérialisez  un 
nouvel objet. 
 
 

18 juillet 2008
 
27  La sérialisation 
 

4 Conclusion 
Vous aurez rapidement constaté que la sérialisation est un moyen de stockage ou d'échange 
de données rapide et facile à utiliser. En effet, seules quelques classes et attributs sont nécessaires 
pour pouvoir enregistrer des objets dans des fichiers. De plus, il vous est tout à fait possible de créer 
votre propre outil de sérialisation. 
 
A la fin de ce chapitre, vous devez être capable de : 
¾ Savoir ce qu'est la sérialisation et la dé‐sérialisation. 
¾ Quels sont les types de sérialisation fournis par défaut dans le .NET Framework ainsi 
que leurs classes associées (BinaryFormatter, SoapFormatter, XmlSerializer). 
¾ Savoir  comment  modifier  le  processus  de  sérialisation  (Attributs  placés  devant  les 
membres). 
¾ Savoir comment utiliser un schéma XML lors d'une sérialisation. 
¾ Savoir comment créer son propre outil de sérialisation. 
 
Dans  tous  les  cas,  vous  pouvez  également  vous  aider  du  MSDN  pour  avoir  des  informations 
complémentaires au sujet des collections. 

18 juillet 2008