Utilisation de constructeurs et de destructeurs

Mise à jour : novembre 2007

Les constructeurs et les destructeurs régissent la création et la destruction des objets.

Constructeurs

Pour créer un constructeur d'une classe, créez une procédure nommée Sub New à n'importe quel endroit de la définition de la classe. Pour créer un constructeur paramétré, spécifiez les noms et les types de données des arguments de la procédure Sub New, de la même façon que vous définiriez les arguments de toute autre procédure, comme dans le code ci-dessous :

Sub New(ByVal s As String)

Les constructeurs sont souvent surchargés, comme l'illustre le code suivant :

Sub New(ByVal s As String, i As Integer)

Quand vous définissez une classe dérivée d'une autre classe, la première ligne d'un constructeur doit constituer un appel au constructeur de la classe de base, à moins que la classe de base ne possède un constructeur accessible n'acceptant pas de paramètre. Un appel à la classe de base contenant le constructeur ci-dessus, par exemple, serait MyBase.New(s). Sinon, MyBase.New est facultatif, et le runtime Visual Basic l'appelle implicitement.

À la suite du code qui appelle le constructeur de l'objet parent, vous pouvez éventuellement ajouter du code d'initialisation supplémentaire à la procédure Sub New. Sub New peut accepter des arguments lorsqu'il est appelé en tant que constructeur paramétré. Ces paramètres sont passés à partir de la procédure qui appelle le constructeur, comme dans Dim AnObject As New ThisClass(X).

Destructeurs

Le code suivant montre comment utiliser Dispose et Finalize pour libérer des ressources dans une classe de base.

Remarque :
Vous devez suivre les instructions pour implémenter IDisposable défini dans Durée de vie d'un objet : création et destruction des objets.

    ' Design pattern for a base class.
    Public Class Base
        Implements IDisposable

        ' Keep track of when the object is disposed.
        Protected disposed As Boolean = False

        ' This method disposes the base object's resources.
        Protected Overridable Sub Dispose(ByVal disposing As Boolean)
            If Not Me.disposed Then
                If disposing Then
                    ' Insert code to free managed resources.
                End If
                ' Insert code to free unmanaged resources.
            End If
            Me.disposed = True
        End Sub

#Region " IDisposable Support "
        ' Do not change or add Overridable to these methods.
        ' Put cleanup code in Dispose(ByVal disposing As Boolean).
        Public Sub Dispose() Implements IDisposable.Dispose
            Dispose(True)
            GC.SuppressFinalize(Me)
        End Sub
        Protected Overrides Sub Finalize()
            Dispose(False)
            MyBase.Finalize()
        End Sub
#End Region
    End Class

Le code suivant montre comment utiliser Dispose et Finalize pour libérer des ressources dans une classe dérivée.

' Design pattern for a derived class.
Public Class Derived
    Inherits Base

    ' This method disposes the derived object's resources.
    Protected Overrides Sub Dispose(ByVal disposing As Boolean)
        If Not Me.disposed Then
            If disposing Then
                ' Insert code to free managed resources.
            End If
            ' Insert code to free unmanaged resources.
        End If
        MyBase.Dispose(disposing)
    End Sub

    ' The derived class does not have a Finalize method
    ' or a Dispose method with parameters because it inherits
    ' them from the base class.
End Class

Le code suivant présente un modèle de design commun pour le destructeur Dispose, à l'aide d'un bloc Using et d'un bloc Try...Finally équivalent.

Sub DemonstrateUsing()
    Using d As New Derived
        ' Code to use the Derived object goes here.
    End Using
End Sub

Sub DemonstrateTry()
    Dim d As Derived = Nothing
    Try
        d = New Derived
        ' Code to use the Derived object goes here.
    Finally
        ' Call the Dispose method when done, even if there is an exception.
        If Not d Is Nothing Then
            d.Dispose()
        End If
    End Try
End Sub

L'exemple suivant crée un objet à l'aide d'un constructeur paramétré, puis appelle des destructeurs une fois que l'objet a perdu son utilité.

