Programmation orientée objet pour les utilisateurs de Visual Basic 6.0

Article
08/21/2008

Mise à jour : novembre 2007

Visual Basic 6.0 prend en charge des éléments de langage orientés objet, ainsi que des objets distribués dans les bibliothèques. Visual Basic 2008 étend la prise en charge de la programmation orientée objet en prenant en charge toutes ses propriétés de langage.

Différences conceptuelles

Les sections suivantes répertorient les fonctionnalités orientées objet dans Visual Basic 2008, en les comparant avec l'implémentation Visual Basic 6.0 le cas échéant. Pour chaque fonctionnalité, des liens sont fournis vers des pages d'aide complètes qui vous permettront d'en apprendre plus sur le sujet.

Niveaux d'accès

Dans Visual Basic 6.0, les mots clés Private, Friend, Public et Static sont utilisés pour définir des niveaux d'accès pour les éléments déclarés.

Dans Visual Basic 2008, les mots clés Private, Friend, Publicet Static, ainsi que les nouveaux mots clés Protected et Protected Friend, sont utilisés pour définir les niveaux d'accès aux éléments déclarés. Le niveau d'accès d'un élément déclaré est l'étendue de la capacité à l'utiliser, à savoir le code qui est autorisé à lire l'élément ou à y écrire.

Pour plus d'informations, consultez Niveaux d'accès dans Visual Basic et Portée dans Visual Basic.

Attributs

Dans Visual Basic 6.0, une prise en charge limitée des attributs incorporés est fournie par des outils tels que les attributs de procédure dans l'IDE Visual Basic.

Dans Visual Basic 2008, un Attribute est une balise descriptive qui peut être utilisée pour annoter des instructions de type et de membre de type, en modifiant ainsi leur signification ou en personnalisant leur comportement. Par exemple, des instructions de classe et des instructions de méthode de classe peuvent être annotées avec des attributs.

Votre application et d'autres applications, telles que le compilateur Visual Basic, peuvent utiliser la réflexion pour accéder à des attributs afin de déterminer comment des types et des membres de type peuvent être utilisés.

Les attributs peuvent être utilisés pour effectuer la programmation AOP (Aspect Oriented Programming) avec Visual Basic. Un aspect est une partie d'un programme qui traverse sa logique métier. En d'autres termes, il est nécessaire pour exécuter le programme, mais n'est pas nécessairement spécifique au domaine pour lequel le programme est écrit. Isoler des aspects tels que l'enregistrement et la persistance de la logique métier est l'objectif du paradigme de programmation orienté aspect.

Pour plus d'informations, consultez Vue d'ensemble des attributs dans Visual Basic, Attributs utilisés dans Visual Basic et Utilisations courantes des attributs.

Compatibilité binaire

Dans Visual Basic 6.0, l'option Binary Compatibility vous permet de conserver automatiquement les identificateurs de classe et d'interface à partir d'une version antérieure d'un composant lors de la compilation d'une nouvelle version.

Dans Visual Basic 2008, l'option Binary Compatibility n'est pas prise en charge. Au lieu de cela, la compatibilité binaire est effectuée avec des attributs. Ceci vous donne un contrôle direct sur les informations situées dans votre composant compilé, telles que les identificateurs de classe et d'interface, les offsets de table virtuelle et les attributs COM appropriés.

Pour plus d'informations, consultez Modifications de la compatibilité binaire pour les utilisateurs de Visual Basic 6.0.

Modules de classe

Dans Visual Basic 6.0, une classe est définie dans un module de classe. Un seul module de classe est stocké dans un type spécial de fichier qui possède une extension de fichier .cls.

Dans Visual Basic 2008, une classe est définie dans une instruction Class qui spécifie le nom et les membres d'une classe. Les instructions Class sont stockées dans des fichiers sources. Le fichier source entier peut être affiché comme du texte brut.

Plusieurs instructions Class ainsi que d'autres instructions de type peuvent être stockées dans un seul fichier source. Visual Basic ne nécessite pas que le nom du fichier source corresponde à une Class ou un type défini dans le fichier source.

Pour plus d'informations, consultez Class, instruction (Visual Basic).

Méthodes de constructeur de classe

