Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez aussi afficher la version anglaise dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte.
Traduction
Anglais

Initialisation et suppression des composants

Votre composant est initialisé par son constructeur (SubNew en Visual Basic) et détruit par son destructeur (SubFinalizeen Visual Basic). Le constructeur de votre composant est appelé lorsqu'une instance est créée ; passé ce moment, il ne peut plus être appelé. Le destructeur est appelé juste avant que votre composant ne soit détruit par l'opération garbage collection et sa mémoire libérée.

Remarque pour Visual Basic Remarque pour Visual Basic

Dans les versions antérieures de Visual Basic, les événements Initialize et Terminate remplissaient les fonctions désormais dévolues respectivement au constructeur et au destructeur.

Quand le garbage collection a déterminé que le composant ne peut plus être atteint par aucun code d'exécution, le Common Language Runtime appelle votre destructeur de composant. Cela arrive quand toutes les références au composant ont été libérées ou si les seules références à votre composant sont contenues dans des objets isolés de tout code d'exécution, par exemple dans le cas des références circulaires.

Parce qu'il peut se passer un certain temps entre le moment où l'utilisateur a fini de se servir de votre composant et celui où le destructeur est appelé, une étape supplémentaire est introduite dans la durée de vie des composants .NET Framework : si votre composant acquiert des ressources système, telles que des connexions à une base de données ou des handles vers des objets système Windows, vous devez implémenter l'interface IDisposable et fournir une méthode Dispose de sorte que les utilisateurs de votre composant puissent choisir le moment auquel ils libèreront ces ressources.

Initialisation du type : Lorsque la première instance de votre composant est créée, le premier code à s'exécuter est un code d'initialisation partagé. Une référence à un membre partagé provoque également l'exécution du constructeur partagé. Cela inclut tous les champs partagés (variables de membre) initialisées, ainsi que le constructeur partagé (SharedSubNew) s'il existe. Dans le code suivant, une police de référence est créée pour la classe tout entière.

Remarque Remarque

Le mot clé C# qui correspond à Shared est static qui ne doit pas être confondu avec le mot clé Static dans Visual Basic.

class ADrawing
{
   static Font m_referenceFont = new Font("TimesNewRoman", 14);
   // Simply add the static keyword to create a static constructor.
   // Static constructors do not have any parameters.
   static ADrawing()
   {
      // There is no call to the base class's static constructor.
      // Code to initialize the font here.
   }
}
RemarqueRemarque

L'initialisation de classe peut se produire même si aucune instance de votre composant n'est créée. Par exemple, une classe abstract, (MustInherit) avec des fonctions membres partagés sera initialisée et ces fonctions seront disponibles pour l'application, bien qu'aucune instance de la classe ne soit créée.

  1. Initialisation d'instance : lorsqu'une instance de votre composant est créée, les membres de données comportant des codes d'initialisation sont initialisés et la surcharge de constructeur appropriée est exécutée. Le code suivant initialise un champ privé et définit deux constructeurs. L'un est appelé en l'absence de paramètres et l'autre est appelé lorsque l'utilisateur spécifie des paramètres.

    class AShape
    {
       private int m_answer = 42;
       // Forward to another constructor.
       public AShape() 
       : this(System.Drawing.Color.Red, 5280, DefinedSizes.Large)
       {
          // Additional initialization goes here.
       }
    
       public AShape(Color color, int length, DefinedSizes size)
       {
          // Code to initialize the class goes here.
       }
       // Defines the DefinedSizes enum
       public enum DefinedSizes
       {
          Large,
          Small
       }
    }
    
  2. Disposition de ressources : si votre composant implémente l'interface IDisposable, il doit fournir une méthode Dispose, que le client doit appeler lorsqu'il a terminé d'utiliser le composant. Notez que tout composant qui hérite de Component comporte déjà une implémentation par défaut de Dispose, qui peut être remplacée pour fournir un code de nettoyage supplémentaire. Dans la méthode Dispose, votre composant libère toutes les ressources système allouées, les références à d'autres objets et s'affiche comme étant inutilisable. Dans certaines instances, votre composant peut avoir besoin d'appeler sa propre méthode Dispose. Le code suivant supprime un objet dépendant qui comporte une méthode Dispose.

    // Assumes that the class implements IDisposable
    public void IDisposable.Dispose()
    {
       mywidget.Dispose();
       mywidget = null;
       // Dispose of remaining objects.
    }
       
    

    Lorsque vous avez appelé Dispose, votre client doit libérer toutes les références au composant restantes, de sorte que le nettoyage de la mémoire puisse libérer la mémoire du composant.

  3. Instance destruction: Lorsque le garbage collection détecte qu'il n'existe aucune référence demeurante au composant, le runtime appelle le destructeur de votre composant (Finalizeen Visual Basic) et libère la mémoire. Vous devez remplacer la méthode Finalize de votre classe de base (pour Visual Basic) ou implémenter un destructeur (pour Visual C#) pour implémenter votre propre code de nettoyage. Vous devez toujours inclure un appel au destructeur ou à la méthode Finalize de la classe de base.

    // In C#, a destructor is used instead of a Finalize method.
    ~ThisClass()
    {
       m_gadget = null;
       m_gear = null;
       // The base class finalizer is called automatically
    }
    

Si votre composant hérite de Component, une implémentation par défaut de Dispose est fournie. Cette implémentation peut être substituée par un code de nettoyage personnalisé. Si vous constituez votre composant en créant une implémentation personnalisée de IComponent, vous devez implémenter IDisposable afin de fournir une méthode Dispose pour votre composant.

Votre composant a besoin d'une méthode Dispose s'il alloue des objets système, des connexions à la base de données et d'autres ressources rares qui doivent être libérées dès qu'un utilisateur a fini de se servir d'un composant.

Vous devez également implémenter une méthode Dispose si votre composant contient des références à d'autres objets possédant des méthodes Dispose.

Selon l'activité du système, un intervalle d'une durée imprévisible peut s'écouler entre le moment où un utilisateur a fini de se servir d'un composant et celui où l'opération garbage collection détecte que le code du composant n'est plus accessible. Si vous ne fournissez pas de méthode Dispose, votre composant stockera ses ressources pendant cet intervalle.

Imaginez qu'un composant serveur ne possédant pas de méthode Dispose utilise une connexion à une base de données. Si le serveur dispose d'une mémoire importante, vous pouvez créer et libérer de très nombreuses instances du composant sans impact réel sur la taille de l'espace libre. Dans un tel cas, l'opération garbage collection peut détruire les composants longtemps après que les références à ces composants ont été libérées.

En fin de compte, toutes les connexions de base de données disponibles pourraient se trouver occupées par des composants libérés mais pas encore détruits. Bien qu'il n'y ait pas pénurie de mémoire sur le serveur, celui-ci pourrait se trouver dans l'incapacité de répondre aux demandes des utilisateurs.

Afficher: