Share via

Procédure pas à pas : persistance d'un objet (C# et Visual Basic)

  • Article

Bien qu'il soit possible de définir des valeur par défaut pour les propriétés d'un objet au moment du design, les valeurs entrées lors de l'exécution sont perdues en cas de destruction de l'objet. Vous pouvez utiliser la sérialisation pour rendre les données d'un objet persistantes entre les instances, ce qui vous permet de stocker des valeurs et de les récupérer lors de la prochaine instanciation de l'objet.

Notes

En Visual Basic, vous pouvez utiliser l'objet My.Settings pour stocker données simples, telles qu'un nom ou un nombre. Pour plus d'informations, consultez Objet My.Settings (Visual Basic).

Dans cette procédure pas à pas, vous allez créer un objet Loan simple et rendre ses données persistantes dans un fichier. Vous récupérerez ensuite les données du fichier lors de la recréation de l'objet. Enfin, vous allez modifier le code afin de rendre l'objet persistant dans un format SOAP.

Note de sécuritéNote de sécurité

Cet exemple crée un fichier s'il n'existe pas. Si une application doit créer un fichier, elle doit disposer de l'autorisation Create pour accéder au dossier. Les autorisations sont définies à l'aide de listes de contrôle d'accès. Si le fichier existe déjà, l'application a uniquement besoin de l'autorisation Write, ce qui représente une autorisation inférieure. Lorsque cela est possible, il est plus sûr de créer le fichier au cours du déploiement et de n'accorder l'autorisation Read que sur un seul fichier (plutôt que l'autorisation Créer sur un dossier). En outre, il est plus sûr d'écrire les données dans des dossiers utilisateur que dans le dossier racine ou le dossier Program Files.
Note de sécuritéNote de sécurité

Cet exemple stocke les données dans un fichier au format binaire ou SOAP. Ces formats ne doivent pas être utilisés pour données sensibles, telles que les mots de passe ou les informations relatives à la carte de crédit.

Notes

Les boîtes de dialogue et les commandes de menu qui s'affichent peuvent être différentes de celles qui sont décrites dans l'aide, en fonction de vos paramètres actifs ou de l'édition utilisée. Pour modifier vos paramètres, cliquez sur Importation et exportation de paramètres dans le menu Outils. Pour plus d'informations, consultez Paramètres Visual Studio.

Création de l'objet Loan

La première étape consiste à créer une classe Loan et une application de test qui utilise cette classe.

Pour créer la classe Loan

  1. Créez un projet Bibliothèque de classes et nommez-le "LoanClass". Pour plus d'informations, consultez Comment : créer des solutions et des projets.

  2. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le fichier Class1, puis cliquez sur Renommer. Renommez le fichier en Loan et appuyez sur ENTRÉE. Lorsque vous renommez le fichier, la classe sera également renommée en Loan.

  3. Ajoutez les membres publics suivants à la classe :

    Public Class Loan
    Implements System.ComponentModel.INotifyPropertyChanged

    Public Property LoanAmount As Double
    Public Property InterestRate As Double
    Public Property Term As Integer

    Private p_Customer As String
    Public Property Customer As String
        Get
            Return p_Customer
        End Get
        Set(ByVal value As String)
            p_Customer = value
            RaiseEvent PropertyChanged(Me,
              New System.ComponentModel.PropertyChangedEventArgs("Customer"))
        End Set
    End Property

    Event PropertyChanged As System.ComponentModel.PropertyChangedEventHandler _
      Implements System.ComponentModel.INotifyPropertyChanged.PropertyChanged

    Public Sub New(ByVal loanAmount As Double,
                   ByVal interestRate As Double,
                   ByVal term As Integer,
                   ByVal customer As String)

        Me.LoanAmount = loanAmount
        Me.InterestRate = interestRate
        Me.Term = term
        p_Customer = customer
    End Sub
End Class

    public class Loan : System.ComponentModel.INotifyPropertyChanged
{
    public double LoanAmount {get; set;}
    public double InterestRate {get; set;}
    public int Term {get; set;}