Dans Visual Basic 6.0, le gestionnaire d'événements Initialize de la classe, nommé Class_Initialize, est utilisé pour exécuter le code qui doit être exécuté au moment où un objet est créé.

Dans Visual Basic 2008, un ou plusieurs constructeurs sont ajoutés dans une classe pour exécuter le code et initialiser des variables. Les constructeurs sont les méthodes dans une classe qui sont nommées New. La méthode New peut être surchargée pour fournir à plusieurs constructeurs le nom New dans la même instruction de classe.

Pour plus d'informations, consultez New (Visual Basic) ou Utilisation de constructeurs et de destructeurs.

Méthodes de destructeur de classe

Dans Visual Basic 6.0, le mot clé Nothing est utilisé pour dissocier une variable d'objet d'un objet réel. L'instruction Set est utilisée pour assigner Nothing à une variable d'objet.

Dans Visual Basic 2008, pour la majorité des objets créés par votre application, vous pouvez laisser au « garbage collector » le soin de réaliser automatiquement les tâches de gestion de mémoire requises. Cependant, les ressources non managées requièrent un nettoyage explicite. Le type le plus répandu de ressource non managée est un objet qui encapsule une ressource de système d'exploitation telle qu'un handle de fichier ou de fenêtre ou une connexion réseau.

Lors de la création d'un objet qui encapsule une ressource non managée, il est recommandé de fournir le code nécessaire pour nettoyer la ressource non managée dans une méthode Dispose publique. En fournissant une méthode Dispose, vous donnez la possibilité aux utilisateurs de votre objet d'en libérer explicitement la mémoire lorsqu'ils ont fini de s'en servir.

Lorsque vous utilisez un objet qui encapsule une ressource non managée, vous devez garder à l'esprit la méthode Dispose et l'appeler si nécessaire.

Pour plus d'informations, consultez Nettoyage de ressources non managées ou Gestion automatique de la mémoire.

Class_Initialize

Dans Visual Basic 6.0, un événement Initialize de classe peut être traité par une méthode Class_Initialize pour exécuter le code devant être exécuté au moment où un objet est créé. Par exemple, les valeurs des variables de données de classe peuvent être initialisées.

Dans Visual Basic 2008, l'événement Initialize et le gestionnaire Class_Initialize ne sont pas pris en charge. Pour fournir l'initialisation de classe, ajoutez une ou plusieurs méthodes de constructeur aux classes et aux structures que vous définissez.

Pour plus d'informations, consultez Modifications de Class_Initialize pour les utilisateurs de Visual Basic 6.0.

Données, classes

Dans Visual Basic 6.0, des classes source de données et consommateur de données complexes sont utilisées pour fonctionner avec des données externes telles que des bases de données Microsoft SQL Server. Une classe source de données fournit des données provenant d'une source externe. Une classe consommateur de données peut être liée à une source de données externe comme une classe Data Source.

Dans Visual Basic 2008, des classes source de données, consommateur de données simples, consommateur de données complexes et de liaison sont utilisées pour les données externes et internes.

Pour plus d'informations, consultez Liaison de données et Windows Forms.

Default, propriété

Dans Visual Basic 6.0, toute propriété de classe peut être définie comme propriété par défaut de la classe.

Dans Visual Basic 2008, le membre par défaut d'une classe ou d'une structure peut uniquement être une propriété qui utilise un ou plusieurs arguments. Les membres de propriété par défaut sont définis en incluant le mot clé Default dans une instruction de déclaration de propriété dans une classe ou une structure.

Pour plus d'informations, consultez Modifications des propriétés par défaut pour les utilisateurs de Visual Basic 6.0.

Délégués

Dans Visual Basic 6.0, les types délégués ne sont pas pris en charge.

Dans Visual Basic 2008, un type délégué est une forme de pointeur méthode orienté objet permettant à une méthode d'être appelée indirectement par l'intermédiaire d'une référence à la méthode. Les délégués peuvent être utilisés pour raccorder des gestionnaires d'événements et passer une méthode d'une méthode à une autre.

Les délégués peuvent être utilisés pour implémenter le modèle de design asynchrone. Par exemple, avec un délégué asynchrone, un programme peut appeler une méthode, qui énumère une longue liste, tandis que le programme principal poursuit son exécution. Lorsque l'énumération est terminée, un rappel est effectué et le programme lui répond.

