Cours complet en Visual Basic.net

Considérant que vous savez normalement déjà allumer un PC et l'éteindre, utiliser une souris et un clavier de préférence, et que vous êtes motivé pour écrire des programmes en Visual Basic.NET, que ce soit pour le plaisir ou le travail, vous êtes donc prêt à commencer la programmation en VB.NET !

En plus d'un PC, il vous faut un exemplaire de Visual studio.NET. Dans le cas où vous douteriez de vos capacités à apprendre la programmation, souvenez-vous d'Albert Einstein (le célèbre physicien qui a inventé la théorie de la relativité). Un de ses instituteurs avait déclaré qu'il apprenait si lentement qu'il était sans doute attardé !

Peut-être en réponse à cela, Albert Einstein a dit un jour : « L'imagination est plus importante que le savoir ». Certaines personnes soutiennent qu'il aurait aussi dit : « Si mon instituteur est si intelligent, où est son prix Nobel ? » (Ce qui reste à vérifier !!)

Avec de l'imagination, un ordinateur et VS.NET (Visual Studio qui est l'outil de développement), vous êtes fin prêt pour le grand saut dans le monde de la programmation…

Le Visual Basic.NET est la dernière version de Visual Basic. Pour comprendre les changements que Microsoft a apportés au langage Visual Basic dans cette version, il faut comprendre ce que Microsoft tente d'accomplir avec le concept .NET.

Il existe des centaines de langages de programmation différents pour résoudre différentes tâches. Un gros problème est que ces langages de programmation ne sont pas conçus pour travailler ensemble.

Même les langages de programmation d'un même éditeur, comme Microsoft, ont des problèmes à travailler ensemble. Les versions précédentes de Visual C++ et Visual Basic enregistrent les données, telles que chaines et nombres, de façon différente. Du fait qu'il est très fastidieux de découvrir tous les moyens particuliers employés par chaque langage de programmation pour enregistrer et manipuler les chaines et les nombres, la plupart des programmeurs écrivent leurs programmes à l'aide d'un seul langage de programmation, même lorsqu'un second langage convient mieux pour résoudre un problème particulier. Par exemple, le Visual Basic est très utile pour faire des applications de bureautique, le C++ est plus puissant que le Basic et donc à utiliser pour les très gros programmes. Quant au Java, il est utilisé dans la conception de sites Internet sophistiqués.

Microsoft a donc développé quelque chose baptisé « .NET Framework », qui agit comme couche intermédiaire entre le système d'exploitation (Windows) et tous les programmes que vous écrivez. Cela résout deux problèmes majeurs.

Le premier problème résolu par le .NET est la possibilité pour différents langages de coopérer entre eux. Au lieu d'octroyer à chaque langage un accès direct au système d'exploitation de l'ordinateur, l'infrastructure .NET Framework force les langages qui ont été conçus pour travailler avec .NET (comme VB.NET) à stocker leurs chaines et nombres exactement de la même manière. De la sorte, vous pouvez écrire un programme utilisant différents langages sans vous préoccuper du fait qu'un langage stocke et manipule les données de façons différentes d'un autre langage de programmation.

Le second problème résolu par le .NET Framework concerne la distribution du programme. Actuellement, la plupart des utilisateurs exécutent des programmes stockés sur leurs disques durs… Bref, passons enfin aux choses plus intéressantes !

Tout ordinateur se plante périodiquement et la mise en place de nouvelles technologies résorbe rarement les faiblesses des technologies déjà mises en place. Aussi promoteur que soit .NET, ne vous laissez pas abuser par le marketing de Microsoft…

Le .NET Framework, étant un logiciel est sujet à toutes sortes de bugs qui font de l'usage de l'ordinateur une expérience frustrante. D'autant plus que cette technologie n'est disponible que pour les versions récentes de Windows (XP et suivant). Si vous souhaitez écrire des programmes pour Linux ou Windows versions antérieures, vous devez passer par la version 6.0 de Visual Basic.

Bon c'est fini pour l'introduction, passons au codage pur ! Mais avant tout, regardons d'un peu plus près, les structures utilisées dans la technologie .NET.

Déjà il faut savoir ce qu'est un objet en programmation. Prenons un exemple de la vie courante :

Une voiture est un objet. Jusqu'à présent, rien de bien compliqué. Cette voiture a des phares, un volant, des pédales, un capot, une couleur, une marque… Ce sont des propriétés de la voiture. De plus, toutes ses propriétés ont des valeurs. Par exemple, la couleur de la voiture peut être bleue ou rouge (bleu et rouge sont les valeurs de la propriété « couleur »). En programmation c'est un peu pareil : La voiture fait partie d'un grand ensemble qui est « les voitures ». « Les voitures » représentent la « class » en programmation. L'objet est « ma voiture ». Un objet est créé suivant un modèle qu'on appelle une Class.

'exemple pour créer 'MaVoiture' à partir de la class " LesVoitures "
Dim MaVoiture As New LesVoitures

MaVoiture a été instanciée (par le mot-clé 'new'). Utilisons quelques propriétés de MaVoiture :

'propriétés de MaVoiture
MaVoiture.Couleur = " Bleue " 'la couleur est bleue
MaVoiture.Phares = 2 'elle possède 2 phares

MaVoiture possède aussi des méthodes. Par exemple, elle roule : c'est une méthode.

'Méthode de MaVoiture
MaVoiture.Roule() ' la voiture roule

Une méthode est caractérisée par des parenthèses. Mais une méthode peut demander des paramètres. Par exemple, à quelle vitesse doit rouler MaVoiture ? Un paramètre est un renseignement envoyé à la méthode.

'Méthode avec paramètre
MaVoiture.Roule(100) 'MaVoiture va rouler à 100 km/h

Dans cet exemple, MaVoiture est un objet, Roule est une méthode et 100 est un entier (Integer).

On peut aussi fournir plusieurs paramètres :