Remarque :
Bien que cet exemple utilise Collect pour indiquer les méthodes appelées par le garbage collector pour supprimer des méthodes, il est préférable généralement de laisser le Common Language Runtime (CLR) gérer l'opération garbage collection.

Sub TestConstructorsAndDestructors()
    ' Demonstrate how the Using statement calls the Dispose method.
    Using AnObject As New ThisClass(6)
        ' Place statements here that use the object.
        MsgBox("The value of ThisProperty after being initialized " & _
        " by the constructor is " & AnObject.ThisProperty & ".")
    End Using

    ' Demonstrate how the garbage collector calls the Finalize method.
    Dim AnObject2 As New ThisClass(6)
    AnObject2 = Nothing
    GC.Collect()
End Sub

Public Class BaseClass
    Sub New()
        MsgBox("BaseClass is initializing with Sub New.")
    End Sub

    Protected Overrides Sub Finalize()
        MsgBox("BaseClass is shutting down with Sub Finalize.")
        ' Place final cleanup tasks here.
        MyBase.Finalize()
    End Sub
End Class

Public Class ThisClass
    Inherits BaseClass
    Implements IDisposable

    Sub New(ByVal SomeValue As Integer)
        ' Call MyBase.New if this is a derived class.
        MyBase.New()
        MsgBox("ThisClass is initializing with Sub New.")
        ' Place initialization statements here. 
        ThisPropertyValue = SomeValue
    End Sub

    Private ThisPropertyValue As Integer
    Property ThisProperty() As Integer
        Get
            CheckIfDisposed()
            ThisProperty = ThisPropertyValue
        End Get
        Set(ByVal Value As Integer)
            CheckIfDisposed()
            ThisPropertyValue = Value
        End Set
    End Property

    Protected Overrides Sub Finalize()
        MsgBox("ThisClass is shutting down with Sub Finalize.")
        Dispose(False)
    End Sub

    ' Do not add Overridable to this method.
    Public Overloads Sub Dispose() Implements IDisposable.Dispose
        MsgBox("ThisClass is shutting down with Sub Dispose.")
        Dispose(True)
        GC.SuppressFinalize(Me)
    End Sub

    Private disposed As Boolean = False
    Public Sub CheckIfDisposed()
        If Me.disposed Then
            Throw New ObjectDisposedException(Me.GetType().ToString, _
            "This object has been disposed.")
        End If
    End Sub

    Protected Overridable Overloads Sub Dispose( _
    ByVal disposing As Boolean)
        MsgBox("ThisClass is shutting down with the Sub Dispose overload.")
        ' Place final cleanup tasks here.
        If Not Me.disposed Then
            If disposing Then
                ' Dispose of any managed resources.
            End If
            ' Dispose of any unmanaged resource.

            ' Call MyBase.Finalize if this is a derived class, 
            ' and the base class does not implement Dispose.
            MyBase.Finalize()
        End If
        Me.disposed = True
    End Sub

End Class

Lorsque vous exécutez cet exemple, la classe ThisClass appelle le constructeur Sub New de la classe BaseClass. Au terme de l'exécution du constructeur de la classe de base, la classe ThisClass exécute les instructions restantes de Sub New qui initialisent une valeur pour la propriété ThisProperty.

Quand la classe n'est plus nécessaire, le destructeur Dispose est appelé dans ThisClass.

Cet exemple affiche les éléments suivants :

BaseClass is initializing with Sub New.

ThisClass is initializing with Sub New.

The value of ThisProperty after being initialized by the constructor is 6.

ThisClass is shutting down with Sub Dispose.

ThisClass is shutting down with the Sub Dispose overload.

BaseClass is shutting down with Sub Finalize.

BaseClass is initializing with Sub New.

ThisClass is initializing with Sub New.

ThisClass is shutting down with Sub Finalize.

ThisClass is shutting down with the Sub Dispose overload.

BaseClass is shutting down with Sub Finalize.

Voir aussi

Concepts

Durée de vie d'un objet : création et destruction des objets

Destructeurs et méthodes Finalize

Fonctionnement des méthodes New et Finalize dans une hiérarchie de classe

Référence

Dispose