Pour plus d'informations, consultez Délégués en Visual Basic ou Comment : passer des procédures à une autre procédure en Visual Basic.

Gestion des erreurs

Dans Visual Basic 6.0, l'instruction On Error est utilisée pour la gestion non structurée des exceptions.

In Visual Basic 2008, both unstructured and structured exception handling are supported. La gestion structurée des exceptions désigne la création d'un mécanisme de gestion des exceptions à l'aide d'une structure de contrôle contenant des exceptions, des blocs de code isolés et des filtres.

Pour plus d'informations, consultez Gestion structurée des exceptions en Visual Basic ou Cas d'utilisation de la gestion structurée ou non structurée des exceptions.

Événements

Dans Visual Basic 6.0, les mots clés Event, RaiseEvent et WithEvents sont utilisés pour déclarer, déclencher et gérer des événements.

In Visual Basic 2008, the Event, RaiseEvent, and WithEvents keywords plus the new AddHandler, RemoveHandler, and Handles keywords are used to declare, raise, and handle events.

Les mots clés AddHandler et RemoveHandler vous permettent d'ajouter, de supprimer et de changer dynamiquement le gestionnaire d'événements associé à un événement.

Le mot clé Handles vous permet de définir une clause Handles sur une méthode. Handles déclare qu'une procédure gère un événement spécifié.

Dans le .NET Framework, les événements reposent sur le modèle délégué. Le modèle délégué est basé sur le modèle de design observateur orienté objet.

Pour plus d'informations, consultez Comment : écrire des gestionnaires d'événements.

Génériques

Dans Visual Basic 6.0, les types génériques ne sont pas pris en charge.

In Visual Basic 2008, generics are used to implement parametric polymorphism in a Visual Basic program. Le code générique est écrit sans mention de quelque type spécifique que ce soit et peut donc être utilisé de façon transparente avec n'importe quel nombre de nouveaux types.

Visual Basic 2008 supports type parameters on generic classes, structures, interfaces, procedures, and delegates. Un argument de type correspondant spécifie, au moment de compilation, le type de données de l'un des éléments dans le type générique.

Pour plus d'informations, consultez Types génériques en Visual Basic.

Classes globales

Dans Visual Basic 6.0, la valeur de la propriété Instancing d'une classe détermine si une classe est privée - c'est-à-dire réservée à une utilisation dans un seul composant - ou disponible pour d'autres applications. Il détermine également comment d'autres applications créent des instances de la classe et comment d'autres applications appellent les membres de classe.

In Visual Basic 2008, the Instancing property is no longer supported.

Vous pouvez appliquer le mot clé Public aux instructions de classe dans un assembly pour exposer les classes de cet assembly à d'autres assemblys.

Vous pouvez référencer un assembly externe tel qu'une bibliothèque de classes pour permettre au code dans votre application d'utiliser les classes Public de cette bibliothèque de classes.

Vous pouvez utiliser le mot clé Imports pour importer des noms d'espaces de noms provenant de projets et d'assemblys référencés. Le mot clé Imports peut également importer des noms d'espaces de noms définis dans le même projet que le fichier dans lequel figure l'instruction.

Vous pouvez appliquer le mot clé Shared aux membres de champ, de propriété et de méthode des classes et structures pour implémenter des membres partagés. Les membres partagés sont des propriétés, des procédures et des champs qui sont partagés par toutes les instances d'une classe ou structure. Les membres partagés d'une classe sont accessibles sans instanciation de la classe.

Pour plus d'informations, consultez Niveaux d'accès dans Visual Basic, Références et l'instruction Imports ou Membres partagés en Visual Basic.

Héritage d'implémentation

Dans Visual Basic 6.0, l'héritage d'implémentation n'est pas pris en charge.

In Visual Basic 2008, you can implement ad-hoc polymorphism through implementation inheritance. Cela vous permet de définir des classes pouvant être utilisées de manière interchangeable par code client au moment de l'exécution, mais avec des méthodes ou des propriétés fonctionnellement différentes (même si elles portent le même nom).

Vous pouvez définir des classes qui servent de base aux classes dérivées. Les classes dérivées héritent des propriétés, des méthodes et des événements de la classe de base et peuvent les étendre. Elles peuvent également substituer des méthodes héritées par de nouvelles implémentations.