'Méthodes avec plusieurs paramètres
MaVoiture.Roule(100, avant) 'Ici elle va rouler à 100 km/h en avant !

Enfin, un objet (ici MaVoiture) peut avoir des événements. Dans notre exemple, MaVoiture peut tomber en panne, démarrer ou s'arrêter. 'TomberEnPanne', 'Demarrer' ou 'Arrêter' sont des événements.

'Evenement de MaVoiture
MaVoiture.Roule(100, avant) 'Ici elle va rouler à 100 km/h en avant !
'MaVoiture_Demarrer va donc se déclencher à cause de l'appel de la méthode 'Roule'

Si on récapitule, un objet est donc dérivé d'une Class. Un objet possède des propriétés, des méthodes et des événements (et d'autres choses…)

Une instruction permet d'effectuer une opération, une déclaration, une définition.

Dim A As Integer ' est une instruction (de déclaration)
A=1 ' est aussi une instruction qui effectue une assignation.

C'est habituellement une 'ligne de code exécutable'. Une instruction est exécutée lorsque le programme marche. Plusieurs instructions peuvent se suivre sur une même ligne, séparées par ':'

Dim B As String : B="Bonjour"

Si une ligne est très longue, on peut passer à la ligne grâce à '_'

Dim B As String = "Bonjour monsieur ": C= _
"le professeur"
'Equivaut à :
Dim B As String = "Bonjour monsieur ": C= "le professeur"

Quand un programme tourne, les instructions sont effectuées ligne après ligne.

1  Dim B As String 
2  B="Bonjour"
3  Dim A As Integer 
4  À= 3
5  A= A + 1

La ligne 1 est exécutée puis la ligne 2 puis la 3, la 4…
Bien que l'on puisse avoir des numéros de ligne, ils ne sont plus utilisés actuellement et ils sont invisibles.

Pour mettre des commentaires dans un programme, on le fait précéder d'une apostrophe. À la différence d'une instruction, le commentaire ne sera pas exécuté.

'Ceci est un commentaire, ce n'est pas une instruction.

Une procédure est un ensemble d'instructions qui effectue une fonction précise. En Visual Basic.NET, il existe deux sortes de procédures : les 'sub' et les 'function' . Les 'sub' commencent par le mot-clé 'sub' puis finissent par 'end sub' et ne retournent aucune valeur contrairement aux fonctions qui débutent par 'function' puis finissent par 'end function' et qui retournent une valeur précise.

'Exemple de sub
Sub DemarrerProgramme()
     'la procédure ne retournera aucune valeur.
End Sub

'Exemple de fonction
Function CalculerPi()
     'la fonction va retourner la valeur de PI après une série de calculs…
End Function

'Exemple d'appel de fonction ou sub
Call DemarrerProgramme 'déconseillé
CalculerPi() 'OK
'Ces deux appels sont identiques

Les modules sont des feuilles (ou formulaires) qui contiennent plusieurs procédures et/ou fonctions. Un module commence toujours par le mot-clé 'Module' et finit par 'End Module'

'Exemple de module
Module NomDeMonModule
     Sub Test1()
          'Procédure 1
     End Sub
 
     Function Test_1()
          'Fonction 1
     End Function

     Function Test_2()
          'Fonction 2
     End Function

     Sub Test2()
          'Procédure 2
     End Sub
End Module

Récapitulatif : Une instruction est une ligne de code qui va être exécutée par le programme. Une fonction retourne une valeur contrairement à la procédure qui n'en retourne pas. Un module n'est en fait qu'une feuille contenant de nombreuses procédures et fonctions.

En programmation, une des choses essentielles est l'utilisation des variables. Une variable est une sorte de boite qui contient une valeur. Par exemple, je mets une chaussure dans une boite. La 'boite' représente la variable et la valeur est la 'chaussure'. L'intérêt principal des variables est leur utilisation ultérieure. En effet, on peut utiliser une variable à n'importe quel moment dans le programme en fonction de la portée de cette variable. (Voir chapitre sur la portée des variables)

III-A-1. Les variables▲

'Exemples de noms de variables
MaVariable 'est acceptée
COOL 'est acceptée
Je_Suis_1_Variable 'est aussi acceptée
2Variable 'est refusée
2_Variable 'est également refusée
The Variable 'est réfusée
Différent 'est aussi refusée

'Exemple : 
Variable_pour_calculer_pi 'est mieux que
VariablePourCalculerPi 'mais ces deux lignes sont équivalentes

'Exemples de déclarations de variables
Dim Ma_Variable As String
Dim Nombre As Integer
Dim Compteur As Integer

'Instancier des variables
Dim Msn As New Msn_Protocol 'Msn_Protocol est une class
Dim Test As New Class

'Exemple avec les variables précédentes
Dim Ma_Variable As String = " toto "
Dim Nombre As Integer = 45
Dim Compteur As Integer = 1000

'Exemple de variable instanciée par une fonction
Dim Pi As Decimal = Fonction_pour_calculer_pi()

III-A-2. Les différents types de variables▲

III-A-3. Convertir des variables▲

'Exemples
Dim Pi As Decimal = 3.14 'crée la variable Pi qui vaut 3.14
Dim a As Integer = 15 'crée la variable a qui vaut 15

Dim Pi_Entier As Integer = CInt(Pi) 'retournera 3
Dim a_caractère As String = CStr(a) 'retourner " 15 " 'en chaine de caractères

III-A-4. La portée des variables▲

'Exemple avec des sub et fonctions

Module Test_Portee

     Private Sub Test()

     End Sub

     Protected Sub Azerty(ByVal Argument As String)

     End Sub

     Private Shared Function Calcul(ByVal Nombre As Integer)

     End Function

End Module

'Exemple
Module Test
     Public Nombre As Integer

     Public Sub Routine_Qui_Va_Affecter_La_Variable(ByVal Valeur As Integer)
            Nombre = Valeur
     End Sub
