Partager via

Objets et classes en Visual Basic

Un objet est une combinaison de code et de données qui peuvent être traitées comme une unité. Un objet peut être un élément d’une application, comme un contrôle ou un formulaire. Une application entière peut également être un objet.

Lorsque vous créez une application en Visual Basic, vous travaillez constamment avec des objets. Vous pouvez utiliser des objets fournis par Visual Basic, tels que des contrôles, des formulaires et des objets d’accès aux données. Vous pouvez également utiliser des objets à partir d’autres applications au sein de votre application Visual Basic. Vous pouvez même créer vos propres objets et définir des propriétés et des méthodes supplémentaires pour eux. Les objets agissent comme des blocs de construction préfabriqués pour les programmes : ils vous permettent d’écrire un morceau de code une fois et de le réutiliser.

Cette rubrique décrit en détail les objets.

Objets et classes

Chaque objet en Visual Basic est défini par une classe. Une classe décrit les variables, propriétés, procédures et événements d’un objet. Les objets sont des instances de classes ; vous pouvez créer autant d’objets que nécessaire une fois que vous avez défini une classe.

Pour comprendre la relation entre un objet et sa classe, pensez aux coupeurs de cookies et aux cookies. L’emporte-pièce est la classe. Il définit les caractéristiques de chaque cookie, par exemple la taille et la forme. La classe est utilisée pour créer des objets. Les objets sont les cookies.

Vous devez créer un objet avant de pouvoir accéder à ses membres, à l’exception des Shared membres accessibles sans objet de la classe.

Créer un objet à partir d’une classe

  1. Déterminez à partir de quelle classe vous souhaitez créer un objet ou définissez votre propre classe. Par exemple:

    Public Class Customer
    Public Property AccountNumber As Integer
End Class

  2. Écrivez une instruction Dim pour créer une variable à laquelle vous pouvez affecter une instance de classe. La variable doit être du type de la classe souhaitée.

    Dim nextCustomer As Customer

  3. Ajoutez le mot clé New Operator pour initialiser la variable à une nouvelle instance de la classe.

    Dim nextCustomer As New Customer

  4. Vous pouvez désormais accéder aux membres de la classe via la variable d’objet.

    nextCustomer.AccountNumber = lastAccountNumber + 1

Remarque

Dans la mesure du possible, vous devez déclarer la variable à être du type de classe que vous avez l’intention de lui affecter. Il s’agit de la liaison anticipée. Si vous ne connaissez pas le type de classe au moment de la compilation, vous pouvez appeler la liaison tardive en déclarant la variable à être du type de données objet. Toutefois, la liaison tardive peut ralentir les performances et limiter l’accès aux membres de l’objet de l’exécution. Pour plus d’informations, consultez Déclaration de variable objet.

Instances multiples

Les objets nouvellement créés à partir d’une classe sont souvent identiques les uns aux autres. Une fois qu’ils existent en tant qu’objets individuels, toutefois, leurs variables et leurs propriétés peuvent être modifiées indépendamment des autres instances. Par exemple, si vous ajoutez trois cases à cocher à un formulaire, chaque objet de case à cocher est une instance de la CheckBox classe. Les objets individuels CheckBox partagent un ensemble commun de caractéristiques et de fonctionnalités (propriétés, variables, procédures et événements) définies par la classe. Toutefois, chacun a son propre nom, peut être activé séparément et désactivé, et peut être placé dans un autre emplacement sur le formulaire.

Membres de l’objet

Un objet est un élément d’une application qui représente une instance d’une classe. Les champs, propriétés, méthodes et événements sont les blocs de construction des objets et constituent leurs membres.

Accès aux membres

Vous accédez à un membre d’un objet en spécifiant, dans l’ordre, le nom de la variable objet, un point (.) et le nom du membre. L’exemple suivant définit la Text propriété d’un Label objet.

warningLabel.Text = "Data not saved"

Liste IntelliSense des membres

IntelliSense répertorie les membres d’une classe lorsque vous appelez son option Liste des membres, par exemple lorsque vous tapez un point (.) comme opérateur d’accès au membre. Si vous tapez le point après le nom d’une variable déclarée en tant qu’instance de cette classe, IntelliSense répertorie tous les membres de l’instance et aucun membre partagé. Si vous tapez le point après le nom de la classe, IntelliSense répertorie tous les membres partagés et aucun des membres de l’instance. Pour plus d’informations, consultez Utilisation d’IntelliSense.