Pour plus d'informations, consultez Éléments fondamentaux de l'héritage ou Quand utiliser l'héritage.

Héritage de l'interface

Visual Basic 6.0 assure le polymorphisme via plusieurs interfaces ActiveX. Dans le modèle COM (Component Object Model) qui forme l'infrastructure de la spécification ActiveX, plusieurs interfaces permettent aux systèmes de composants logiciels d'évoluer sans rupture du code existant.

In Visual Basic 2008, you can implement ad-hoc polymorphism with the .NET Framework's Interface keyword.

Plusieurs classes peuvent implémenter la même Interface, et une seule classe peut implémenter une ou plusieurs interfaces. Pour les décrire simplement, les interfaces sont des définitions de la façon dont une classe doit répondre. Une interface définit les méthodes, les propriétés et les événements qu'une classe doit implémenter ainsi que le type de paramètres que chaque membre doit recevoir et retourner, mais elle laisse l'implémentation spécifique de ces membres à la charge de la classe d'implémentation.

Les interfaces multiples permettent l'évolution des systèmes de composants logiciels sans endommager le code existant.

Pour plus d'informations, consultez Polymorphisme d'interface ou Comment : créer et implémenter des interfaces.

Méthodes : paramètres ByVal et ByRef

Dans Visual Basic 6.0, les arguments sont passés à une méthode par valeur ou par référence. Sauf spécification explicite des paramètres de méthode par le mot clé ByVal ou ByRef, les arguments sont implicitement passés par référence (ByRef).

In Visual Basic 2008, arguments are passed to a method by value or by reference. Sauf spécification explicite des paramètres de méthode par le mot clé ByVal ou ByRef, les arguments sont implicitement passés par valeur (ByVal).

Pour plus d'informations, consultez Passage d'arguments par valeur et par référence.

Méthodes : Surcharge

Dans Visual Basic 6.0, la surcharge de méthode n'est pas prise en charge.

In Visual Basic 2008, Method overloading is used to implement ad-hoc polymorphism in a Visual Basic program. Une méthode est surchargée lorsque plusieurs versions de la méthode sont définies dans une classe. Les versions surchargées diffèrent au niveau de leurs paramètres et types de retours.

Pour plus d'informations, consultez Propriétés et méthodes surchargées et Polymorphisme dans Visual Basic.

Méthodes : Substitution

Dans Visual Basic 6.0, les méthodes ne peuvent pas être substituées.

In Visual Basic 2008, you can use the Overrides keyword to override a method in a derived class to provide a different implementation of a method from the derived class's base class.

Pour plus d'informations, consultez Substitution de propriétés et de méthodes.

Méthodes : Retour de résultats

Dans Visual Basic 6.0, un nom de méthode Function est utilisé comme nom d'une variable pour retourner le résultat de la méthode Function.

In Visual Basic 2008, you use the Return keyword to return a Function method's result.

Utilisez le Return pour retourner le contrôle au code qui a appelé une méthode Sub, Function ou Property.

Pour plus d'informations, consultez Return, instruction (Visual Basic).

My

In Visual Basic 2008, the new My feature enables rapid object-oriented programming with Visual Basic by providing entry points to frequently used .NET Framework classes and functions. My provides new high-level .NET Framework classes that pull together related functionality into task-based APIs.

Pour plus d'informations, consultez Développement avec My.

Mots clés MyBase, MyClass et Me

Dans Visual Basic 6.0, le mot clé Me se comporte comme une variable déclarée implicitement. Lorsqu'une classe possède plusieurs instances, Me offre un moyen de faire référence à l'instance spécifique de la classe où le code s'exécute.

In Visual Basic 2008, the MyBase keyword provides a way to refer to the base class of the current class instance.

Le mot clé MyClass offre un moyen de faire référence à l'instance de classe actuelle sans substitutions.

Le mot clé Me permet de faire référence à l'instance spécifique d'une classe ou d'une structure dans laquelle le code est en train de s'exécuter.

Pour plus d'informations, consultez Me, My, MyBase et MyClass dans Visual Basic.

Mot clé New

Dans Visual Basic 6.0, l'utilisation inappropriée du mot clé New peut provoquer des comportements de réinitialisation inhabituels susceptibles d'induire des erreurs et une utilisation excessive de la mémoire.