    private string p_Customer;
    public string Customer
    {
        get { return p_Customer; }
        set 
        {
            p_Customer = value;
            PropertyChanged(this,
              new System.ComponentModel.PropertyChangedEventArgs("Customer"));
        }
    }

    public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;

    public Loan(double loanAmount,
                double interestRate,
                int term,
                string customer)
    {
        this.LoanAmount = loanAmount;
        this.InterestRate = interestRate;
        this.Term = term;
        p_Customer = customer;
    }
}

Vous devrez également créer une application simple qui utilise la classe Loan.

Pour créer une application de test

  1. Pour ajouter un projet d'application Windows Forms à votre solution, dans le menu Fichier, pointez sur Ajouter, puis cliquez sur Nouveau projet.

  2. Dans la boîte de dialogue Ajouter un nouveau projet, entrez LoanApp comme nom du projet et cliquez sur OK pour fermer la boîte de dialogue.

  3. Dans l'Explorateur de solutions, sélectionnez le projet LoanApp.

  4. Dans le menu Projet, cliquez sur Définir comme projet de démarrage.

  5. Dans le menu Projet, cliquez sur Ajouter une référence.

  6. Dans la boîte de dialogue Ajouter une référence, cliquez sur l'onglet Projets, puis sur le projet LoanClass.

  7. Cliquez sur OK pour fermer la boîte de dialogue.

  8. Dans le concepteur, ajoutez quatre contrôles TextBox au formulaire.

  9. Dans l'éditeur de code, ajoutez le code suivant :

    Private WithEvents TestLoan As New LoanClass.Loan(10000.0, 0.075, 36, "Neil Black")

Private Sub Form1_Load() Handles MyBase.Load
    TextBox1.Text = TestLoan.LoanAmount.ToString
    TextBox2.Text = TestLoan.InterestRate.ToString
    TextBox3.Text = TestLoan.Term.ToString
    TextBox4.Text = TestLoan.Customer
End Sub

    private LoanClass.Loan TestLoan = new LoanClass.Loan(10000.0, 0.075, 36, "Neil Black");

private void Form1_Load(object sender, EventArgs e)
{
    textBox1.Text = TestLoan.LoanAmount.ToString();
    textBox2.Text = TestLoan.InterestRate.ToString();
    textBox3.Text = TestLoan.Term.ToString();
    textBox4.Text = TestLoan.Customer;
}

  10. Ajoutez un gestionnaire d'événements pour l'événement PropertyChanged au formulaire en utilisant le code suivant :

    Public Sub CustomerPropertyChanged(
      ByVal sender As Object,
      ByVal e As System.ComponentModel.PropertyChangedEventArgs
    ) Handles TestLoan.PropertyChanged

    MsgBox(e.PropertyName & " has been changed.")
End Sub

    private void CustomerPropertyChanged(object sender, 
    System.ComponentModel.PropertyChangedEventArgs e)
{
    MessageBox.Show(e.PropertyName + " has been changed.");
}

À ce stade, vous pouvez générer et exécuter l'application. Remarquez que les valeurs par défaut de la classe Loan apparaissent dans les zones de texte. Essayez de remplacer le taux d'intérêt de 7,5 par 7,1, puis fermez l'application et exécutez-la de nouveau : le taux reprend sa valeur par défaut de 7,5.

Dans la réalité, les taux d'intérêt changent régulièrement, mais pas nécessairement chaque fois que l'application est exécutée. Plutôt que d'imposer à l'utilisateur de mettre à jour le taux d'intérêt chaque fois qu'il exécute l'application, il peut être plus judicieux de conserver le taux d'intérêt le plus récent entre les instances de l'application. C'est ce que vous ferez à l'étape suivante, en ajoutant la sérialisation à la classe Loan.

Utilisation de la sérialisation pour rendre l'objet persistant

Pour rendre les valeurs de la classe Loan persistantes, vous devez d'abord marquer la classe avec l'attribut Serializable.

Pour marquer une classe comme étant sérialisable

  • Modifiez la déclaration de la classe Loan de la façon suivante :

    <Serializable()>
Public Class Loan

    [Serializable()]