Champs et propriétés

Les champs et les propriétés représentent les informations stockées dans un objet. Vous récupérez et définissez leurs valeurs avec des instructions d’affectation de la même façon que vous récupérez et définissez des variables locales dans une procédure. L’exemple suivant récupère la Width propriété et définit la ForeColor propriété d’un Label objet.

Dim warningWidth As Integer = warningLabel.Width
warningLabel.ForeColor = System.Drawing.Color.Red

Notez qu’un champ est également appelé variable membre.

Utilisez des procédures de propriété quand :

  • Vous devez contrôler quand et comment une valeur est définie ou récupérée.

  • La propriété a un ensemble bien défini de valeurs qui doivent être validées.

  • La définition de la valeur entraîne une modification perceptible de l’état de l’objet, par exemple une IsVisible propriété.

  • La définition de la propriété entraîne des modifications apportées à d’autres variables internes ou aux valeurs d’autres propriétés.

  • Un ensemble d’étapes doit être effectué avant que la propriété puisse être définie ou récupérée.

Utilisez des champs quand :

  • La valeur est d’un type auto-validateur. Par exemple, une erreur ou une conversion automatique de données se produit si une valeur autre que True ou False est affectée à une Boolean variable.

  • Toute valeur de la plage prise en charge par le type de données est valide. Cela est vrai de nombreuses propriétés de type Single ou Double.

  • La propriété est un String type de données et il n’existe aucune contrainte sur la taille ou la valeur de la chaîne.

  • Pour plus d’informations, consultez Procédures de propriété.

Conseil / Astuce

Conservez toujours les champs non constants privés. Lorsque vous souhaitez le rendre public, utilisez plutôt une propriété.

Méthodes

Une méthode est une action qu’un objet peut effectuer. Par exemple, Add est une méthode de l’objet ComboBox qui ajoute une nouvelle entrée à une zone de liste déroulante.

L’exemple suivant illustre la Start méthode d’un Timer objet.

Dim safetyTimer As New System.Windows.Forms.Timer
safetyTimer.Start()

Notez qu’une méthode est simplement une procédure exposée par un objet.

Pour plus d’informations, consultez Procédures.

Événements

Un événement est une action reconnue par un objet, par exemple en cliquant sur la souris ou en appuyant sur une touche, et pour laquelle vous pouvez écrire du code pour répondre. Les événements peuvent se produire à la suite d’une action utilisateur ou d’un code de programme, ou ils peuvent être provoqués par le système. Le code qui signale un événement est dit pour déclencher l’événement et le code qui répond à celui-ci est dit pour le gérer .

Vous pouvez également développer vos propres événements personnalisés pour être déclenchés par vos objets et gérés par d’autres objets. Pour plus d’informations, consultez Événements.

Membres d’instance et membres partagés

Lorsque vous créez un objet à partir d’une classe, le résultat est une instance de cette classe. Les membres qui ne sont pas déclarés avec le mot clé Partagé sont des membres d’instance, qui appartiennent strictement à cette instance particulière. Un membre d’instance dans une instance est indépendant du même membre dans une autre instance de la même classe. Une variable membre d’instance, par exemple, peut avoir des valeurs différentes dans différentes instances.

Les membres déclarés avec le Shared mot clé sont des membres partagés, qui appartiennent à la classe dans son ensemble et non à une instance particulière. Un membre partagé n’existe qu’une seule fois, quel que soit le nombre d’instances de sa classe que vous créez, ou même si vous ne créez aucune instance. Une variable membre partagée, par exemple, n’a qu’une seule valeur, qui est disponible pour tout le code pouvant accéder à la classe.

Accès aux membres non partagés

  1. Vérifiez que l’objet a été créé à partir de sa classe et affecté à une variable d’objet.

    Dim secondForm As New System.Windows.Forms.Form

  2. Dans l’instruction qui accède au membre, suivez le nom de la variable objet avec l’opérateur d’accès membre (.), puis le nom du membre.

    secondForm.Show()

