Utiliser l'objet Recordset ADO

51 Pages·2004·0.84 MB·French

MMiiggrreerr ddee VVBB66 àà VVBB..NNEETT –– PPrreemmiièèrree ppaarrttiiee
JJ--MM RRaabbiilllloouudd

wwwwww..ddeevveellooppppeezz..ccoomm..
RReepprroodduuccttiioonn,, ccooppiiee,, ppuubblliiccaattiioonn ssuurr uunn
aauuttrree ssiittee WWeebb iinntteerrddiittee ssaannss ll''aauuttoorriissaattiioonn ddee ll''aauutteeuurr..

Remerciements
J'adresse ici tous mes remerciements à l'équipe de rédaction de "developpez.com" et tout
particulièrement à David Pédéhourcq, Jacques Malatier, Piotrek et pharaonix pour le temps qu'ils ont bien
voulu passer à la correction et à l'amélioration de cet article.
INTRODUCTION...........................................................................................................2
AVANT PROPOS..........................................................................................................3
LE FRAMEWORK DOTNET .........................................................................................3
UN NOUVEL ENVIRONNEMENT.................................................................................4
PREMIERES DIFFERENCES......................................................................................12
De drôle de types.....................................................................................................................................................12
VB AURA SA POO......................................................................................................12
C’est nouveau mais nous l’avons déjà vu..............................................................................................................12
Assembly bien compliqué.......................................................................................................................................15
C’est la classe...........................................................................................................................................................16
Initions-nous avec INI............................................................................................................................................17
Encapsulation..........................................................................................................................................................22
Interface...................................................................................................................................................................25
1
Héritage...................................................................................................................................................................26
Polymorphisme.......................................................................................................................................................32
En résumé................................................................................................................................................................33
ON ERROR GOTO EXCEPTION................................................................................33
Généralités...............................................................................................................................................................33
Créer et lever ses exceptions..................................................................................................................................35
DE VB6 A VB.NET......................................................................................................36
Des petites modifications........................................................................................................................................36
Des changements plus important...........................................................................................................................38
PROCEDURE DE S’EN PASSER...............................................................................39
L’ EVENT SE LEVE.....................................................................................................40
WithEvents & Handles...........................................................................................................................................40
AddHandler & RemoveHandler............................................................................................................................41
Création d’évènement.............................................................................................................................................41
LES CONTROLES SONT FREQUENTS ....................................................................43
C’est la Form...........................................................................................................................................................43
Ne pas perdre le contrôle........................................................................................................................................45
Et voici le menu.......................................................................................................................................................49
CONCLUSION.............................................................................................................51

