1.1 L'application VB

Une application Visual Basic se compose d'un projet "xxx.vbp" et d'au minimum un fichier de feuille "xxx.frm". Lors de la compilation d'un projet VB engendre selon le choix, un code interprété (appelé pseudo-code ou p-code) ou un code dit natif "xxx.exe".

Ci-dessous un projet minimal comportant une seule feuille :

Tous les projets VB en p-code ou en code natif font appel à un environnement d'exécution virtuel de VB sous forme d'un module de service d'exécution de type DLL (dénommé MSVBVM60.DLL pour Visual Basic 6) qui sert à exécuter certaines parties de l'application et d'intermédiare de communication avec le système windows :

La première action à entreprendre lors du développement d'une application VB est la création de l'interface IHM de l'application. Il faut utiliser alors des feuilles (dénommées aussi fiche ou fenêtres) et des contrôles. Ce sont des objets au sens informatique de la POO mais qui possèdent une représentation visuelle.
 

1.2 Les feuilles et les contrôles

Chaque feuille est en fait un objet instancié à partir de la classe interne des Form de VB. Cette classe possède des propriétés(attributs) qui décrivent l'apparence de la feuille, des méthodes qui décrivent le comportement de la feuille et enfin des procédure d'événements qui permettent de programmer la réaction de la feuille aux événements auxquels elles est sensible.

Ci-dessous la feuille Form1 du projet Projet1 minimal :

Sur une feuille vous déposez des contrôles qui sont eux aussi d'autres classes d'objets visuels, mais qui sont contenus dans la feuille.

Ci-dessous la boîte à outils de VB contenant les contrôles :

Ci-dessous la feuille Form1 précédente après dépôt de 3 contrôles :

Il existe une notion de classe conteneur, la feuille en est le principal représentant, le code des différentes actions et réactions de la feuille et de ses contrôles est lui-même contenu dans la feuille.

Ci-dessous un exemple de code dans la feuille Form1 avec 3 contrôles :

2. Les modules dans Visual Basic ...

VB est un langage modulaire, nous avons indiqué plus haut qu'une application VB comportait au minimum une feuille contenant des contrôles et tout le code écrit par le programmeur au sujet de cette feuille. Il est possible de stocker du code ailleurs que dans une feuille, c'est l'entité dénommée module en VB qui remplit cet office.

Un module VB possède toutes fonctionnalités de base et classique d'encapsulation de l'information (publique et privée).
 

Vb dispose de 4 catégories de modules : Module standard Module de feuille Module de classe Module ActiveX

Chaque module peut contenir entre autres éléments :
 

• des déclarations de constantes, de types, de variables,
• des procédures ou des fonctions avec leur code.

2.1 Le Module standard

C'est un module qui ne contient que des déclarations, des procédures et des fonctions. Ce genre de module est celui qui se rapproche le plus de la notion de module réutilisable. Il contient du code qui n'est pas attaché spécifiquement à une apllication particulière.

On se servira de tels modules lorsque l'on regroupera le code traitant un problème particulier, pour implanter un type abstrait de données, ...

Extension de fichier pour ce genre de module : xxx.BAS

En VB on demande d'ajouter au projet un nouveau module standard:

Et l'on obtient une fenêtre de code Module1 :

qui est ajoutée par VB au projet Projet1 :

2.2 Le Module de feuille

Ce type de module contient une description en codage interne à VB, d'une feuille des déclarations, des procédures et fonctions ainsi que des réactions de la feuille à certains événements programmés par le développeur.

Un module de feuille sert à décrire une seule feuille, c'est le nom du module qui est le nom de la feuille.

Extension de fichier pour ce genre de module : xxx.FRM

En VB on demande d'ajouter au projet une nouvelle feuille :

On ajoute une feuille standard:

 

VB rajoute une feuille Form2 au projet1 :

2.3 Le Module de classe