Accès aux membres partagés

  • Suivez le nom de la classe avec l’opérateur d’accès membre (.), puis le nom du membre. Vous devez toujours accéder à un Shared membre de l’objet directement via le nom de la classe.

    Console.WriteLine("This computer is called " & Environment.MachineName)

  • Si vous avez déjà créé un objet à partir de la classe, vous pouvez également accéder à un Shared membre via la variable de l’objet.

Différences entre les classes et les modules

La principale différence entre les classes et les modules est que les classes peuvent être instanciées en tant qu’objets, tandis que les modules standard ne peuvent pas. Étant donné qu’il n’existe qu’une seule copie des données d’un module standard, lorsqu’une partie de votre programme modifie une variable publique dans un module standard, toute autre partie du programme obtient la même valeur si elle lit ensuite cette variable. En revanche, les données d’objet existent séparément pour chaque objet instancié. Une autre différence est que contrairement aux modules standard, les classes peuvent implémenter des interfaces. Si une classe est marquée avec le modificateur MustInherit , elle ne peut pas être instanciée directement. Toutefois, il est toujours différent d’un module, car il peut être hérité tandis que les modules ne peuvent pas être hérités.

Remarque

Lorsque le Shared modificateur est appliqué à un membre de classe, il est associé à la classe elle-même au lieu d’une instance particulière de la classe. Le membre est accessible directement à l’aide du nom de classe, de la même façon que les membres du module sont accessibles.

Les classes et les modules utilisent également des portées différentes pour leurs membres. Les membres définis dans une classe sont délimités dans une instance spécifique de la classe et existent uniquement pour la durée de vie de l’objet. Pour accéder aux membres de classe en dehors d’une classe, vous devez utiliser des noms qualifiés complets au format Object. Membre.

En revanche, les membres déclarés dans un module sont accessibles publiquement par défaut et sont accessibles par tout code pouvant accéder au module. Cela signifie que les variables d’un module standard sont effectivement des variables globales, car elles sont visibles n’importe où dans votre projet et existent pour la durée de vie du programme.

Réutilisation des classes et des objets

Les objets vous permettent de déclarer des variables et des procédures une fois, puis de les réutiliser chaque fois que nécessaire. Par exemple, si vous souhaitez ajouter un vérificateur d’orthographe à une application, vous pouvez définir toutes les variables et fonctions de prise en charge pour fournir des fonctionnalités de vérification orthographique. Si vous créez votre vérificateur d’orthographe en tant que classe, vous pouvez la réutiliser dans d’autres applications en ajoutant une référence à l’assembly compilé. Mieux encore, vous pourrez peut-être vous sauver un peu de travail à l’aide d’une classe de vérificateur d’orthographe que quelqu’un d’autre a déjà développé.

.NET fournit de nombreux exemples de composants disponibles pour une utilisation. L’exemple suivant utilise la classe TimeZone dans l'espace de nommage System. TimeZone fournit des membres qui vous permettent de récupérer des informations sur le fuseau horaire de l’ordinateur actuel.

Public Sub ExamineTimeZone()
    Dim tz As System.TimeZone = System.TimeZone.CurrentTimeZone
    Dim s As String = "Current time zone is "
    s &= CStr(tz.GetUtcOffset(Now).Hours) & " hours and "
    s &= CStr(tz.GetUtcOffset(Now).Minutes) & " minutes "
    s &= "different from UTC (coordinated universal time)"
    s &= vbCrLf & "and is currently "
    If tz.IsDaylightSavingTime(Now) = False Then s &= "not "
    s &= "on ""summer time""."
    Console.WriteLine(s)
End Sub

Dans l’exemple précédent, la première instruction Dim déclare une variable d’objet de type TimeZone et lui affecte un TimeZone objet retourné par la CurrentTimeZone propriété.

Relations entre les objets

Les objets peuvent être liés les uns aux autres de plusieurs façons. Les principaux types de relation sont hiérarchiques et de confinement.

Relation hiérarchique

Lorsque les classes sont dérivées de classes plus fondamentales, elles sont dites avoir une relation hiérarchique. Les hiérarchies de classes sont utiles lors de la description des éléments qui sont un sous-type d’une classe plus générale.

Dans l’exemple suivant, supposons que vous souhaitez définir un type spécial de Button qui agit comme un Button normal, mais expose également une méthode qui inverse les couleurs de premier plan et d’arrière-plan.