public class Loan : System.ComponentModel.INotifyPropertyChanged
{

L'attribut Serializable indique au compilateur que tout ce que contient la classe peut être persistant dans un fichier. Étant donné que l'événement PropertyChanged est géré par un objet Windows Form, il ne peut pas être sérialisé. L'attribut NonSerialized peut être utilisé pour marquer les membres de la classe qui ne doivent pas être persistants.

Pour empêcher la sérialisation d'un membre

  • Modifiez la déclaration de l'événement PropertyChanged comme suit :

    <NonSerialized()>
Event PropertyChanged As System.ComponentModel.PropertyChangedEventHandler _
  Implements System.ComponentModel.INotifyPropertyChanged.PropertyChanged

    [field: NonSerialized()]
public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;

L'étape suivante consiste à ajouter le code de sérialisation à l'application LoanApp. Afin de sérialiser la classe et de l'écrire dans un fichier, utilisez les noms d'espaces System.IO et System.Xml.Serialization. Pour éviter de taper les noms qualifiés complets, vous pouvez ajouter des références aux bibliothèques de classes requises.

Pour ajouter des références aux espaces de noms

  • Ajoutez les instructions suivantes au début de la classe Form1 :

    Imports System.IO
Imports System.Runtime.Serialization.Formatters.Binary

    using System.IO;
using System.Runtime.Serialization.Formatters.Binary;

    Dans ce cas, vous utilisez un formateur binaire pour enregistrer l'objet dans un format binaire. Plus loin dans cette procédure, vous allez modifier le code afin d'enregistrer l'objet dans un format SOAP.

L'étape suivante consiste à ajouter le code permettant de désérialiser l'objet à partir du fichier lors de la création de l'objet.

Pour désérialiser un objet

  1. Ajoutez une constante à la classe pour le nom de fichier des données sérialisées.

    Const FileName As String = "..\..\SavedLoan.bin"

    const string FileName = @"..\..\SavedLoan.bin";

  2. Modifiez le code de la procédure événementielle Form1_Load de la façon suivante :

    Private WithEvents TestLoan As New LoanClass.Loan(10000.0, 0.075, 36, "Neil Black")

Private Sub Form1_Load() Handles MyBase.Load
    If File.Exists(FileName) Then
        Dim TestFileStream As Stream = File.OpenRead(FileName)
        Dim deserializer As New BinaryFormatter
        TestLoan = CType(deserializer.Deserialize(TestFileStream), LoanClass.Loan)
        TestFileStream.Close()
    End If

    AddHandler TestLoan.PropertyChanged, AddressOf Me.CustomerPropertyChanged

    TextBox1.Text = TestLoan.LoanAmount.ToString
    TextBox2.Text = TestLoan.InterestRate.ToString
    TextBox3.Text = TestLoan.Term.ToString
    TextBox4.Text = TestLoan.Customer
End Sub

    private LoanClass.Loan TestLoan = new LoanClass.Loan(10000.0, 0.075, 36, "Neil Black");

private void Form1_Load(object sender, EventArgs e)
{
    if (File.Exists(FileName))
    {
        Stream TestFileStream = File.OpenRead(FileName);
        BinaryFormatter deserializer = new BinaryFormatter();
        TestLoan = (LoanClass.Loan)deserializer.Deserialize(TestFileStream);
        TestFileStream.Close();
    }

    TestLoan.PropertyChanged += this.CustomerPropertyChanged;

    textBox1.Text = TestLoan.LoanAmount.ToString();
    textBox2.Text = TestLoan.InterestRate.ToString();
    textBox3.Text = TestLoan.Term.ToString();
    textBox4.Text = TestLoan.Customer;
}

    Remarquez que vous devez d'abord vérifier que le fichier existe. S'il existe, créez une classe Stream pour lire le fichier binaire et une classe BinaryFormatter pour convertir le fichier. Vous devez également convertir le type de flux en type d'objet Loan.

Vous devez ensuite ajouter le code permettant d'enregistrer dans la classe Loan les données saisies dans les zones de texte, puis ensuite de sérialiser la classe dans un fichier.

Pour enregistrer les données et sérialiser la classe

  • Ajoutez le code suivant à la procédure événementielle Form1_FormClosing :