Introduction
Ce document s’adresse tout particulièrement aux développeurs VB6 d’un niveau intermédiaire. Si vous
avez démarré VB6 il y a peu, utilisez plutôt un cours de VB.NET pour débutants, tel que :
Cours d'initiation à VB.NET : 70 chapitres>
Dans ce cours, nous allons voir comment migrer tranquillement de VB6 vers VB.NET. Tout au long de
celui-ci, nous regarderons ce qui a changé entre les deux, ce qui a disparu et ce qui est nouveau. Je vous
donnerai des exemples de conversion pour illustrer le propos. Nous nous concentrerons sur les applications
Windows Forms puisque c’est globalement ce que faisais VB6.
Il est presque impossible de couvrir l’ensemble du domaine dans un cours, mais nous aborderons les
principaux points dans ce premier cours. D’autres points plus spécifiques seront traités dans d’autres cours si
le besoin s’en fait sentir.
Bonne lecture.
2
Avant Propos
Depuis la sortie de VB.NET, on nous serine le même message, la migration va être affreusement
compliquée, il va falloir tout réapprendre, maintenant ce sera la programmation orientée objet ou la mort ;
bref du sang et des larmes. J’avoue que j’ai mis du temps à regarder VB.NET car je ne voyais pas bien ce
que cela pouvait m’apporter. De tendance secrètement masochiste, je fréquente depuis longtemps des
communautés de développeurs où de bien doctes personnes m’ont expliquées que le Visual Basic était juste
bon pour programmer la gestion de ma vidéothèque, à condition de ne pas posséder trop de cassettes.
Comme VB6 couvrait généralement mes besoins, j’ai laissé chanté les érudits. Reconnaissons que sur un
point au moins ils avaient raison, une partie de la vitesse de développement de VB6 était due à la
permissivité de celui-ci, ce qui a occasionné de bien funestes surprises.
Tout ça pour dire que le fait ne pas faire de la programmation objet ne m’a jamais fais culpabiliser. En
lisant donc les promesses de la migration VB.NET, j’avoue que je ne voyais pas l’intérêt de réaliser cette
migration. Force est de constater que je ne le regrette pas aujourd’hui.
En migrant moi-même, je me suis rendu compte que cette migration n’est pas la montagne escarpée
promise, et nous allons voir tout au long de ce document comment migrer sans douleur. Pourquoi cela ?
En fait, la plupart de ces ‘nouveaux’ concepts de la POO, nous les avons croisés, utilisés ou contournés
lors de nos programmations VB6. Ils nous sont familiers pour la plupart sans que nous en ayons conscience.
Après une petite visite de l’IDE, nous verrons comment réapprendre ce que nous savons déjà.
Le Framework DotNet
Le voici donc ce NET, qui des traits de son maître
A détruit l’harmonie, il en rougit le traître.
Voila en quelques mots comment est perçu la nouvelle plate-forme de développement de Microsoft.
Quelle tempête formidable depuis deux ans, “VB est mort”, “Il va falloir tout réapprendre”, “la fin du
procédural”, et bien d’autre encore.
Mais quelle révolution effective pour le développeur VB ?
Les composants s’appelle désormais Assembly, on ne leurs en veut pas.
Les ressources sont gérées par l’environnement plutôt que par le système, la belle affaire.
Le code généré est un langage intermédiaire compilé à la volée, pourquoi pas ?
Lorsque j’entend des développeurs VB6 hurler à l’encontre de la difficulté de la POO, je ne peux
m’empêcher de sourire en pensant que cela fait des années qu’ils font du COM autrement plus complexe,
sans d’ailleurs s’en être rendu compte.
Nous allons voir dans ce cours, que la migration de VB6 vers VB.NET est assez naturelle. Je vais tenter
de vous montrer que nous restons dans l’univers de VB, avec de nouvelles possibilités très intéressantes,
qu’il est possible de migrer à son rythme sans être obligé de lire un million de page de cours pour faire vos
programmes. Bref, nous allons tordre le cou à un mythe.

Le Framework est un environnement managé. Ce nom vient de la terminologie anglaise “Managed Risk
Software”.
Le concept en est assez simple. Les langages classiques (natifs ou interprétés) s’exécutent directement
sur le système d’exploitation. Les langages managés quant à eux utilisent une couche intermédiaire qui se
met entre le système et l’application. L’implication principale est visible, on échange les fonctionnalités de
cette couche intermédiaire contre de la vitesse d’exécution. De fait, le Framework gère pour vous un certain
nombre de tâches, généralement de façon transparente, tout comme VB6 le fait.

En VB6, vous avez probablement utilisé des composants externes, ActiveX ou non. Cette utilisation
était gérée par le système par le biais de la base de registre et d’une stratégie d’appel assez complexe. Il ne
pouvait exister qu’une seule version d’un composant sur un poste et cela pose des problèmes. En effet, pour
installer votre application sur un poste, il faut déployer aussi l’ensemble des composants Ad Hoc, ce qui est
déjà un peu lourd. De plus, il faut qu’au cours de son évolution, le composant soit toujours compatible avec
ses anciennes versions, règle COM sur laquelle des générations de programmeurs se sont assises sans
sourciller.
3
Le Framework n’utilise pas la base de registre pour gérer ses composants. Il peut utiliser un processus
similaire quand on travaille sur le Global Assembly Cache, mais peut aussi gérer les composants
différemment laissant la possibilité d’avoir plusieurs versions d’un composant sur le même poste.

Le Framework gère aussi l’allocation des ressources de votre application. Pour le développeur, cela ne
change pas grand chose, les objets créés doivent être détruire, il faut fermer les fichiers que l’on a ouvert,
bref celui qui travaille proprement en VB6 ne verra pas de différences en VB.NET. Là encore, la tâche sera
plutôt plus simple, puisque le Framework sait résoudre les références circulaires, s’occupe de la destruction
réelles des objets, et accessoirement vous préviens quand ça commence à sentir le sapin sans se sentir obligé
de percuter le système par solidarité.
Et c’est le dernier point que je vais aborder, car les environnements managés en se mettant entre les
applications et le système, protègent celui-ci des erreurs dues aux applications.
Un nouvel environnement
C’est donc d’un pas décidé que nous installons notre Visual Studio, et le souffle court que nous appelons
pour la première fois l’IDE. La première boite de dialogue est très différente de l’invite de projet VB6, mais
pour le prix c’est bien le moins.