C'est à ce niveau que VB nous permet de travailler avec les notions de base de la programmation orientée objet. Il est possible d'écrire du code de description de la classe représentée par le module de classe. Toutefois un tel module de classe ne peut pas contenir de contrôles (composants visuels), il est compilable séparément de l'application elle-même et peut être réutilisé.

Un module de classe sert à décrire une seule classe, c'est le nom du module qui est le nom de la classe.

Extension de fichier pour ce genre de module : xxx.CLS

En VB on demande d'ajouter au projet une nouvelle classe :

On ajoute un module de classe :

 

VB rajoute une classe Class1 au projet1 :

Il ne reste plus qu'à écrire dans la page de code associée les déclarations et implémentations de la classe.
 

Remarque

Les modules de feuille de VB sont en fait techniquement des modules de classe dans lesquels il est possible d'inclure des contrôles sur une fenêtre.

 

2.4 Le Module Contrôle ActiveX

Un contrôle ActiveX est un composant logiciel pouvant être intégré dans tout environnement de développement ou autre acceptant les contrôles ActiveX : Delphi et Visual Basic,les navigateurs Internet tels que MS Internet Explorer et Netscape Navigator sont des exemples de tels environnements. Un contrôle ActiveX suit la spécification ActiveX dans le but de fournir aux programmeurs des composants logiciels réutilisables au sein d'applications et de services.
 

La technologie ActiveX se différencie de la programmation orientée objets par son niveau d'intervention, c'est une technique de méta assemblage des objets :
 

• La POO sert à créer des objets et en particulier à créer des composants ActiveX.

• ActiveX est une norme technologique qui permet d'assembler des composants basés objets créés à l'aide d'outils de développement en particulier comme Visual Basic et Delphi, et beaucoup d'autres. Il s'agit d'une technologie ayant trait à l'interopérabilité des objets.

On ajoute un nouveau projet de création de contrôle ActiveX:

VB crée un groupe avec l'ancien projet :

Ce type de module est semblable au module de fiche, il peut contenir des fenêtres et des contrôles dans les fenêtres. Les nouveaux contrôles obtenus sont distribuables à d'autres développeurs.

Extension de fichier pour ce genre de module : xxx.OCX
 
 
 

3. Visual Basic et la POO ...
 

Notre objectif est d'observer comment VB implante certaines notions contenues dans la P.O.O. Ce n'est pas réellement un langage orienté objet, dans ce domaine il possède des fonctionnalités plutôt restreintes par rapport à C++, Delphi et java.

Les restrictions objet de Visual Basic si elles en limitent la richesse sont aussi une des composantes de sa force pédagogique et sa simplicité d’apprentissage, sans nuire à sa capacité de développement sous windows, puisqu’il est utilisé comme langage de développement professionel.
 

3.1 Les éléments de base

En premier lieu il faut savoir que VB dispose de 9 catégories d’objets :

 *1 : Feuille
 *2 : Contrôle
 *3 : Printer (imprimante)
 *4 : Clipboard (presse-papier)
 *5 : Screen (écran)
 *6 : App (l’application)
 *7 : Debug (débogueur)
 *8 : Base de données
 *9 : Graphique

Tous les modules de VB comportent deux parties :
 

• une partie déclaration des variables, des types et constantes
• une partie déclaration et implémentation des procédures et des fonctions

VB possède des types de données classiques sur les entiers, décimaux, chaînes, booléen etc.. qui se déclarent avec le mot clé As :

Dim a,b As integer
Dim c As String
Dim d,e,f As Byte etc...

Lorsqu'aucun type de données n'est spécifié, le type de données par défaut de la variable est Variant. C'est un type générique permettant de représenter tous les autres types qui peut se déclarer aussi :
 

Dim a  (automatiquement Variant)

Dim a As Variant (conseillé)

Les passages des paramètres s'effectuent selon deux modes classiques : le passage par valeur (mot clé ByVal), le passage par référence (mot clé ByRef). Par défaut si rien n'est spécifié le passage est par référence.
 

