Objets et classes dans Visual Basic

Un objet est une combinaison de code et de données qui peuvent être traités en tant qu’unité. Un objet peut être une partie d’une application, comme une commande ou un formulaire. Une application entière peut également être un objet.

Lorsque vous créez une application dans 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 ceux-ci. Les objets se comportent comme des blocs de construction préfabriqués : ils vous permettent d’écrire un fragment de code une seule fois et de le réutiliser maintes fois.

Cette rubrique présente les objets en détail.

Objets et classes

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

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

Vous devez créer un objet avant de pouvoir accéder à ses membres, à l’exception des Shared membres qui peuvent être 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éfinir 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 assigner 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 par le biais de la variable d’objet.

   nextCustomer.AccountNumber = lastAccountNumber + 1
   

Instances multiples

Les objets nouvellement créés à partir d’une classe sont souvent identiques. Dès qu’ils existent en tant qu’objets individuels, toutefois, leurs variables et propriétés sont modifiables 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 classe CheckBox. Les objets CheckBox individuels 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 possède son propre nom, peut être séparément activé 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, représentant 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 propriété Text d’un objet Label.

warningLabel.Text = "Data not saved"

Liste de membres IntelliSense

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 comme une instance de cette classe, IntelliSense répertorie tous les membres de l’instance et aucun des membres partagés. 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 propriétés et les champs sont des informations stockées dans un objet. Vous récupérez et définissez leurs valeurs avec des instructions d’assignation 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 propriété Width et définit la propriété ForeColor d’un objet Label.

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

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

Utilisez les 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é possède 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, comme une propriété IsVisible.

• La définition de la propriété entraîne des modifications d’autres variables internes ou des 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 les champs quand :

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

• N’importe quelle valeur dans la plage prise en charge par le type de données est valide. Cela est vrai pour de nombreuses propriétés du type Single ou Double.

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

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

Méthodes

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

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

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

Notez qu’une méthode est simplement une procédure qui est 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 le fait de cliquer sur la souris ou d’appuyer sur une touche, et pour laquelle vous pouvez écrire du code en réponse. Les événements peuvent se produire à la suite d’une action de l’utilisateur ou du code de programme, ou ils peuvent être provoqués par le système. On dit que le code qui signale un événement le déclenche et le code qui y répond le gère.

Vous pouvez également développer vos propres événements personnalisés pour qu’ils soient 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é Shared sont des membres d’instance, qui appartiennent strictement à cette instance spécifique. Un membre d’instance dans une instance est indépendant du même membre dans une autre instance de la même classe. Par exemple, une variable de membre d’instance peut avoir des valeurs différentes dans différentes instances.

Les membres déclarés avec le mot clé Shared 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 de membre partagé, par exemple, n’a qu’une seule valeur, qui est disponible à tout le code qui peut accéder à la classe.

Accès aux membres non partagés

1. Assurez-vous que l’objet a été créé à partir de sa classe et assigné à une variable 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 classe avec l’opérateur d’accès membre (.), puis le nom du membre. Vous devez toujours accéder à un membre Shared 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 membre Shared à l’aide de 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 mais pas les modules standard. Étant donné qu’il n’existe qu’une seule copie des données d’un module standard, quand une partie de votre programme transforme une variable publique dans un module standard, toute autre partie du programme reçoit 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é alors que les modules ne peuvent pas être hérités.

Les classes et les modules utilisent également des portées différentes pour leurs membres. Les membres définis dans une classe ont comme portée une instance spécifique de la classe et existent uniquement pendant la durée de vie de l’objet. Pour accéder aux membres de la classe en dehors d’une classe, vous devez utiliser des noms de domaine complets sous la forme Objet.Membre.

En revanche, les membres déclarés dans un module sont publiquement accessibles par défaut et sont accessibles par tout code qui peut accéder au module. Cela signifie que les variables dans un module standard sont effectivement des variables globales puisqu’elles sont visibles n’importe où dans votre projet, et qu’elles existent pendant 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 seule fois, puis de les réutiliser à chaque fois que cela est 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 support pour fournir la fonctionnalité de vérification orthographique. Si vous créez votre vérificateur d’orthographe en tant que classe, vous pouvez ensuite le réutiliser dans d’autres applications en ajoutant une référence à l’assembly compilé. Mieux encore, vous pouvez vous épargner du 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 noms 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 objet de type TimeZone et lui attribue un objet TimeZone retourné par la propriété CurrentTimeZone.

Relations entre les objets

Les objets peuvent être liés entre eux de plusieurs façons. Les principales sortes de relations sont hiérarchique et imbrication.

Relation hiérarchique

Lorsque les classes sont dérivées de classes plus fondamentales, elles ont une relation hiérarchique. Les hiérarchies de classes sont utiles lors de la description des éléments qui représentent 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 l’instruction Class pour définir une classe à partir de laquelle créer l’objet dont vous avez besoin.

   Public Class ReversibleButton
   

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

2. Faites suivre immédiatement l’instruction Class d’une instruction Inherits. Spécifiez la classe dont dérive la nouvelle classe.

   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 exposés par votre classe dérivée. Par exemple, vous pouvez ajouter une méthode ReverseColors 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 classe, il peut accéder à tous les membres de la ReversibleButtonButton classe, ainsi que la ReverseColors méthode et les autres membres que vous définissez dans ReversibleButton.

Les classes dérivées héritent des membres de la classe que dont ils dépendent, ce qui vous permet d’ajouter de la complexité au fur et à mesure que vous progressez dans la hiérarchie. Pour plus d’informations, consultez Concepts de base de l’héritage.

Compiler le code

Assurez-vous que le compilateur peut accéder à la classe à partir de laquelle vous souhaitez dériver votre nouvelle classe. Cela peut signifier qualifier complètement son nom, comme dans l’exemple précédent ou identifier son espace de noms dans une instruction Imports (espace de noms et type .NET). 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

Les objets peuvent également être liés par une relation d’imbrication. Les objets conteneur encapsulent de manière logique d’autres objets. Par exemple, l’objet OperatingSystem contient de manière logique un objet Version, qu’il retourne via sa propriété Version. Notez que l’objet conteneur ne contient physiquement aucun autre objet.

Regroupements

Un type particulier de relation d’imbrication d’objet est représenté par les 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 For Each... Instruction suivante qui vous permet d’itérer les éléments d’une collection. En outre, les collections vous permettent souvent d’utiliser un Item[] pour récupérer des éléments à l’aide de leur index ou en les associant à une chaîne 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 simplicité d’utilisation, les collections sont souvent utilisées pour stocker les formulaires et les commandes.

Rubriques connexes

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

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

Éléments fondamentaux de l’héritage
Présente les modificateurs d’héritage, la substitution des propriétés et des méthodes, MyClass et MyBase.

Durée de vie d’un objet : création et destruction des objets
Explique comment créer et supprimer des instances de classe.

Types anonymes
Décrit comment créer et utiliser les 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 servent à créer des instances de types nommés et anonymes à l’aide d’une expression unique.

Comment : déduire les types et les noms de propriétés dans des déclarations de types anonymes
Explique comment déduire les types et les noms de propriétés dans des déclarations de types anonymes. Fournit des exemples d’inférence possible et impossible.