End Module

'Quelque part d'autre dans le programme on appel la procédure avec un argument de type Integer
Call Routine_Qui_Va_Affecter_La_Variable(45) 

'Ensuite dans le programme totale, la variable Nombre va valoir 45
MsgBox(Nombre.ToString) 'Affiche dans une boite de dialogue la valeur

Nombre = 45

Les conditionnelles comme les boucles permettent de gérer le déroulement du code. Il existe deux grands types de conditionnelles : celles avec « If - Then » et celles avec « Select Case - End Select »

III-B-1. Avec « If -Then »▲

If condition 1 vraie Then
    'exécuter instructions
Else 
    'exécuter autres intructions
End If

'Exemple 
Dim code As Integer = 1739
 
If code = 1739 Then
     MsgBox("condition vraie")
Else
     MsgBox("condition fausse")
End If

If Not A=B Then MsgBox("A est différent de B") 'Si A et B sont différents (Not A=B signifie NON égaux) afficher "A est différent de B".

If A=B And C=D Then..    'Si A égal B et si C égal D

'Exemple
If condition_1 vraie Then
      If condition_2 vraie Then
             MsgBox("Condition_1 Vraie et Condition_2 Vraie")
      Else
            If condition_3 Vraie Then
                  MsgBox("Condition_1 Vraie et Condition_2 Fausse et Condition_3 Vraie")
            End If
      End If
End If

If Condition1 vraie Then
    ..
ElseIf condition2 Then 'sinon on teste la condition 2
    ..
ElseIf condition3 Then 'la condition 3
    ..
End If

III-B-2. Avec « Select Case - End Select »▲

Select Case X
    Case 1 : 'faire Y
    Case 2 : 'faire Z
    Case Else : 'faire A
End Select

Select Case code
    Case 1 : 'se connecter
    Case 2 : 'se déconnecter
    Case Else : 'erreur code non reconnu
End Select

'Exemple avec les virgules
Select Case N
    Case 8, 9, 10
        'Effectuer le code  si N=8 ou N=9 ou N=10
End Select
'Exemple avec une plage de valeurs
Select Case N
    Case 8 To 20
       'Effectuer le code  si N est dans la plage 8 à 20
End Select
'Exemple avec un opérateur de comparaison
Select Case N
     Case Is >= 15
         'Effectuer le code  si N supérieur ou égal à 15.
End Select
Select Case N
     Case 3 To 6, 7 To 15, 200, 1654, Is > MaxNumber
         'Effectuer le code si N, compris entre 3 et 15, si N = 200 ou N = 1654, est supérieur à MaxNumber
End Select
Select Case N
     Case "ttt", "bbb" To "eee", Nombre
          'Effectuer le code si N ="ttt" ou si N est compris entre "bbb" et "eee" (ordre alphabétique) ou si N = Nombre
End Select

Les boucles permettent de répéter un bloc d'instruction autant de fois qu'on l'a indiqué à la boucle. Elles sont très utilisées par exemple pour faire des calculs itératifs (Méthode d'Euler) ou de lister le contenu d'un tableau. Il en existe quatre types majeurs : celles avec « For - Next », celles avec « Do - Loop », celles avec « While - End While » et celles avec « For Each - Next »

III-C-1. Avec « For - Next »▲

For Variable = Debut To Fin
   'Execute la boucle
Next Variable

'Exemple de boucle
Dim i As Integer
For i = 3 To 10
   'Exécute la boucle pour i variant de 3 à 10
Next i

'Exemple de boucle
Dim i As Integer
For i = 3 To 10 Step 2
    MsgBox(i.ToString) 'affiche 3 puis 5 puis 7 et enfin 9
Next i

'Exemple
For Test As Integer = 0 To 43
    'boucle de 0 à 43
Next

'Exemple de sortie de boucle
For Test As Integer = 0 To 43
    If Test = 3 then Exit For 'Quand Test sera égale à 3 alors on sort…
Next

III-C-2. Avec « Do - Loop »▲

Do
   'Instructions
Loop Until Condition

Do
   'Instructions
Loop While Condition

'Exemple avec Until
Dim i As Integer = 0
Do
   i = i + 1 'incrémente i de 1
   MsgBox(i.ToString) 'affiche la valeur de i
Loop Until i = 10 'Quand i = 10 on sort de la boucle.

'Exemple avec While
Dim Fichier As String
Do
   'Liste les fichiers d'un répertoire
Loop While Fichier <> "NomDeMonFichier " 'Tant que Fichier n'est pas égal à NomDeMonFichier alors on boucle sinon on sort.

III-C-3. Avec « While - End While »▲

While Condition
    'Execute la boucle
End While

'Exemple :
Dim Compteur As Integer = 0
While Compteur < 20 'Dès que Compteur = 20, on sort de la boucle.
   Compteur = Compteur + 1 'incrémente le compteur de 1
   Msgbox(Compteur.ToString) 'affiche le compteur
End While

III-C-4. Avec « For Each - Next »▲

For Each Item In Collection
   'boucle
Next Item

'Exemple
Dim Var_Item As String
For Each Item As Object In MonTableau
    Var_Item = Var_Item + Item 'Var_Item va contenir tous les éléments du tableau en admettant que le tableau soit déjà remplit.
Next Item

'Autre exemple
Dim Chaine As String = "Toto va bien"
Dim Caractere As String
For Each Caractere In Chaine
    Msgbox(Caractere.ToString) 'affiche chaque caractère de Chaine
Next

Pour travailler avec les variables, on utilise des opérateurs. Il en existe de trois sortes : les opérateurs d'arithmétiques et de concaténation (mise bout à bout de chaine de caractères), les opérateurs de logiques et les opérateurs de comparaisons.

III-D-1. Les opérateurs d'arithmétique et de concaténation▲

'Exemples
Dim x, y, Somme As Single
X = 10
Y = 15.4
Somme = X + Y 'Somme retourne 25,4