Exemple d'utilisation un tri récursif sur un tabelau de variant :
(les paramètres sont tous passés par référence par défaut)

Private Sub quicksort (G As Integer, D As Integer, tabl() As Variant)
Dim i As Integer, j As Integer
Dim x As Variant, w As Variant
  i = G
  j = D
  x = tabl((i + j) \ 2)
  Do
    While tabl(i) < x
        i = i + 1
    Wend
   While tabl(j) > x
        j = j - 1
    Wend
    If i <= j Then
        w = tabl(i)
        tabl(i) = tabl(j)
        tabl(j) = w
        i = i + 1
        j = j - 1
    End If
   Loop Until i > j
   If G < j Then
     quicksort(G, j, tabl())
   End If
   If D > i Then
     quicksort(i, D, tabl())
   End If
End Sub

Cette procédure générique permet de trier des entiers longs ou courts, des réels simples ou doubles et des chaînes de caractères.

Le nombre de paramètres effectifs n'est pas nécessairement fixé lors de l'appel, VB dispose d'un mot clé permettant d'indiquer qu'un paramètre formel est facultatif (mot clé optional) :

Dim x As Integer, y As String, z As Boolean
Sub NbrParVar (A As Integer,Optional B As String, C As Boolean)

voici un appel classique de NbrParVar, avec 3 paramètres effectifs:
NbrParVar(x,y,z)

Voici un appel de NbrParVar avec 2 paramètres effectifs:
NbrParVar(x,z)

Dans ce dernier cas VB crée un paramètre invisible de type variant pour B et lui affecte la valeur Empty.

Les mots clés Public et Private indiquent l'encapsulation aussi bien des variables que des procédures et des fonctions selon le principe général du masquage de l'information privée.
 

Voici un exemple de page de code d'un module quelconque :

3.2 Fonctionnalités du langage dans VB

Attention :

VB n'est pas un langage à structure de bloc complet car il ne permet pas de déclarer des blocs à l'intérieur d'autres blocs (ie on ne peut pas déclarer de procédure ou de fonction à l'intérieur d'une procédure ou d'une fonction.

• La visibilité est identique à celle qui est inhérente à tout langage de bloc Algol-like : variables globales, variables locales, masquage des identificateurs.

• Les entités gérées dynamiquement le sont selon un modèle classique de tas et de pile.

• Les entités gérées statiquement (mot clé static)sont persistantes durant toute la durée de l'exécution du programme, mais gardent leur niveau de visibilité.

Private Sub Exemple ( )
  Dim E1,E2 As integer
  Static A1,A2,A3 As Long
End Sub
 

Les variables < Dim E1,E2 As integer > sont des variables locales à la procédure exemple, leur durée d'existence est donc celle de la procédure lors de chaque appel, elles sont détruites à la fin de l'exécution de la procédure.

 

Les variables < Static A1,A2,A3 As Long > sont aussi des variables locales  à la procédure Exemple(), leur durée d'existence est différente de E1 et E2, elles persistent même après la fin de l'exécution de la procédure qui peut lors d'un prochain appel retrouver les valeurs précédentes de A1,A2 et A3. Elles ne sont détruites qu'à la fin de l'application.

 

La pile d'exécution de VB permet des récursivités suffisantes par rapports aux premières versions du langage. Ci-dessous une fonction privée de calcul récursif de la somme des n premiers entiers :
 

Private Function recur(n As Long) As Long  If n = 0 Then   recur = 0  Else   recur = n + recur(n - 1)  End If End Function Vb affiche un message d'erreur de pile pleine sur l'appel recur(5642), donc une profondeur de 5641 appels recursifs a été atteinte sur ce programme. La documentation Microsoft indique que la taille de pile disponible pour Visual Basic est d'un méga-octet (1 Mo) par thread.

 
 

3.3 Les classes