Définir une classe dérivée d’une classe déjà existante

  1. Utilisez une instruction de classe pour définir une classe à partir de laquelle créer l’objet dont vous avez besoin.

    Public Class ReversibleButton

    Assurez-vous qu’une End Class instruction suit la dernière ligne de code de votre classe. Par défaut, l’environnement de développement intégré (IDE) génère automatiquement une End Class instruction lorsque vous entrez une Class instruction.

  2. Faites suivre immédiatement l’instruction Class d’une instruction Inherits. Spécifiez la classe à partir de laquelle votre nouvelle classe dérive.

    Inherits System.Windows.Forms.Button

    Votre nouvelle classe hérite de tous les membres définis par la classe de base.

  3. Ajoutez le code pour les membres supplémentaires que votre classe dérivée expose. Par exemple, vous pouvez ajouter une ReverseColors méthode et votre classe dérivée peut se présenter comme suit :

    Public Class ReversibleButton
    Inherits System.Windows.Forms.Button
        Public Sub ReverseColors()
            Dim saveColor As System.Drawing.Color = Me.BackColor
            Me.BackColor = Me.ForeColor
            Me.ForeColor = saveColor
       End Sub
End Class

    Si vous créez un objet à partir de la ReversibleButton classe, il peut accéder à tous les membres de la Button classe, ainsi que la ReverseColors méthode et les autres nouveaux membres que vous définissez dans ReversibleButton.

Les classes dérivées héritent des membres de la classe sur laquelle elles sont basées, ce qui vous permet d’ajouter de la complexité à mesure que vous progressez dans une hiérarchie de classes. Pour plus d’informations, consultez Notions de base de l’héritage.

Compiler le code

Vérifiez que le compilateur peut accéder à la classe à partir de laquelle vous envisagez de dériver votre nouvelle classe. Cela peut signifier la qualification complète de son nom, comme dans l’exemple précédent, ou l’identification de son espace de noms dans une Imports Statement (.NET Namespace and Type). Si la classe se trouve dans un autre projet, vous devrez peut-être ajouter une référence à ce projet. Pour plus d’informations, consultez Gestion des références dans un projet.

Relation d'imbrication

Une autre façon dont les objets peuvent être liés est une relation de confinement. Les objets conteneur encapsulent logiquement d’autres objets. Par exemple, l’objet OperatingSystem contient logiquement un Version objet, qu’il retourne par le biais de sa Version propriété. Notez que l’objet conteneur ne contient physiquement aucun autre objet.

Collections

Un type particulier d’isolement d’objet est représenté par des collections. Les collections sont des groupes d’objets similaires qui peuvent être énumérés. Visual Basic prend en charge une syntaxe spécifique dans l'instruction For Each...Next qui vous permet d’itérer les éléments d’une collection. De plus, les collections vous permettent souvent d’utiliser un Item[] pour récupérer des éléments par leur index ou en les associant à une chaîne de caractères unique. Les collections peuvent être plus faciles à utiliser que les tableaux, car elles vous permettent d’ajouter ou de supprimer des éléments sans utiliser d’index. En raison de leur facilité d’utilisation, les collections sont souvent utilisées pour stocker des formulaires et des contrôles.

Procédure pas à pas : définition de classes
Fournit une description pas à pas de la création d’une classe.

Propriétés et méthodes surchargées
Propriétés et méthodes surchargées

Principes de base de l’héritage
Couvre les modificateurs d’héritage, les méthodes et propriétés substituées, MyClass et MyBase.

Durée de vie des objets : création et destruction d’objets
Décrit la création et la suppression d’instances de classe.

Types anonymes
Décrit comment créer et utiliser des types anonymes, qui vous permettent de créer des objets sans écrire de définition de classe pour le type de données.

Initialiseurs d’objets : types nommés et anonymes
Décrit les initialiseurs d’objets, qui sont utilisés pour créer des instances de types nommés et anonymes à l’aide d’une seule expression.

Guide pratique pour déduire les noms et les types de propriétés dans les déclarations de types anonymes
Explique comment déduire les noms et les types de propriétés dans les déclarations de type anonyme. Fournit des exemples d’inférence réussie et infructueuse.