In Visual Basic 2008, the New keyword simply allocates space for the object; it does not cause any unusual re- initializing behavior.

Utilisez une clause New dans une instruction de déclaration ou une instruction d'assignation. Lorsque l'instruction est exécutée, elle appelle une méthode de constructeur de la classe spécifiée, en passant tous les arguments fournis dans la clause New. Cela signifie que vous pouvez appliquer des contraintes de données à partir du moment où l'objet est instancié.

Une classe possède un ou plusieurs constructeurs. Les constructeurs sont les méthodes dans une méthode nommée New. Plusieurs constructeurs sont définis par surcharge de la méthode New dans la classe. Les méthodes de constructeur surchargées sont décrites comme des constructeurs paramétrés.

Pour plus d'informations, consultez New (Visual Basic).

Durée de vie de l'objet

Dans Visual Basic 6.0, la durée de vie des objets est déterministe ; chaque instance d'objet gère un décompte de références. Lorsque la dernière référence à une instance est diffusée et que le compte atteint la valeur zéro, l'objet est immédiatement terminé.

In Visual Basic 2008, object lifetime is non-deterministic; a destructor is not necessarily called as soon as the last reference is released. En effet, le Common Language Runtime gère une arborescence des références au lieu de décomptes de références individuelles.

Le garbage collector trace cette arborescence des références à l'arrière-plan. S'il trouve un objet ou un groupe d'objets qui n'ont aucune référence d'aucun code en cours d'exécution, le garbage collector appelle les destructeurs de tous ces types d'objets.

Il est impossible de prévoir ni l'ordre des destructions, ni le temps qu'il faut au garbage collector pour tracer l'arborescence des références.

Pour plus d'informations, consultez Durée de vie dans Visual Basic ou Durée de vie d'un objet : création et destruction des objets.

Surcharge d'opérateur

Dans Visual Basic 6.0, la surcharge d'opérateur n'est pas prise en charge.

In Visual Basic 2008, operator overloading allows the behavior of a standard operator (such as *, <>, or And) to be defined for a user-defined class or structure.

Pour plus d'informations, consultez Comment : définir un opérateur de conversion.

Option Strict

Dans Visual Basic 6.0, la vérification de type permissive est utilisée au moment de l'exécution.

In Visual Basic 2008, you can use the OPTION STRICT ON statement to enable strict type checking at design time rather than permissive type checking at run time. Par défaut, OPTION STRICT OFF est utilisé.

When converting between data types, the Visual Basic compiler can operate under strict or permissive type semantics. Si la sémantique de type stricte est active (OPTION STRICT ON), seules les conversions étendues sont implicitement autorisées et les conversions restrictives doivent être explicites. Si la sémantique de type permissive (OPTION STRICT OFF) est active, vous pouvez tenter d'effectuer toutes les conversions étendues et restrictives de manière implicite. Ces sémantiques s'appliquent aux conversions entre tous les types de données, y compris les types d'objets.

Pour plus d'informations, consultez Vérification du type dans Visual Basic.

Syntaxe des propriétés

Dans Visual Basic 6.0, utilisez les instructions Property Get, Property Let et Property Set pour obtenir et définir des valeurs de propriété.

In Visual Basic 2008, a unified property declaration syntax is used that includes the procedures for getting and setting the property's value. Cette syntaxe garantit la cohérence d'attributs de propriété tels que le niveau d'accès et la surcharge.

Pour plus d'informations, consultez Modifications des propriétés pour les utilisateurs de Visual Basic 6.0.

Interfaces publiques

Dans Visual Basic 6.0, l'interface publique d'une classe est constituée de l'ensemble de ses membres publics.

In Visual Basic 2008, a class's public interface is the set of its public members, but an abstract class may be used to implement sub-typing polymorphism in a Visual Basic program.

Une classe abstraite est semblable au Interface du .NET Framework. Une classe abstraite est une classe conçue uniquement pour servir de classe de base à des classes dérivées. Les classes abstraites sont souvent utilisées pour représenter des concepts ou des entités abstraites.

Une classe abstraite ne peut pas être instanciée elle-même ; elle doit être héritée. Certains, voire tous les membres de la classe peuvent ne pas être implémentés, et c'est à la classe qui hérite de fournir cette implémentation. Les membres implémentés peuvent toujours être substitués, et la classe qui hérite peut toujours implémenter des interfaces supplémentaires ou d'autres fonctionnalités.