La notion de classe est présente dans VB, elle se met en oeuvre à travers une entité spéciale dénommée : le module de classe.

Une classe VB contient des attributs et des méthodes publiques ou privés, nous avons déclaré un module de classe : "Etudiant.cls" pour représenter la classe simple suivante où tout est publique :

Classe Etudiant

NoteMath     (attribut public)
NoteInfo     (attribut public)
MoyMath(UneNote) (méthode public)
MoyInfo(UneNote) (attribut public)

On crée un module de classe

 

La page de code de ce module représente le code de déclaration et d'implémentation de la classe :

La classe est maintenant utilisable n'importe où, à partir d'une de ses instances NomObjet selon la syntaxe de la notation uniforme NomObjet.attribut ou bien NomObjet.méthode.
 
 

3.4 Le modèle objet de VB

Le modèle est celui de la référence :

Les variables objet sont stockées dans la mémoire dynamique ou statique selon leur déclaration sous forme d'adresses 32 bits faisant référence aux objets contenus dans une mémoire de type tas.

Les objets ne sont accessibles que par leur référence.

Le type générique Object

Une variable de type Object est une variable qui peut être ré-affectée ultérieurement (à l'aide de l'instruction Set) pour faire référence à n'importe quel objet (contrôle ou classe personnelle).

 

3.5 Les objets en VB

Les classes sont instanciables en autant d'objets que le développeur le souhaite.
 

• Le mot clé New est généralement utilisé dans les déclarations pour permettre la création d'une nouvelle instance de la classe.

• Le mot clé Set attribue une référence d'objet à une variable d'objet.

Reprenons la classe étudiant créée précédemment, déclarons 3 variables objet dans une feuille selon le programme ci-dessous :

Dim albert As New Etudiant
Dim julie As Object, Luc As Object

Private Sub Form_Click()
 Set Luc = Nothing
End Sub

Private Sub Form_Load()
  Set Luc = New Etudiant
  Set julie = Luc
End Sub

Détaillons les actions effectuées par VB sur ce programme, tout d'abord les déclarations :
 

