Utiliser la sérialisation pour assurer la persistance des objets (partie 1)

Auteur Stéphane Sibué

Le Compact Framework 2 permet d'utiliser la sérialisation XML. Cette fonctionnalité permet de sauvegarder et de restaurer un objet en écrivant toutes les propriétés qui le composent sous la forme d'un flux XML, et ce de manière automatique. Cette fonctionnalité existe dans le Framework depuis le début, mais il a fallu attendre la version 2 du Compact Framework pour pouvoir en bénéficier. Alors il ne faut pas s'en priver car c'est extrêmement pratique !

Vous devez utiliser l'espace de noms System.Xml.Serialization. Là se trouvent toutes les classes nécessaires pour réaliser les opérations de sérialisation/dé-sérialisation. Vous devez ajouter la référence System.Xml à votre projet pour pouvoir accéder à cet espace de noms.

Nous allons apprendre à sérialiser un objet simple de notre cru :

Public Class Projet
           
    Public Code As String
    Public Libelle As String
    Public Actif As Boolean

    Public Sub New(Byval wCode As String, ByVal wLibelle As String, Byval wActif As Boolean)
           
        Code = wCode
        Libelle = wLibelle
        Actif = wActif
           
    End Sub

End Class

Pour être sérialisable, une classe doit répondre à deux critères :

1 Un constructeur sans paramètre
2 L'attribut <Serializable()>

Dans notre cas, il faut donc ajouter le constructeur sans paramètre et l'attribut, ce qui donne :

<Serializable()> _
Class Projet
           
    Public Code As String
    Public Libelle As String
    Public Actif As Boolean

    Public Sub New()
    End Sub

    Public Sub New(Byval wCode As String, ByVal wLibelle As String, Byval wActif As Boolean)
           
        Code = wCode
        Libelle = wLibelle
        Actif = wActif
           
    End Sub

End Class

Maintenant il faut ajouter le code de sérialisation. La fonction Save que nous allons créer va prendre en paramètre le nom du fichier XML et s'occuper de créer le flux XML de l'objet. Cette fonction retourne True si elle fonctionne et False dans le cas contraire sans provoquer d'exception (c'est un choix, vous pouvez changer ça si vous voulez).

Public Function Save(ByVal wFilename As String) As Boolean          

    Dim wFile As System.IO.StreamWriter
    Dim wSerializer As System.Xml.Serialization.XmlSerializer
    Dim wRetval As Boolean

    REM Ouverture du fichier
    Try
        wFile = New System.IO.StreamWriter(wFilename, False)
    Catch ex As Exception
        MsgBox(ex.Message, MsgBoxStyle.Exclamation)
        Return False
    End Try

    REM Création du serializer
    wSerializer = New System.Xml.Serialization.XmlSerializer(Me.GetType)
    wRetval = True

    REM Ecriture des infos XML
    Try
        wSerializer.Serialize(wFile, Me)
    Catch ex As Exception
        MsgBox(ex.Message, MsgBoxStyle.Exclamation)
        wRetval = False
    End Try

    REM Fermeture du fichier
    wFile.Close()

    Return wRetval

End Function

Le principe est très simple, on ouvre le fichier, puis on créé un objet de type System.Xml.Serialization.XmlSerializer en lui donnant le type de la classe à sérialiser (le passage avec Me.GetType dans le code). Puis on invoque la méthode Serialize du XmlSerializer avec en paramètres le fichier à créer et l'instance à enregistrer, dans notre cas, l'objet lui même (Me en VB).

Cette fonction créé un fichier XML représentant l'objet. Pour un objet Projet contenant les informations suivantes :

La sérialisation va créer le fichier XML suivant :

A partir de ce fichier il est tout à fait possible de recréer un objet Projet avec les mêmes valeurs de propriétés. C'est l'opération de dé-sérialisation.

Le plus pratique pour dé-sérialiser est d'ajouter une méthode Load partagée (Shared en VB ou Static en C#) à la classe. Nous allons donc ajouter cette méthode à notre classe Projet. Pour recharger un objet Projet depuis un fichier XML créé par la sérialisation, il faudra utiliser la classe Projet elle même et non obligatoirement une instance de Projet (c'est le but de la méthode partagée).

Voici le code de dé-sérialisation :

Public Shared Function Load(ByVal wFilename As String) As Projet

    Dim wFile As System.IO.StreamReader = Nothing
    Dim wSerializer As System.Xml.Serialization.XmlSerializer
    Dim wInstance As Projet = Nothing

    REM On ouvre le fichier
    Try
        wFile = New System.IO.StreamReader(wFilename)
    Catch ex As Exception
    End Try

    If wFile IsNot Nothing Then

        REM Lecture de l'objet
        wSerializer = New System.Xml.Serialization.XmlSerializer(GetType(Projet))
        Try
            wInstance = wSerializer.Deserialize(wFile)
        Catch ex As Exception
           MsgBox(ex.Message, MsgBoxStyle.Exclamation)
        End Try

        REM Fermeture du fichier
        wFile.Close()

    End If

    REM On retourne l'objet lu (ou nothing si erreur de lecture)
    Return wInstance

End Function

Le principe de la dé-sérialisation ressemble beaucoup à celui de la sérialisation (c'est logique me direz-vous). Une fois le fichier ouvert, le XmlSerialiser, qui a été instancé avec le type de l'objet à dé-sérialiser en paramètre, génère un nouvel objet de ce type lorsqu'on invoque sa méthode Deserialize. Si le fichier XML est au bon format, une nouvelle instance de l'objet est créé et les différentes propriétés publiques qui le composent sont chargées avec les valeurs prises dans le fichier XML.

A partir du fichier XML généré avec l'objet Projet que nous avons créé plus haut, nous pouvons recréer une instance identique à l'objet d'origine :

Le processus de sérialisation enregistre toutes les propriétés publiques dans le fichier XML. Si pour une raison ou une autre vous ne voulez pas qu'une propriété soit enregistrée, il faut utiliser sur elle l'attribut Xml.Serialization.XmlIgnore().

Dans la prochaine partie, nous étudierons comment sérialiser des objets complexes en implémentant l'interface System.Xml.Serialization.IXmlSerializable.

Stéphane Sibué