    Private Sub Form1_FormClosing() Handles MyBase.FormClosing
    TestLoan.LoanAmount = CDbl(TextBox1.Text)
    TestLoan.InterestRate = CDbl(TextBox2.Text)
    TestLoan.Term = CInt(TextBox3.Text)
    TestLoan.Customer = TextBox4.Text

    Dim TestFileStream As Stream = File.Create(FileName)
    Dim serializer As New BinaryFormatter
    serializer.Serialize(TestFileStream, TestLoan)
    TestFileStream.Close()
End Sub

    private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
    TestLoan.LoanAmount = Convert.ToDouble(textBox1.Text);
    TestLoan.InterestRate = Convert.ToDouble(textBox2.Text);
    TestLoan.Term = Convert.ToInt32(textBox3.Text);
    TestLoan.Customer = textBox4.Text;

    Stream TestFileStream = File.Create(FileName);
    BinaryFormatter serializer = new BinaryFormatter();
    serializer.Serialize(TestFileStream, TestLoan);
    TestFileStream.Close();
}

À ce stade, vous pouvez de nouveau générer et exécuter l'application. À l'origine, les valeurs par défaut s'affichent dans les zones de texte. Essayez de modifier les valeurs et de taper un nom dans la quatrième zone de texte. Fermez l'application et exécutez-la de nouveau. Notez que les nouvelles valeurs s'affichent maintenant dans les zones de texte.

Persistance de l'objet à l'aide d'un format SOAP

Jusqu'à présent, l'exemple a illustré la persistance d'un objet dans un fichier texte à l'aide d'un format binaire. Un tel format est parfait pour la plupart des applications Windows. Pour les applications ou les services Web, vous pouvez rendre l'objet persistant dans un fichier XML à l'aide d'un format SOAP, ce qui facilite le partage de l'objet.

Pour rendre l'objet persistant dans un format SOAP, vous devez d'abord référencer la classe SoapFormatter. La classe SoapFormatter se trouve dans son propre espace de noms : System.Runtime.Serialization.Formatters.Soap.

Pour rendre persistant l'objet à l'aide d'un format SOAP

  1. Dans l'Explorateur de solutions, sélectionnez le projet LoanApp.

  2. Dans le menu Projet, cliquez sur Ajouter une référence.

  3. Dans la boîte de dialogue Ajouter une référence, cliquez sur l'onglet .NET, puis sur le composant System.Runtime.Serialization.Formatters.Soap.

  4. Cliquez sur OK pour fermer la boîte de dialogue.

  5. Dans l'éditeur de code, ajoutez l'instruction suivante au début du module Form1 :

    Imports System.Runtime.Serialization.Formatters.Soap

    using System.Runtime.Serialization.Formatters.Soap;

  6. Remplacez le nom de fichier SavedLoan.bin par SavedLoan.xml.

  7. Dans la procédure événementielle Form1_Load, remplacez la déclaration de la variable deserializer par l'élément suivant :

    Dim deserializer As New SoapFormatter

    SoapFormatter deserializer = new SoapFormatter();

  8. Dans la procédure événementielle Form1_FormClosing, remplacez la déclaration de la variable serializer par l'élément suivant :

    Dim serializer As New SoapFormatter

    SoapFormatter serializer = new SoapFormatter();

À ce stade, vous pouvez générer et tester l'application. Lors de la première exécution de l'application, le fichier SavedLoan.xml est créé. Pour afficher ce fichier, sélectionnez l'option Afficher tous les fichiers dans l'Explorateur de solutions ; il se trouve sous le nœud Bin du projet d'application Windows.

Notes

Si le mode Afficher tous les fichiers est déjà activé, vous devez actualiser la vue en cliquant sur Actualiser dans le menu Affichage pour voir le fichier.

Remarquez que les trois membres de LoanClass s'affichent au format XML. Essayez de modifier la valeur InterestRate dans le fichier XML, enregistrez-le puis exécutez de nouveau l'application. Le nouveau taux d'intérêt s'affiche dans la deuxième zone de texte.

Voir aussi

Concepts

Guide de programmation C#

Autres ressources

Sérialisation (C# et Visual Basic)

Guide de programmation Visual Basic