Pour plus d'informations, consultez MustInherit.

Propriétés en lecture seule

Dans Visual Basic 6.0, l'exclusion de la méthode Set dans une procédure Property crée une propriété en lecture seule.

In Visual Basic 2008, you must both apply the ReadOnly keyword to a property and exclude the property Set clause to make a property read-only.

Vous pouvez également appliquer le mot clé ReadOnly à un champ pour en faire un champ en lecture seule.

Pour plus d'informations, consultez ReadOnly (Visual Basic).

Réflexion

Dans Visual Basic 6.0, la réflexion n'est pas prise en charge.

In Visual Basic 2008, the classes in the .NET Framework class library System.Reflection namespace can be used to obtain information about types such as classes, interfaces, and value types at run time and to create type instances to invoke and access them.

Pour plus d'informations, consultez Espaces de noms de réflexion dans Visual Studio.

Membres de classe et de structure partagées

In Visual Basic 2008, the new Shared keyword can be applied to Property, Sub, Dim, Function, Operator, and Event statements to share them with all instances of a class or structure. Les membres partagés d'une classe sont accessibles sans instanciation de la classe.

Vous pouvez accéder aux membres partagés par le nom d'une classe plutôt que via une instance de la classe.

Pour plus d'informations, consultez Membres partagés en Visual Basic.

Fichiers sources

In Visual Basic 2008, programs consist of one or more source files. Les fichiers sources sont stockés dans un type de fichier spécial qui possède une extension de fichier .vb. Type statements for types such as classes, structures, interfaces, enumerations, and delegates, as well as statements for standard modules, are stored in program source-code files. Visual Basic does not limit a source file to defining only one type nor does it require the name of the source file to match a type defined in the source file.

Les instructions de type partiel autorisent une classe, ou une structure, à être définie à travers plusieurs fichiers sources. Lorsqu'un programme à plusieurs fichiers sources est compilé, tous les fichiers sources sont traités ensemble, comme si tous les fichiers sources étaient concaténés dans un même fichier avant d'être traités.

Pour plus d'informations, consultez Structure d'un programme Visual Basic ou Partial (Visual Basic).

Types définis par l'utilisateur

Dans Visual Basic 6.0, l'instruction Type est utilisée pour combiner des variables de plusieurs types différents en un seul type défini par l'utilisateur, ou UDT.

In Visual Basic 2008, the Structure and Enum statements are used to define user defined value types.

Utilisez les instructions Class, Interface et Delegate pour définir des types référence définis par l'utilisateur.

Pour plus d'informations, consultez Structures constituées à partir de vos propres types de données.

Déclaration des variables

Dans Visual Basic 6.0, vous pouvez déclarer des variables de types différents dans la même instruction. Si vous ne spécifiez pas le type de données d'une variable dans l'instruction, son type sera Variant par défaut.

In Visual Basic 2008, you can declare multiple variables of the same data type without having to specify the data type of each variable in the statement.

Pour plus d'informations, consultez Déclaration de variable en Visual Basic.

Mettre à niveau des remarques

When a Visual Basic 6.0 application is upgraded to Visual Basic 2008, object-oriented code constructs are converted to their nearest Visual Basic 2008 equivalent in the most expedient manner. The resulting code should not be taken as an example of how to do object-oriented programming in Visual Basic 2008.

If you intend to extend an upgraded application to use Visual Basic 2008 object-oriented constructs, you may first want to modify the upgraded code. Les pages suivantes devraient vous aider à entamer ce travail.

Classes pour les utilisateurs de Visual Basic 6.0
Les classes sont les blocs de construction d'une application orientée objet.
Comment : convertir une collection personnalisée en collection typée Visual Basic
Visual Basic 2008 provides several options for creating typed classes from Visual Basic 6.0 custom collections.
Comment : convertir un type défini par l'utilisateur en structure Visual Basic
The Type statement of Visual Basic 6.0 is upgraded to the Structure statement of Visual Basic 2008.
Comment : convertir du code Implements en nouvelle forme d'héritage
Newer versions of Visual Basic offer two types of inheritance, using the Implements statement and the Inherits statement.

Voir aussi

Share via