Dim albert As New Etudiant  '(albert est un objet instancié de la classe Etudiant) Dim julie As Object, Luc As Object  '(luc et julie sont 2 variables d'objet)

Ensuite, lors du chargement de la feuille nous avons instancié luc, et julie référence le même objet que luc, cela donne le code suivant :
 

Private Sub Form_Load()   Set Luc = New Etudiant  '(luc est un objet instancié de la classe Etudiant)   Set julie = Luc '(julie pointe sur le même objet que luc) End Sub

Nous avons donc créé 2 objets distincts pointés par les variables albert et luc.

La troisième variable julie référençant le même objet que luc :

Afin de mettre fin à l'association entre une variable d'objet et l'objet lui-même VB utilise le mot clé Nothing. L'objet lui-même n'est détruit immédiatement c'est la liaison entre la variable et l'objet qui est annulée. La libération de la mémoire occupée par l'objet s'effectue selon la méthode des compteurs de références.
 

Lorsque plus aucune référence ne désigne un objet alors les resources mémoires sont libérées.

Dans le code suivant :
 

Private Sub Form_Click()  Set Luc = Nothing End Sub

l'instruction Set Luc = Nothing déréférence la variable luc, mais comme la variable julie pointe encore sur l'objet celui-ci n'est pas désalloué.

3.6 Encapsulation en VB

private correspond à la définition privée d'une classe
public correspond à la définition publique d'une classe
friend uniquement pour les méthodes qui peuvent alors être appelées depuis des modules situés en dehors de la classe elle-même, mais faisant partie du projet dans lequel la classe est définie.

Il n'y a pas de polymorphisme au sens  d'un langage orienté objet en Visual Basic, Microsoft préconise dans sa documentation de simuler ce concept à l'aide d'interface multiples du modèle objet composant COM.

3.9 Evènements

Les événements déclarés dans les classes fournies par un composant peuvent être gérés par les clients, que le composant soit exécuté à l'intérieur ou à l'extérieur du processus. Tous les événements sont publics.
 

Déclaration et déclenchement des événements.

Tout comme les procédures, les événements (et leurs arguments) doivent être déclarés.

La déclaration est réalisée à l'aide du mot clé Event, dans la zone de déclaration du code :
 

[Public] EventNom_Evenement [(Liste_Arguments)]

où Liste_Arguments représente une liste d'arguments identiques à celles utilisées dans les déclarations de procédures, sauf pour les cas suivants : les événements ne peuvent pas avoir d'arguments nommés, d'arguments facultatifs ou d'arguments ParamArray. Les événements ne renvoient pas de valeurs.

Pour qu'un événement déclaré survienne, l'objet doit le déclencher à partir du code du module de classe chaque fois que sont remplies les conditions qui définissent l'événement.

L'événement est déclenché par le mot clé RaiseEvent, dans les procédures concernées :
 

RaiseEventNom_Evenement [(Liste_Arguments)]

 

Private Sub Form_Load() Set MonObjet = New MaClasse End Sub

4. Propriétés et méthodes en Visual Basic ...
 

Les propriétés et les méthodes d'une classe composent son interface par défaut. C'est cette interface par défaut qui est généralement utilisée pour manipuler les objets.

En règle générale, les propriétés représentent les données sur un objet, tandis que les méthodes représentent les actions qu'un objet peut effectuer. En d'autres termes, les propriétés fournissent la description de l'objet, tandis que les méthodes désignent son comportement.

Les événements ne font pas partie de l'interface par défaut. Ce sont en fait des interfaces sortantes (qui atteignent et ont une incidence sur d'autres objets), tandis que les propriétés et les méthodes sont des interfaces entrantes (dont les membres sont appelés par d'autres objets). L'interface par défaut d'un objet Visual Basic est une interface entrante.
 

4.1 Propriétés en VB

Même si l'aide en ligne de Microsoft pour Visual Basic considère qu'il existe deux moyens de définir des propriétés personnalisées, le principe orienté objet d'encapsulation nous conduit à n'en décrire qu'un (oublions la notion de propriété définie comme un champ public !). En VB la définition d'une propriété objet est réalisée à l'aide du mot clé Property.

Ainsi, il est possible de masquer des champs (privés) d'un objet et d'en réguler l'accès par des propriétés, publiques, en lecture seule, écriture seule ou lecture/écriture.

Les spécificateurs d'accès sont fonctions du type de champ manipulé.
 

4.2 Ajout de propriétés - Cas général

Nous proposons d'adopter la démarche suivante :

4.2.1 Définition d'un champ privé.

 

Private mintMonChamp As Integer

Utiliser pour cela le menu Outils/Ajouter une procédure, et choisir les options Type/Property et Portée/Public :

L'assistant créée automatiquement le squelette des propriétés de lecture "GET" et d'écriture "LET".

4.2.3 Renseigner le code de la lecture de la propriété

Elle permet de préciser la forme sous laquelle la propriété est lue. Si elle n'est pas définie, alors cette propriété peut être écrite mais pas lue. Ne pas oublier de changer le type de la propriété.

 

Public Property Get MonChamp() As Integer MonChamp = mintMonChamp End Property

 

Variable = Objet.MonChamp

La propriété à définir est transmise à la procédure en tant qu'argument. Donc la liste des paramètres contient toujours un argument. Le code peut préciser des conditions particulière : ici le mintMonChamp ne peut être qu'incrémenté.

 

Public Property Let MonChamp(ByVal NouveauChamp As Integer) If NouveauChamp < mintMonChamp Then mintMonChamp = NouveauChamp End Property

 

Objet.MonChamp = 100

La démarche est la même que décrite précédemment. Mais si le champ privé fait référence à un objet, les spécificateur d'accès à la propriété sont modifiés :

• la lecture de l'objet est réalisé avec l'instruction set,
• l'écriture dans l'objet est réalisé avec la propriété SET et non pas LET (l'assistant de création de propriété ne permet pas de créer le squelette de la propriété SET. Il faut le faire soi même).

4.4 Propriétés de type Variant

Dans ce troisième cas , il faut que le code puisse répondre aux 2 cas de figure précédents.
Donc il est nécessaire de respecter les règles suivantes :

• La lecture du Variant est réalisée par la propriété GET. Elle peut être codée pour traiter les deux cas de figure à l'aide de la fonction IsObject, afin de tester la variable de type variant privée avant de renvoyer la valeur.
• Pour l'écriture, le variant doit disposer des 2 propriétés SET et LET.

4.5 Propriétés pour les contrôles ActiveX

Pour implémenter les propriétés d'un contrôle ActiveX, on ajoute les procédures de propriété au module de code de l'objet UserControl qui constitue la base de la classe du contrôle.

Les propriétés pour les contrôles diffèrent de deux façons des propriétés des autres objets créés avec Visual Basic :

• Les valeurs de propriétés sont affichées dans la fenêtre Propriétés et dans la boîte de dialogue Pages de propriétés, au moment de la création.
• Les valeurs de propriétés sont sauvegardées dans, et extraites du, fichier source du conteneur, afin qu'elles soient conservées d'une session de programmation à l'autre.

Ces différences se traduisent, par rapport aux autres types d'objets, par une augmentation des besoins et des options relatives à l'implémentation des propriétés pour les contrôles.

Il faut notamment indiquer à Visual Basic à quel moment une valeur de propriété est modifiée. Pour ce faire, invoquez la méthode PropertyChanged de l'objet UserControl à la fin de chaque procédure Property Let ou Property Set réussie :

Sa syntaxe est la suivante :
 

object.PropertyChanged "Nom_de_la_propriété"

Le fait d'informer le conteneur que la valeur d'une propriété a été modifiée permet à celui-ci de synchroniser sa fenêtre Propriétés avec les nouvelles valeurs des propriétés de l'objet. Notons également que le conteneur ne pourrait pas savoir si une instance de l'objet nécessitait d'être enregistrée (par le biais d'un événement WriteProperties) s'il n'était pas informé du changement de valeur de propriété intervenu.

Il convient d'appeler cette méthode lorsque, par exemple, un utilisateur change la valeur d'une propriété sur une page de propriétés, ou, lorsque l'objet lui-même modifie une valeur de propriété. Cette méthode doit également être invoquée lorsqu'une propriété dépendante est modifiée, faute de quoi, la source de données ne sera pas mise à jour.

Les propriétés uniquement accessibles au moment de l'exécution ne nécessitent pas d'appeler la méthode PropertyChanged sauf si elles sont susceptibles d'être dépendantes.
 
 

4.6 Les méthodes en VB

Les méthodes d'une classe sont en fait les procédures publiques Sub ou Function qui sont déclarées. Les procédures Sub et Function étant publiques par défaut, il n'est pas nécessaire d'indiquer explicitement le mot clé Public pour créer une méthode. Cependant, il est préférable de le faire afin de faciliter la maintenance du code.
 

Propriétés et Méthodes Friend

En plus des déclarations de propriétés et méthodes en tant que Public et Private, il est également possible de les déclarer en tant que Friend.

Pour les autres objets du projet, les membres Friend s'apparentent aux membres Public, comme s'ils appartenaient à l'interface d'une classe, ce qui n'est pas le cas.
 
 

Dans les composants ActiveX, les membres Friend jouent un rôle important. Ils ne font en fait pas partie de l'interface d'un objet et ne sont pas accessibles aux programmes qui utilisent les objets du composant. Mais les membres sont visibles de tous les autres objets du composant et permettent donc une communication interne en toute sécurité au sein du composant.