Les trois premiers modèles couvrent sensiblement tout ce que nous verrons dans le cours puisque c’est
similaire à ce que VB6 nous proposer sous la forme, Exe standard, DLL, contrôles utilisateurs.
Choisissons donc une Application Windows que nous nommerons ‘Debut’.
Nous arrivons alors dans l’IDE proprement dit, avec devant nous une feuille Form1 donc rien de bien
nouveaux. Vous voyez aussi l’explorateur de projet (qui est devenu explorateur de solutions), la boite à outils
(qui à maintenant plusieurs onglets) et la fenêtre des propriétés, donc rien de bien surprenant.
4
Juste en passant, regardons l’explorateur de solution car il contient de nouveaux éléments :

Comme nous sommes curieux comme des chats, nous cliquons sur le petit + de références et oh,
merveille de l’informatique, nous obtenons :

Vous avez déjà ajouté des références dans vos programmes VB6, et bien ce que vous voyez dans le
dossier référence est à peu près identique. Mais nous y reviendrons.
En bas à gauche de votre IDE, se trouve une fenêtre à trois onglets, Liste des tâches, Sortie,
Commande.

Si les fenêtres commande et sortie peuvent êtres apparentés à la fenêtre exécution de VB6, la
liste des tâches est une nouveauté extrêmement pratique.
Celle-ci regroupe les informations suivantes :
Erreur de génération : Au lieu de vous remettre sur la ligne en erreur comme en VB6, l’erreur
s’affiche dans la liste des tâches avec le message et la ligne concerné. Un double-clic sur la ligne de
la liste des taches vous positionne sur la ligne en arrière.
Commentaires : Les commentaires suivis d’un Tag TODO, HACK, UNDONE se reporte dans
la liste des taches. Il est possible de créer d’autres TAG
Signets : Vous pouvez insérer des signets avec renvoie dans la liste des tâches, ce qui permet de
naviguer facilement entre plusieurs lignes.

5
Sur ma feuille, Je vais ajouter trois zones de texte et un bouton, le principe étant de faire la somme des
zones un et 2 dans la zone trois lors d’un clic sur le bouton.
A l’instar de mes applications VB6, j’utilise la fenêtre des propriétés pour renommer mes contrôles
txtEntree1, txtEntree2, txtSomme et cmdSomme. Je mets les propriétés Text de mes zones de texte à ‘0’, je
mais la propriété Enabled de ma zone ‘Somme’ à False et je vais modifier la propriété Caption de mon
bouton.
Tiens, dis-je en moi-même car c’est une langue que je parle couramment, mon bouton n’a plus de
propriété Caption. En effet, cette propriété s’appelle maintenant Text. C’est la première nouveauté, la
propriété qui affecte un texte à un contrôle s’appelle Text. Reconnaissons que c’est plus facile à retenir.
Je rajoute enfin un label auquel j’affecte ‘Somme’ dans la propriété….. Text, merci à ceux qui ont suivi.
J’ai donc une feuille semblable à :

Comme mes deux zones d’entrées doivent se comporter de façon identique, je veux faire un groupe de
contrôle, malheureusement pas plus de propriété index que de beurre en branche.(il est cependant possible de
palier l'absence d'index en utilisant les GroupBox)
Tant pis, comme au bon vieux temps du VB4, je taperais deux fois le code.
Maintenant je double-clic sur mon bouton afin d’aller écrire le code de son événement clic.
Et nous voilà projeté dans un univers semblable mais différent de ce que nous connaissons.
Je retrouve bien ma liste déroulante des contrôles, mais elle contient des nouveautés

Ainsi que celle des évènements correspondant

6
Mais surtout, le code généré ressemble à ça :

Attiré par la nouveauté comme les poissons par la chute d’un corps dans l’eau, je clique sur la croix pour
voir le code généré par le concepteur Windows Form et j’obtiens :
Public Class Form1
Inherits System.Windows.Forms.Form

#Region " Code généré par le Concepteur Windows Form "

Public Sub New()
MyBase.New()

'Cet appel est requis par le Concepteur Windows Form.
InitializeComponent()
'Ajoutez une initialisation quelconque après l'appel
InitializeComponent()

End Sub

'La méthode substituée Dispose du formulaire pour nettoyer la liste des
composants.
Protected Overloads Overrides Sub Dispose(ByVal disposing As Boolean)
If disposing Then
If Not (components Is Nothing) Then
components.Dispose()
End If
End If
MyBase.Dispose(disposing)
End Sub
'Requis par le Concepteur Windows Form
Private components As System.ComponentModel.IContainer

'REMARQUE : la procédure suivante est requise par le Concepteur Windows Form
'Elle peut être modifiée en utilisant le Concepteur Windows Form.
'Ne la modifiez pas en utilisant l'éditeur de code.
Friend WithEvents txtEntree1 As System.Windows.Forms.TextBox
Friend WithEvents txtEntree2 As System.Windows.Forms.TextBox
Friend WithEvents cmdSomme As System.Windows.Forms.Button
Friend WithEvents txtSomme As System.Windows.Forms.TextBox
Friend WithEvents Label1 As System.Windows.Forms.Label
<System.Diagnostics.DebuggerStepThrough()> Private Sub InitializeComponent()
Me.txtEntree1 = New System.Windows.Forms.TextBox
Me.txtEntree2 = New System.Windows.Forms.TextBox
Me.cmdSomme = New System.Windows.Forms.Button
Me.txtSomme = New System.Windows.Forms.TextBox
Me.Label1 = New System.Windows.Forms.Label
Me.SuspendLayout()
'
'txtEntree1
'
Me.txtEntree1.Location = New System.Drawing.Point(32, 24)
Me.txtEntree1.Name = "txtEntree1"
Me.txtEntree1.Size = New System.Drawing.Size(72, 20)
7
Me.txtEntree1.TabIndex = 0
Me.txtEntree1.Text = "0"
'
'txtEntree2
'
Me.txtEntree2.Location = New System.Drawing.Point(176, 24)
Me.txtEntree2.Name = "txtEntree2"
Me.txtEntree2.Size = New System.Drawing.Size(72, 20)
Me.txtEntree2.TabIndex = 1
Me.txtEntree2.Text = "0"
'
'cmdSomme
'
Me.cmdSomme.Location = New System.Drawing.Point(56, 112)
Me.cmdSomme.Name = "cmdSomme"
Me.cmdSomme.Size = New System.Drawing.Size(168, 24)
Me.cmdSomme.TabIndex = 2
Me.cmdSomme.Text = "Faire la somme"
'
'txtSomme
'
Me.txtSomme.Enabled = False
Me.txtSomme.Location = New System.Drawing.Point(88, 64)
Me.txtSomme.Name = "txtSomme"
Me.txtSomme.Size = New System.Drawing.Size(136, 20)
Me.txtSomme.TabIndex = 3
Me.txtSomme.Text = "0"
'
'Label1
'
Me.Label1.Location = New System.Drawing.Point(8, 64)
Me.Label1.Name = "Label1"
Me.Label1.Size = New System.Drawing.Size(72, 16)
Me.Label1.TabIndex = 4
Me.Label1.Text = "Somme"
'
'Form1
'
Me.AutoScaleBaseSize = New System.Drawing.Size(5, 13)
Me.ClientSize = New System.Drawing.Size(304, 181)
Me.Controls.Add(Me.Label1)
Me.Controls.Add(Me.txtSomme)
Me.Controls.Add(Me.cmdSomme)
Me.Controls.Add(Me.txtEntree2)
Me.Controls.Add(Me.txtEntree1)
Me.Name = "Form1"
Me.Text = "Form1"
Me.ResumeLayout(False)

End Sub

#End Region

Private Sub cmdSomme_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles cmdSomme.Click

End Sub
End Class
En voilà bien du code pour un malheureux formulaire.
8
Tout ce code généré existait bel et bien dans VB6, mais il n’était pas question d’y accéder. J’en connais
quelques-uns qui regrettent déjà d’avoir cliqué sur la croix. Pour l’instant nous n’allons pas regarder ce code,
nous y reviendrons ultérieurement.
Pour mémoire, rappelons-nous que le code VB6 pour faire la somme de deux entiers longs avec des
zones de textes serait
Code VB6
Private CalculOK As Boolean

Private Sub cmdSomme_Click()

If Not CalculOK Then Exit Sub
Dim Somme As Double
Somme = Val(txtEntree(0).Text) + Val(txtEntree(1).Text)
txtSomme.Text = Somme

End Sub

Private Sub txtEntree_KeyPress(Index As Integer, KeyAscii As Integer)
Const Nombre As String = "0123456789"
If KeyAscii <> 8 Then
If InStr(Nombre, Chr(KeyAscii)) = 0 Then
KeyAscii = 0
Exit Sub
End If
End If
End Sub

Private Sub txtEntree_Validate(Index As Integer, Cancel As Boolean)
If Len(txtEntree(Index).Text) = 0 Then txtEntree(Index).Text = 0
On Error GoTo troplong
Dim TestVal As Long
TestVal = CLng(txtEntree(Index).Text)
CalculOK = True
Exit Sub
troplong:
MsgBox "La valeur entrée ne peut excéder 2 147 483 647"
CalculOK = False
End Sub
Pour faire le début en VB.NET, pas de problème. Je peux écrire
Private calculOk As Boolean

Private Sub cmdSomme_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles cmdSomme.Click
If Not calculOk Then Exit Sub
Dim Somme As Double
Somme = Val(txtEntree1.Text) + Val(txtEntree2.Text)
txtSomme.Text = Somme
End Sub
Sans que l’environnement de développement hurle à la mort. Par contre pour le KeyPress ça commence
à se gâter.
9
Si je tape :
Private Sub txtEntree1_KeyPress(ByVal sender As Object, ByVal e As
System.Windows.Forms.KeyPressEventArgs) Handles txtEntree1.KeyPress
Const Nombre As String = "0123456789"
If KeyAscii <> 8 Then
If InStr(Nombre, Chr(KeyAscii)) = 0 Then
KeyAscii = 0
Exit Sub
End If
End If
End Sub
Je voie que KeyAscii est souligné partout. Ceci est normal puisqu’il n’y a pas de KeyAscii dans les
arguments de l’événement KeyPress. Encore pire, il n’y a plus d’événement Validate pour la zone de texte,
mais un événement Validating et un événement Validated.
Mais bon, nous autres développeurs VB6 sommes des tenaces, donc accrochons nous. Je me dis bien
que vu sa tête, l’argument e contient des trucs. Et la miracle, je trouve un e.KeyChar qui m’a l’air bien
sympathique. J’écris donc :
Private Sub txtEntree1_KeyPress(ByVal sender As Object, ByVal e As
System.Windows.Forms.KeyPressEventArgs) Handles txtEntree1.KeyPress
Const Nombre As String = "0123456789"
If e.KeyChar <> 8 Then
If InStr(Nombre, Chr(e.KeyChar)) = 0 Then
e.KeyChar = 0
Exit Sub
End If
End If
End Sub
Las, cet abominable environnement me souligne encore mes e.KeyChar. Par contre, si je regarde mes
erreurs dans la fenêtre ‘liste des tâches’, il me dit « les valeurs 'Char' en 'Integer'. Utilisez
'Microsoft.VisualBasic.AscW' pour interpréter une valeur numérique en tant que caractère Unicode soit
'Microsoft.VisualBasic.Val' pour interpréter le caractère comme un chiffre ».
Donc, toujours discipliné, j’écris
Private Sub txtEntree1_KeyPress(ByVal sender As Object, ByVal e As
System.Windows.Forms.KeyPressEventArgs) Handles txtEntree1.KeyPress
Const Nombre As String = "0123456789"
If Microsoft.VisualBasic.AscW(e.KeyChar) <> 8 Then
If InStr(Nombre, e.KeyChar) = 0 Then
e.KeyChar = Microsoft.VisualBasic.AscW(0)
Exit Sub
End If
End If
End Sub
Ce n’est pas encore fini, car ma fenêtre d’erreur m’annonce sans sourciller que e.KeyChar est en lecture
seule. Je retourne farfouiller dans ce maudit e, et je trouve une propriété Handled qui permet d’indiquer
qu’on ne souhaite pas que l’événement soit géré. Je finis donc par écrire ma fonction
Const Nombre As String = "0123456789"
If Microsoft.VisualBasic.AscW(e.KeyChar) <> 8 Then
If InStr(Nombre, e.KeyChar) = 0 Then
e.Handled = True
Exit Sub
End If
End If
10