Dim Revenu, Taxes, Revenu_Reel As Integer
Revenu = 2000
Taxes = 2500
Revenu_Reel = Revenu - Taxes 'retourne -500

Dim a, b, c As Integer
a = 12
b = 3
c = a Mod b 'c = 0, car la division tombe juste donc le reste = 0

Dim Prenom, Nom, NomComplet As String
Prenom = "Florent"
Nom = "Aspic"
NomComplet = Prenom & Nom 'retourne "FlorentAspic"

III-D-2. Les opérateurs de logique▲

'Exemples
Dim a, b As Integer
Dim Var, Var_1 As String
a = 13
b = - 15
Var = "Cool"
Var_1 = "Snif"

If (a Or b) < 0 Then
   'Évalue la condition si a ou b est négative : ici c'est Vrai
End If 

If (a And b) > 0 Then
   'Évalue la condition si a et b sont positifs : ici c'est Faux
End If

If Not Var = Var_1 Then
    'Évalue la condition si Var est différent de Var_1 : Ici c'est Vrai
End If

III-D-3. Les opérateurs de comparaison▲

'Exemples
Dim Age, AgeMin, AgeMax As Integer
Dim EntreeBoiteDeNuit As Boolean

Age = 12
AgeMin = 16
AgeMax = 45

If AgeMin < Age AndAlso Age < AgeMax Then
    EntreeBoiteDeNuit = True 'La condition est Vraie
End If

If Age < AgeMin Then
     EntreeBoiteDeNuit = False 'La condition est Fausse
End If

If Age = AgeMin then
    EntreeBoiteDeNuit = True 'La condition est Vraie
End If

If Age >= 46 Then
    EntreeBoiteDeNuit = False 'La condition est Fausse
End If

Les constantes sont des variables qui ne peuvent pas être la cible d'une assignation. C'est-à-dire que leur valeur ne peut pas être modifiée. Pour déclarer une constante, on utilise le mot-clé « Const ». Un avantage majeur des constantes est qu'elles améliorent la lisibilité du code et son exécution.

'Exemples de constantes
Private Const Pi As Decimal = 3.14
Public Const Plat_Prefere As String = "Pates"

'Ensuite on peut les utiliser
Dim Rayon As Decimal = 5 'Soit un cercle de rayon 5
Dim AireCercle, PerimetreCercle As Decimal

AireCercle = Pi * Rayon ^ 2 
PerimetreCercle = 2 * Pi * Rayon

MsgBox(Plat_Prefere) 'Affiche mon plat préféré !!

Les énumérations sont des structures qui permettent de créer une liste de constantes. Pour cela on utilise le mot-clé « Enum »

'Exemple
Private Enum Erreur
     Logique
     Execution
     Syntaxe
     Grammataire
End Enum

'les constantes ainsi créées sont 
Erreur.Logique
Erreur.Execution
Erreur.Syntaxe
Erreur.Grammaire

Exemple concret d'utilisation des constantes :

'On crée une énumération
Enum Action
     Ajouter
     Supprimer
     Inserer
     Selectionner
End Enum
 
'Plus loin dans le code
Select Case Action
    Case Action.Ajouter 'dans ce cas on ajoute quelque chose
            'ici le bloc de code
    Case Action.Supprimer 'dans ce cas on supprime un élément
            'ici le bloc de code
    Case Action.Selectionner 'ici on sélectionne un élément
             'ici le bloc de code
    Case Action.Inserer 'ici on insère un élément dans un tableau par ex
             'ici le bloc de code
    Case Else
           MsgBox("Énumération non reconnue")
End Select

Les énumérations comme les constantes allègent le programme et le rendent plus clair.

Un tableau regroupe des éléments de même type et les rend accessibles par un indice entier. Pour créer un tableau, on procède comme ceci :

'Exemple création tableau
Dim Tableau(6) As Integer 'déclare un tableau de 7 entiers

On peut modifier des valeurs dans le tableau.

'Exemple d'assignations
Tableau(2) = 3 'assigne la valeur 3 à l'élément d'indice 2
Tableau(0)= 98 'assigne la valeur 98 à l'élément d'indice 0
Tableau(7) = 3 'provoquera une erreur, car l'indice est supérieur à 6

Le tableau contient donc :

Pour assigner un élément du tableau à une variable, on procède comme ceci :

'Affectation à une variable
Dim Var As Integer
Var = Tableau(0) 'Var contient donc 98

Pour effacer un tableau et récupérer la mémoire allouée par le tableau :

'Efface le tableau
Erase Tableau
Tableau = Nothing
'Ces deux commandes sont équivalentes.

Pour réinitialiser le tableau (remise à zéro des éléments) :

'Réinitialisation du tableau de l'index 0 au dernier index du tableau
Array.Clear(Tableau, 0, Tableau.Length)

Pour parcourir un tableau, rien de plus simple. On utilise une boucle :

'Lister les éléments d'un tableau
Dim Tableau(5) As Integer
For Each Item As Object In Tableau
     MsgBox(Item.ToString) 'affiche chaque valeur du tableau
Next Item

'une autre méthode
For i As Integer = 0 To Tableau.Length - 1
      MsgBox(tableau(i).ToString)
Next

Il existe des classes spéciales pour les tableaux 'ArrayList et SortedList', mais cela ne sera pas abordé dans ce cours.

Il en existe seulement trois types dont deux sont très répandus. Ces options permettent un meilleur codage et une meilleure compréhension du code. Le fait de les activer empêche le programmeur de faire des erreurs de logique implicites (conversions implicites ou liaisons tardives par exemple). Voilà comment les utiliser :

'Ces lignes de code doivent être écrites tout en haut de la feuille
Option Strict On 'active le mode Strict
Option Strict Off 'désactive le mode Strict
Option Explicit On 'active le mode Explicit
Option Explicit Off 'désactive le mode Explicit
Option Compare Binary 'mode binaire pour la comparaison de chaines
Option Compare Text 'mode texte pour la comparaison de chaines

'Si Option Strict Off
Dim a As Decimal = 5.987
Dim b As Integer
b = a 'a vaut 5. Il y a eu une conversion implicite de Decimal vers Integer. VB accepte.

'Si Option Strict On
Dim a As Decimal = 5.987
Dim b As Integer
b = a 'VB plante !! 
'Il faut écrire
b = CInt(a)

'Si Option Strict Off
Dim a As Object = "Toto"
Dim b As Integer
b = a.Length 'a vaut 4. Il y a eu une liaison tardive. VB accepte.

'Si Option Strict On
Dim a As Object = "Toto"
Dim b As Integer
b = a.Length 'VB plante !!
'Il faut être strict et écrire :
b = CType(a, String).Length

'Si Option Explicit Off
a = "Toto" 'a est un String
b = 13 'b est un Integer 
'VB accepte cela, mais cela est très déconseillé !
'Exemple de problèmes causés avec les déclarations implicites de variables :
Dim Var 'Déclare Var implicitement 
Varr = 10 'On croit avoir mis 10 dans Var, mais en fait on créé une nouvelle variable nommée Varr et qui vaut 10 et Var vaut toujours 0 !!

'Si Option Explicit On
a = "Toto" 'a est un String
b = 13 'b est un Integer 
'Cela est tout simplement refusé par Visual Basic…

'Option Strict Off permet n'importe quoi. C'est du Basic au mauvais sens du terme. 
'Option Strict On oblige à une grande rigueur. C'est du VB.Net

Je vous conseille de laisser Option Explicit à On, ce qui oblige à déclarer toutes les variables avant de les utiliser Dans ce cas si vous tapez le nom d'une variable non déclarée, VB.NET génère une erreur.

Ici nous sommes dans la section 'Interface utilisateur'. On va apprendre à créer des éléments pour rendre dynamiques les programmes. Sachez que cette partie est très importante, car pour rendre agréable l'utilisation de votre programme, il faut avant tout créer une belle interface.

Pour créer un élément, il faut aller dans la boite à outils à gauche dans l'IDE (Integrated Development Environment). Sélectionnez le composant à ajouter au formulaire (bouton, label…) puis positionnez-le dans le formulaire.

Les Forms sont des formulaires Windows. En programmation, on les appelle des « Windows Form ». VB.NET génère automatiquement une Form lors de la création d'un projet. Pour créer une nouvelle Form, cliquez sur 'Ajouter un formulaire' dans le menu 'Projet'. Comme chaque contrôle, les Forms possèdent des propriétés (cf tableau).

Pour afficher la boite de propriétés, cliquez sur le contrôle puis appuyez sur F4.

Tableau des propriétés les plus utilisées :

Bien sûr il existe d'autres fonctions.

La console est une fenêtre du type DOS. C'est assez archaïque comme interface, mais c'est la définition de la console. Dans une console on peut afficher uniquement du texte. Pour créer une application console, allez dans 'Fichier' puis 'Nouveau Projet' suivit de 'Application Console'.

'Exemple de lignes de code utilisant la console
Dim LigneTapee As String = Console.In.ReadLine() 'permet de lire du texte
Console.ReadLine() 'marche aussi 
Console.Out.WriteLine("Ligne à afficher") 'pour afficher du texte
Console.WriteLine 'est aussi accepté

'Petit programme en application console
Console.Out.Write("Tapez une ligne : ")
Dim LigneTapee As String = Console.In.ReadLine()
Console.Out.WriteLine("Je viens de taper : " & LigneTapee)

Le bouton est le composant le plus important puisque c'est grâce à lui que l'utilisateur pourra interagir avec le programme. Un bouton permet essentiellement de valider ou d'annuler une fonction.

Tableau des propriétés les plus utiles

Un label est un élément permettant d'informer l'utilisateur d'une chose. Par exemple, pour indiquer à l'utilisateur d'entrer son nom dans une TextBox, on utilise un 'Label'. Ils renseignent donc sur l'utilisation du programme. Un label ne peut pas être modifié par l'utilisateur.

Tableau des principales fonctions du label :

Les TextBox sont des emplacements pour accueillir du texte (d'où le nom de TextBox). Elles sont très utiles pour récupérer du texte. Par exemple dans MSN vous entrez votre login et votre mot de passe dans des TextBox prévues à cet effet. Une TextBox peut donc être modifiée par l'utilisateur.

Tableau des différentes propriétés d'une TextBox :

Les CheckBox sont des cases à cocher. Elles permettent de savoir si l'utilisateur veut ou pas activer la fonction. Il est possible aussi d'utiliser des CheckBox avec 3 états d'activation. (cf. Tableau)

Tableau des propriétés des CheckBox

Les ComboBox sont des menus déroulants. Elles permettent de choisir une option parmi plusieurs. Exemple : Quelle est ta couleur préférée ? On utilisera une ComboBox pour afficher les réponses possibles (Rouge, Bleu, Vert, Noir…)

Tableau des propriétés des ComboBox

Il existe trois types de liste : les ListBox, les ListView et les TreeView.

La ListBox est le contrôle le plus facile à maîtriser. Il permet d'ajouter en ligne des éléments. Quand on organise des dossiers ou fichiers avec Windows en mode 'Liste' on obtient le résultat dans une ListBox (voir photo).

La ListView est plus complexe, car elle permet plus de choses. En effet, on peut créer plusieurs colonnes avec différents modes (détails, icônes, grandes icônes…). Quand on organise des dossiers ou fichiers avec Windows en mode 'Détails' on obtient le résultat dans une ListView (voir photo).

La TreeView est assez dur à manipuler dans la mesure où elle représente une arborescence avec plusieurs niveaux de nœuds. Dans une TreeView, il y a un nœud racine, suivi de nœuds puis de sous nœuds, ce qui rend ce contrôle difficile d'accès aux débutants (comme je l'étais avant, je confirme que j'ai galéré avec ce contrôle !). Dans Windows, cliquez sur 'Poste de Travail' puis 'Dossiers' et vous obtenez une TreeView (voir photo).

Tableau des propriétés d'une ListBox

Tableau des propriétés d'une ListView

Tableau des propriétés d'une TreeView

Les PictureBox permettent d'afficher des images et de les redimensionner.

Tableau des propriétés d'une PictureBox

Les ProgressBar permettent de suivre l'évolution d'une application. Windows utilise de nombreuses ProgressBar (lors de la recherche d'un fichier par exemple). Pour faire fonctionner une ProgressBar, il faut spécifier une valeur pour la propriété Minimal et une autre valeur pour la propriété Maximal. Si vous souhaitez représenter un pourcentage d'avancement d'une opération, mettez 0 pour Minimum et 100 pour Maximum.

Tableau des propriétés d'une ProgressBar

Le TabControl est un outil très important et surtout bien pratique. En effet, il permet de mettre beaucoup de choses dans peu d'espace puisqu'il gère cela en onglets. Dans un TabControl, il y a des TabPages. Vous pouvez définir autant de TabPages que vous le souhaitez.

Tableau des propriétés d'un TabControl :

Les boites de dialogue sont des fenêtres utilisées par Windows pour exécuter une fonction précise. Il existe en gros cinq boites de dialogue avec chacune un rôle spécifique :

1. L'OpenFileDialog permet de demander à l'utilisateur d'ouvrir un fichier. Cela est très utile pour effectuer un transfert de fichier par exemple.
   
   
2. La FolderBrowserDialog est en fait une boite de dialogue qui permet de chercher un dossier spécifique ou un disque dur. Par exemple, pour lister le contenu d'un dossier ou d'un lecteur, on demande à l'utilisateur de choisir ce dossier ou lecteur et on utilise ce contrôle.
   
   
3. La ColorDialog est moins utilisée. Elle permet tout simplement d'affecter une couleur à un élément à partir d'une boite de couleurs prédéfinies. Utile pour changer le fond d'écran d'un programme par exemple.
   
   
4. La SaveFileDialog, comme son nom l'indique, permet tout simplement de sauvegarder un fichier.
   
   
5. Enfin la dernière est la FontDialog qui affecte une certaine police à un texte. Très pratique pour les logiciels de messagerie instantanée.
   
   

Le plus intéressant bien sûr est de récupérer dans le code la sélection de l'utilisateur. Cela est très simple :

'Exemples avec les boites de dialogues
Dim Selection As String
Dim Couleur As Color
Dim MonFont As Font

FolderBrowserDialog.ShowDialog()
Selection = FolderBrowserDialog.SelectedPath 'récupère le chemin du dossier

OpenFileDialog.ShowDialog()
Selection = OpenFileDialog.FileName 'récupère le nom et le chemin du fichier

ColorDialog.ShowDialog()
Couleur = ColorDialog.Color 'récupère la couleur sélectionnée

FontDialog.ShowDialog()
MonFont = FontDialog.Font 'récupère le font (police, taille et style)

En programmation, il existe trois types d'erreurs possibles :

1. Les erreurs de syntaxe
2. Les erreurs d'exécution
3. Les erreurs de logique

Une erreur de syntaxe naît de la mauvaise orthographe d'une commande. Si vous tapez INTEGEER au lieu de INTEGER, VB.NET n'a aucune idée de ce que INTEGEER signifie et il n'essaye même pas d'exécuter le reste du programme. Les erreurs de syntaxes sont affichées dans la liste d'erreurs. Lorsque VB.NET rencontre une erreur de syntaxe, il met gentiment dans la liste d'erreurs le mot mal orthographié pour vous montrer exactement quel est le problème. Il suffit donc de corriger l'orthographe de la commande et d'exécuter à nouveau le programme. Il suffit d'une seule erreur de syntaxe pour empêcher le programme de s'exécuter. Lorsque votre programme s'exécute finalement pour la première fois, vous savez que le programme ne possède aucune erreur de syntaxe.

Une erreur d'exécution est plus subtile qu'une erreur de syntaxe, car elle ne se produit que lorsque votre programme reçoit des données qu'il ne sait pas vraiment gérer. Un programme peut être truffé d'erreurs d'exécution, vous ne le saurez pas tant que vous n'avez pas exécuté le programme. Pour déclencher une erreur d'exécution dans votre propre vie, allez au MacDo et, lorsque l'employé vous demande ce qu'il peut faire pour vous, commandez une crêpe. Du fait que l'employé attend de vous que vous commandiez quelque chose qui fait partie du menu des MacDo, il ne saura pas vous répondre et il est probable qu'il s'ensuivra une erreur d'exécution. (C'est une image, mais c'est compréhensible.)

'Exemple d'erreur d'exécution
Dim MonTableau As New ArrayList 'déclare un tableau
MonTableau = Nothing 'détruit le tableau
MonTableau.Items.Add(" Cool ") 'provoquera une erreur d'exécution, car MonTableau n'existe plus puisqu'il vaut " nothing "

Le type de bugs le plus délicat est dû à une erreur de logique. Une erreur de logique se produit lorsque le programme ne fonctionne pas correctement parce que vous lui avez fourni de mauvaises commandes. Par exemple, si vous avez des enfants adolescents, demandez-leur de ranger leur chambre ou de faire la vaisselle. Ils s'acquitteront de la tâche, mais pas forcément de la façon prévue. Au lieu de bien nettoyer les assiettes, ils vont peut-être seulement les mettre sous l'eau froide, ou alors mettre tout leur boxon sous leurs lits… Dans ces deux situations, l'adolescent a suivi vos instructions. Vos instructions n'étaient tout simplement pas assez précises ! Un ordinateur n'est pas très différent d'un adolescent !? (douteux). S'il peut trouver une échappatoire à vos instructions, il ne s'en privera pas ! Le problème est que comme vous pensez que vous avez donné à l'ordinateur la bonne marche à suivre, vous n'avez aucune idée de pourquoi le programme ne fonctionne pas. Il faut maintenant trouver l'endroit où les instructions ne sont pas assez précises et claires. Dans le cas d'un grand programme, vous avez éventuellement à le relire entièrement ligne par ligne (quel plaisir).

Étant donné que les bugs sont inévitables et en plus invisibles à l'œil nu, il faut pouvoir les détecter puis comprendre ce qui les a provoqués afin de pouvoir les corriger. Une fois le bug localisé, il suffit de le corriger, mais attention en corrigeant un bug vous pouvez en avoir créés d'autres ! Donc je vous conseille vivement de réécrire la partie du code qui contient le bug. En d'autres termes, le débogage est loin d'être une tâche facile.

Trouver l'endroit où se cache le bug est la partie la plus difficile. Le moyen le plus simple est d'exécuter le programme ligne par ligne, mais cela reste assez fastidieux. Imaginez que votre programme comporte 10 000 lignes de code, je vous vois mal examiner les lignes une par une ! Il faut donc utiliser d'autres méthodes. Il convient de regarder la partie du programme où vous pensez que le bug est susceptible d'agir. Par exemple, si votre fichier ne s'enregistre pas correctement, l'erreur se situe dans la partie du code qui traite de l'enregistrement du fichier.

Pour combattre les bugs, on peut mettre en place un piège à erreur. Un piège à erreur indique à l'ordinateur : voici un ensemble d'instructions génériques à suivre en cas de rencontre d'un problème que tu ne sais gérer. Ces instructions génériques et simples permettent d'afficher un message à l'écran. C'est toujours mieux que faire planter l'ordinateur !

'Exemple de piège à erreur dans VB.NET
Try 'Ouvre le piège
   Dim a As Integer = 30
   Dim b As Integer = 0
 
   Dim Resultat As Decimal = a / b

   Call CalculerPi()
Catch Ex As Exception 'Intercepte l'erreur en cas de pb
   MsgBox(Ex.ToString) 'Affiche l'erreur : Ici Division par 0 impossible
End Try 'Ferme le piège

Dans cet exemple, le programme va planter, car la division par 0 n'est pas possible en mathématiques. Lorsque le programme va exécuter la ligne du calcul du résultat de la division, le code va passer immédiatement dans le Catch et afficher le message d'erreur. Par conséquent, la fonction CalculerPi ne sera pas exécutée. Vous comprenez donc que pour tester une partie de code, il suffit de copier ce code entre le Try et le Catch. Il ne vous reste plus qu'à gérer l'erreur en l'affichant.

Il existe d'autres méthodes pour intercepter les erreurs. Par exemple, Visual Studio fournit des outils de débogage. Le pas à pas consiste à exécuter le programme ligne par ligne en s'interrompant après chaque ligne. Vous pouvez alors voir ce que le programme a réalisé et étudier le code. Si le programme fonctionne bien de la façon dont vous le voulez, c'est que la ligne est correcte. Dans le cas contraire, il y a un bug que vous venez de découvrir. Pour traverser un programme pas à pas, appuyer sur F11 pour un pas à pas détaillé : la commande pas à pas détaillé traverse la totalité du programme ligne par ligne, y compris les lignes dans les procédures du programme. L'autre option est d'utiliser un pas à pas principal en appuyant sur F10 : le programme traverse la totalité du programme, mais à chaque fois que Visual Basic rencontre une procédure, il exécute toutes les instructions dans cette procédure sans vous obliger à visionner ligne par ligne la procédure (c'est donc plus rapide).

Les commandes pas à pas détaillé et pas à pas principal commencent l'exécution au début du programme et la poursuivent jusqu'à la fin. Pour des gros programmes, cette méthode devient fastidieuse et compliquée. Pour sauter certaines parties de votre programme dont vous savez déjà qu'elles fonctionnent, vous pouvez définir des points d'arrêt. Un point d'arrêt indique à Visual Basic d'exécuter le programme jusqu'à atteindre le point d'arrêt. Pour mettre en place un point d'arrêt rien de plus simple, cliquer à gauche de la ligne où vous souhaitez insérer un point d'arrêt. Visual Basic affiche un point rouge dans la marge de gauche pour vous montrer à quelle ligne correspond le point d'arrêt. Pour supprimer un point d'arrêt, cliquer de nouveau sur la ligne dans la marge. Si vous souhaitez supprimer tous les points d'arrêt d'un seul coup, aller dans le menu déboguer puis cliquer sur effacer tous les points d'arrêt.

La dernière méthode pour intercepter les bugs est l'espionnage de variables. Cette fonction est très utile. Elle permet de vérifier la valeur d'une variable à tout moment, comme ça vous pouvez contrôler la variable. Pour ajouter un espion, vous devez d'abord déboguer le programme. Ensuite sélectionner la variable et faites un clic droit puis sélectionner Ajouter un espion. L'espion apparaît dans la fenêtre des espions. Elle affichera la valeur de la variable à chaque instant.



Pour récapituler, pour combattre un bug, il faut le localiser, puis le détruire. Pour détruire les bugs, vous disposez du pas à pas (principal ou détaillé), des points d'arrêt (pour intercepter le code à un endroit précis), des espions (pour espionner des variables) et des pièges à erreurs (pour gérer des erreurs).

Dans cet exemple, le projet dont l'Install sera généré s'appelle Hello World. Une fois votre projet ouvert et terminé de préférence, cliquez sur Fichier puis ajouter suivi de nouveau projet. Dans le volet de gauche, déroulez le menu Autres types de projets puis choisissez Configuration et déploiement. Sélectionnez ensuite dans le volet de droite, Assistant Installation

L'assistant d'installation s'ouvre. Il va vous guider à travers les étapes à suivre pour créer votre installation. La page d'accueil s'affiche. Cliquez sur Suivant

Choisissez l'option Créer un programme d'installation pour une application Windows (cochée par défaut).

Dans la fenêtre suivante, sélectionnez la sortie principale du projet. Visual Studio générera un fichier Exe pour votre application (dans certains cas cela peut être un fichier dll s'il s'agit d'un projet bibliothèque de classe). Cliquez sur Suivant.

Ici, vous pouvez ajouter des fichiers supplémentaires à votre application. Par exemple, si votre programme contient une icône, vous devez ajouter le fichier Ico manuellement via cette interface. Pour cela, cliquez sur Ajouter puis cherchez votre fichier sur votre disque dur. Idem si vous souhaitez ajouter un fichier Read Me. Une fois tous vos fichiers ajoutés, cliquez sur Suivant.

Un récapitulatif de votre installation s'affiche. Vérifiez vos choix. En cas d'erreur vous pouvez cliquer sur Précédent sinon cliquez sur Terminer.

Voilà la création de l'installation est terminée ! Mais il reste quand même à configurer quelques petites choses !

Vous apercevez un nouveau projet dans votre solution. Ceci est le projet de l'installation de l'application.

Cliquez sur Setup1 (le nom de votre installation) puis appuyez sur F4 (fenêtre propriétés).

La ligne AddRemoveProgramsIcons permet d'affecter une icône qui s'affichera lors de la désinstallation de votre programme.

Dans Author, mettez le nom de votre société ou votre propre nom.

Dans Manufacturer, mettez votre nom.

ProductName permet de donner un nom à votre programme (exemple : Hello World).

Mettez la valeur True dans RemovePreviousVersion (si vous faites des mises à jour de votre programme, l'ancien programme sera effacé lors de l'installation de la mise à jour).

ProductName permet de donner un nom à votre installation genre Installation de Hello World. Enfin dans Version, mettez le même numéro de version que dans votre programme. Exemple : Si la version de votre programme est 1.2.3 alors mettez 1.2.3 dans la case version. Cliquer sur Oui en réponse au message d'avertissement.

Le ProductCode a changé, cela est normal. En effet, pour détecter les versions d'un même programme, le programme d'installation regarde le ProductCode de l'ancienne installation. Si vous avez spécifié True dans RemovePreviousVersion alors le programme d'installation effacera automatiquement l'ancienne version (pratique non ?)



Faites un clic droit sur Setup1 et choisissez Affichage et Interface Utilisateur.

Ici, ce sont les fenêtres de votre installation qui sont référencées. Ne touchez rien dans Installation d'administration. Cliquez sur Bienvenue et faites F4. Vous pouvez ici modifier le texte de bienvenue ou alors le copyright et même ajouter une bannière. Configurez-le à votre guise ! Vous pouvez répéter l'opération pour les fenêtres Dossier d'installation, Confirmer l'installation, Progression et Terminé.

Une option intéressante est l'ajout de nouvelles fenêtres. Pour cela, choisissez la catégorie où vous souhaitez ajouter une boite de dialogue (Début, Progression ou Fin toujours dans Installer !!), faites un clic droit et sélectionnez Ajouter une boite de dialogue. Faites vos choix. Je n'expliquerai pas les différentes boites de dialogue puisqu'elles sont expliquées dans l'explorateur de Visual Studio (cliquer sur une boite de dialogue et la description apparaît en bas). De plus, les noms sont assez explicites.

Enfin, si vous souhaitez modifier l'ordre d'apparition des fenêtres lors de l'installation, clic droit sur la boite de dialogue et sélectionner Monter ou Descendre selon votre convenance.

Faites un clic droit sur Setup1 et choisissez Affichage puis Système de Fichier. Cliquez sur Dossier d'application. Dans le volet de droite, faites un clic droit sur la sortie principale du projet et sélectionner Créer un raccourci. Renommer votre raccourci puis glisser le dans Menu Programmes de l'utilisateur et dans Bureau de l'utilisateur volet de gauche). Vous l'avez déjà compris, le raccourci s'affichera sur le bureau de l'utilisateur (Bureau de l'utilisateur) et dans le menu démarrer (Menu Programmes de l'utilisateur)

Enfin, pour affecter une icône à votre raccourci, sélectionner le puis clic droit et aller dans Propriétés. Cliquez sur Aucun dans Icon et sélectionner Parcourir dans le menu déroulant. Allez chercher votre icône ou ajoutez-la si cela n'est déjà fait. Ne touchez pas aux autres propriétés.

Voilà c'est vraiment fini, c'était si dur que ça ? Maintenant, n'oubliez pas de générer votre projet. Rien de plus simple, clic droit sur Setup1 (décidément y'en a marre…) et choisissez Générer. La génération s'affiche dans la fenêtre de Sortie. La barre de statut vous informe que la génération a réussi.

Le setup est créé dans le dossier de votre solution et contient un fichier Msi et Exe. Celui que vous distribuerez à vos amis est le fichier Msi.

- Un grand merci à SpiceGuildspiceguild pour la relecture complète (sauf partie V) de ce cours !
- Merci à nlegrielnlegriel pour la correction de la partie V de ce cours.
- Un clin d'œil également à Nipnip pour ses quelques conseils bien utiles pour le cours.

- La première publication de ce cours se trouve par làzonegeeks.
- Je vous conseille d'aller jeter un coup d'œil sur l'excellent cours de PlasserreCours de Plasserre sur la Programmation vb.net Orientée Objet.
- N'hésitez pas à consulter les sourcessources et les FAQfaq si vous avez le moindre souci.
- Vous avez un souci technique et vous n'avez rien trouvé dans les ressources de developpez ? Rendez-vous sur le forum de Developpezforum de Developpez, club d'entraide des développeurs.