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 à débuter 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 chaînes 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 chaînes 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 chaînes 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çon 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.
Cette partie constitue la début de votre apprentissage en matière de programmation.

Vous apprendrez ici les bases pour stucturer vos propres applications.

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.
1.‘exemple pour créer ‘MaVoiture’ à partir de la class ‘LesVoitures’
2.Dim MaVoiture As New LesVoitures

MaVoiture a été instanciée (par le mot clé ‘new’). Utilisons quelques propriétés de MaVoiture :
1.‘propriétés de MaVoiture
2.MaVoiture.Couleur = « Bleue » ‘la couleur est bleue
3.MaVoiture.Phares = 2 ‘elle possède 2 phares

NB : Les chaines de caractères (texte comme ‘Bleue’) sont entre guillemets. Les nombres ne sont pas entre guillemets.
MaVoiture possède aussi des méthodes. Par exemple, elle roule : c’est une méthode.
1.‘Méthode de MaVoiture
2.MaVoiture.Roule() ‘la voiture roule

Dans cet exemple, MaVoiture est un objet, Roule est une méthode et 100 est un entier (Integer).
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.
1.‘Méthode avec paramètre
2.MaVoiture.Roule(100) ‘MaVoiture va rouler à 100 Km/h

On peut aussi fournir plusieurs paramètres :
1.‘Méthodes avec plusieurs paramètres
2.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.
1.‘Evenement de MaVoiture
2.MaVoiture.Roule(100, avant) ‘Ici elle va rouler à 100 Km/h en avant !
3.‘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.
1.Dim A As Integer ‘est une instruction (de déclaration)
2.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 ‘:’
1.Dim B As String : B= »Bonjour »

Si une ligne est très longue, on peut passer à la ligne grâce à ‘ _’
1.Dim B As String = « Bonjour monsieur « : C= _
2.« le professeur »
3.‘Equivaut à
4.Dim B As String = « Bonjour monsieur « : C= « le professeur »

Quand un programme tourne, les instructions sont effectuées ligne après ligne.
1.1 : Dim B As String
2.2 : B= »Bonjour »
3.3 : Dim A As Integer
4.4 : A= 3
5.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 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é.
1.‘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.
1.‘Exemple de sub
2.Sub DemarrerProgramme()
3. ‘la procédure ne retournera aucune valeur.
4.End Sub
5.
6.‘Exemple de fonction
7.Function CalculerPi()
8. ‘la fonction va retourner la valeur de PI après une série de calculs.
9.End Function

NB : Pour appeler une fonction ou un sub on utilise le mot clé Call. Il n’est pas obligatoire et est devenu inutile en .Net (c’est un reste de VB6)
1.‘Exemple d’appel de fonction ou sub
2.Call DemarrerProgramme ‘ déconseillé
3.CalculerPi() ‘OK
4.‘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
1.‘Exemple de module
2.Module NomDeMonModule
3. Sub Test1()
4. ‘Procédure 1
5. End Sub
6.
7. Function Test_1()
8. ‘Fonction 1
9. End Function
10.
11. Function Test_2()
12. ‘Fonction 2
13. End Function
14.
15. Sub Test2()
16. ‘Procédure 2
17. End Sub
18.End Module

PS : Les sub et fonctions ne peuvent pas avoir les mêmes noms sauf si le nombre de paramètres est différent.

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.

La base essentielle de tous les langages de programmation est la déclaration de variables.

En programmation, une des choses essentielle est l’utilisation des variables. Une variable est une sorte de boîte 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)
En ce qui concerne les noms des variables, on peut utiliser des majuscules, minuscules et chiffres. Les espaces et autres caractères spéciaux ne sont pas acceptés (accents, @, .).
Attention : Le nom de la variable ne peut pas commencer par un chiffre !
1.‘Exemples de noms de variables
2.MaVariable ‘est acceptée
3.COOL ‘est acceptée
4.Je_Suis_1_Variable ‘est aussi acceptée
5.2Variable ‘est refusée
6.2_Variable ‘est également refusée
7.The Variable ‘est réfutée
8.Différent ‘est aussi refusée

NB : Je vous conseille de donner des noms explicites aux variables pour ne pas vous y perdre dans le programme. De plus, mettez la première lettre de votre variable en majuscule. Si votre variable est composée de plusieurs noms, séparez les par des « _ » ou mettez une majuscule à chaque nouveau mot. (préférez la première méthode)
1.‘Exemple :
2.Variable_pour_calculer_pi
3.VariablePourCalculerPi ‘ou bien

Maintenant pour utiliser une variable, il faut avant tout la déclarer et l’instancier dans certains cas. Pour cela on utilise le mot clé Dim pour la déclarer et New pour l’instancier. De plus, il vaut lui assigner un type (Voir plus loin dans le chapitre)
1.‘Exemples de déclarations de variables
2.Dim Ma_Variable As String
3.Dim Nombre As Integer
4.Dim Compteur As Integer
5.
6.‘Instancier des variables
7.Dim Msn As New Msn_Protocol ‘Msn_Protocol est une class
8.Dim Test As New Class

On peut aussi instancier les variables précédentes comme cela :
1.‘Exemple avec les variables précédentes
2.Dim Ma_Variable As String = « toto »
3.Dim Nombre As Integer = 45
4.Dim Compteur As Integer = 1000

Une variable peut aussi être instanciée par une fonction :
1.‘Exemple de variable instanciée par une fonction
2.Dim Pi As Decimal = Fonction_pour_calculer_pi()

Il existe une multitude de types de variable. A notre niveau, on en utilisera essentiellement 4 : String, Integer, Boolean et Byte
Regroupons tous les types dans un tableau :
Type de variableMémoire occupéePlage de nombres acceptés
Boolean2 octetsTrue (1) ou False (0)
Byte1 octetDe 0 à 255
Char2 octetsDe 0 à 65 535
Date8 octetsDates entre le 1 Janvier 0001 et le 31 Décembre 9999
Decimal16 octets+ / – 79 228 162 514 264 337 593 543 950 335 sans séparateur décimal sinon + / – 7.9 228 162… avec 28 chiffres après le séparateur décimal
Double8 octets– 1,79769313486231E+308 à – 4.94065645841247E-324 (nombres négatifs) et 4.94065645841247E-324 à 1,79769313486231E+308 (nombres positifs)
Integer4 octetsDe – 2 147 483 648 à 2 147 483 647
Long8 octetsDe – 9 223 372 036 854 775 808 à 9 223 372 036 854 775 807
Short2 octetsDe – 32 768 à 32 767
Single4 octetsDe – 3.402823E-45 à – 1.401298E+38
StringVariable0 à 2 milliards de caractères Unicode
Utilisation de ces différents types de variable :
•Boolean : Retourne True ou False
•Byte : Pour lire un fichier
•Char : Pour les caractères alphanumériques
•Date : Pour les dates
•Decimal : Pour les nombre décimaux
•Double : Pour les grands nombres à virgule (avec double précision)
•Integer : Pour les nombres entiers
•Long : Pour les nombres entiers grands
•Short : Pour les nombres entiers petits
•Single : Pour les grands nombres à virgule (avec simple précision)
•String : Pour les chaînes de caractères
NB : Utiliser les types qui prennent le moins de mémoire. Par exemple, si vous souhaitez stocker une note dans votre variable, utilisez le type Integer mais n’utilisez pas le type Long dans la mesure où votre variable sera comprise entre 0 et 20 (ou 40 ou 100 en fonction des examens lol)
NB 2 : Une chaîne de caractères n’est en fait que du texte (« Je suis gentille ») et elle se met TOUJOURS entre guillemets contrairement aux nombres !
NB 3 : En VB.NET 2005 (dernière version de Microsoft), il existe 4 autres types de variables mais cela ne concerne pas notre cours.

Dans tous les langages de programmation, il peut être utile voire même nécessaire de convertir des variables d’un type dans un autre type. Cela permet d’éviter la création de nouvelles variables qui alourdiraient le programme.
Tableau récapitulatif des fonctions permettant de convertir des variables :
FonctionType
CBoolBoolean
CByteByte
CCharChar
CDateDate
CDblDouble
CDecDecimal
CIntInteger
CLngLong
CObjObject
CShortShort
CSngSingle
CStrString
1.Dim Pi As Decimal = 3.14 ‘crée la variable Pi qui vaut 3.14
2.Dim a As Integer = 15 ‘crée la variable a qui vaut 15
3.
4.Dim Pi_Entier As Integer = CInt(Pi) ‘retournera 3
5.Dim a_caractère As String = CStr(a) ‘retourner « 15 » ‘en chaîne de caractère
6.

Attention : Dans le langage VB.NET, la virgule n’existe pas. On utilise le point qui remplace la virgule.
Noter que ces fonctions sont construites à partir de C (pour Convert) et de l’abréviation du type.
Pour convertir un Object dans un type (String, Integer…), on utilise la commande CType. Exemple : CType(a, String) ‘a va être convertit en ‘String’

Une variable peut être utilisée que si elle est visible dans le programme. Pour définir le niveau de visibilité de chaque variable, il existe un mot clé propre à chaque cas.
Tableau qui recence la portée des variables :
Mot cléPortée de la variable
PublicPartout dans le programme.
PrivatePartout dans la classe ou le module où elle a été créée.
DimSeulement dans la procédure ou la fonction créée.
ProtectedLes membres Protected sont similaires aux Private, mais ils ont une particularité en cas d’héritage. Ce point ne sera pas abordé.
FriendLes membres Friend ne sont accessibles qu’à l’intérieur du projet, et pas par des éléments extérieurs au projet en cours.
SharedPermet de partager une variable. N’est pas indispensable.
NB : Ce tableau est aussi valable pour la portée des procédures et des fonctions
1.‘Exemple avec des sub et fonctions
2.Module Test_Portee
3. Private Sub Test()
4.
5. End Sub
6.
7. Protected Sub Azerty(ByVal Argument As String)
8.
9. End Sub
10.
11. Private Shared Function Calcul(ByVal Nombre As Integer)
12.
13. End Function
14.End Module

Cependant, il est déconseillé d’utiliser des variables globales (publics) car cela est une source importante d’erreurs. Pour affecter une valeur à une variable public, il est préférable de passer par une procédure d’affectation.
1.‘Exemple de procédure d’affectation
2.Module Test
3. Public Nombre As Integer
4.
5. Public Sub Routine_Qui_Va_Affecter_La_Variable(ByVal Valeur As Integer)
6. Nombre = Valeur
7. End Sub
8.End Module
9.
10.‘Quelque part d’autre dans le programme on appel la procédure avec un argument de type Integer
11.Call Routine_Qui_Va_Affecter_La_Variable(45)
12.
13.‘Ensuite dans le programme totale, la variable Nombre va valoir 45
14.MsgBox(Nombre.ToString) ‘Affiche dans une boite de dialogue la valeur

Bien sûr, il est possible de faire directement :
1.‘attention source d’erreurs
2.Nombre = 45

mais cela est source d’erreurs… En effet, vous pouvez modifier la variable à tout moment sans même vous en rendre compte ! A utiliser à vos risques et périls.

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 »

Structure générale :
1.If condition 1 vraie Then
2. ‘exécuter condition 2
3.Else
4. ‘exécuter condition 3
5.End If

•If : Mot clé signifiant  » si  » et qui ouvre la structure
•Then : Mot clé signifiant  » alors  »
•Else : Mot clé signifiant  » sinon  »
•End If : Mot clé permettant de fermer la structure
En français : Si la condition 1 est vraie alors on exécute le bloc Then sinon on exécute le bloc Else
1. ‘Exemple
2.Dim code As Integer = 1739
3.
4.If code = 1739 Then
5. MsgBox(« condition vraie »)
6.Else
7. MsgBox(« condition fausse »)
8.End If

On peut tester une condition fausse et dans ce cas utiliser Not.
1.‘Si A et B sont différent (Not A=B signifie NON égaux)
2. ‘afficher « A est différent de B ».
3.If Not A=B Then MsgBox(« A est différent de B »)

Il peut y avoir des opérateurs logiques dans la condition :
1.If A=B And C=D Then.. ‘Si A égal B et si C égal D

Des structures If – Then peuvent être imbriquées. C’est-à-dire que l’on peut emboîter plusieurs conditions dans une seule condition :
1.‘Exemple
2.If condition_1 vraie Then
3. If condition_2 vraie Then
4. MsgBox(« Condition_1 Vraie et Condition_2 Vraie »)
5. Else
6. If condition_3 Vraie Then
7. MsgBox(« Condition_1 Vraie et Condition_2 Fausse et Condition_3 Vraie »)
8. End If
9. End If
10.End If

Astuce : Pour ne pas vous trompez, utiliser les tabulations et décaler chaque structure et son code au même niveau. Pour vérifier s’il n’y a pas d’erreur, comptez les If, il doit y en avoir autant que des End If. Visual Studio vous avertira en cas d’erreur.
Autre syntaxe possible :
1.If Condition1 vraie Then
2...
3.ElseIf condition2 Then ‘sinon on teste la condition 2
4...
5.ElseIf condition3 Then ‘la condition 3
6...
7.End If

Exercice : Créer une structure permettant de sécuriser ton MSN :
•Déclare ton code secret dans une variable.
•Si le code est bon alors afficher dans une MessageBox : « Accès autorisé » sinon afficher dans cette même MessageBox : « Accès refusé »

Cette structure est très utile pour tester un grand nombre de possibilités en fonction de la valeur d’une expression :
Structure générale :
1.Select Case X
2. Case 1 : ‘faire Y
3. Case 2 : ‘faire Z
4. Case Else : ‘faire A
5.End Select

•Select Case : Mot clé permettant d’ouvrir la structure
•Case : Représente les différents cas (Case 1 = cas 1, Case 2 = cas 2, Case Else = autre cas…)
•End Select : Mot clé permettant de fermer la structure
•X : Expression à évaluer (nombre, chaîne de caractères, booléen…)
•faire Y : Exécute le cas 1
•faire Z : Exécute le cas 2
•faire A : Exécute le cas Else
Prenons un exemple : Un serveur envoie un certain code mais on ne sait pas si c’est le 1, le 2 ou un autre (comme 1000, 453, 876…) et vous voulez vous connecter si le code envoyé correspond au 1, vous déconnecter s’il correspond au 2 et afficher un message d’erreur si c’est un autre code autre que le 1 et le 2.
Voilà la structure :
1.Select Case code
2. Case 1 : ‘se connecter
3. Case 2 : ‘se déconnecter
4. Case Else : ‘erreur code non reconnu
5.End Select

La structure précédente est relativement simple mais limitée. On peut aussi utiliser d’autres types d’expressions plus complexes et plus pratiques :
Plusieurs expressions peuvent être séparées par des virgules.
•Le mot-clé To permet de définir les limites d’une plage de valeurs correspondantes pour N.
•Le mot-clé Is associé à un opérateur de comparaison (= < ou >=) permet de spécifier une restriction sur les valeurs correspondantes de l’expression. Si le mot-clé Is n’est pas indiqué, il est automatiquement inséré.
•Enfin, vous pouvez aussi indiquer des plages et des expressions multiples pour des chaînes de caractères. Dans l’exemple suivant, Case correspond aux chaînes qui sont absolument identiques à ttt, aux chaînes comprises entre bbb et eee dans l’ordre alphabétique, ainsi qu’à la valeur de Nombre :
Vous pouvez aussi mixer les différents cas précédents.
1. ‘Exemple avec les virgules
2.Select Case N
3. Case 8, 9, 10
4. ‘Effectuer le code si N=8 ou N=9 ou N=10
5.End Select
6.
7. ‘Exemple avec une plage de valeurs
8.Select Case N
9. Case 8 To 20
10. ‘Effectuer le code si N est dans la plage 8 à 20
11.End Select
12.
13. ‘Exemple avec un opérateur de comparaison
14.Select Case N
15. Case Is >= 15
16. ‘Effectuer le code si N supérieur ou égal à 15.
17.End Select
18.
19.Select Case N
20. Case 3 To 6, 7 To 15, 200, 1654, Is > MaxNumber
21. ‘Effectuer le code si N, compris entre 3 et 15, si N = 200 ou N = 1654, est supérieur à MaxNumber
22.End Select
23.
24.Select Case N
25. Case « ttt », « bbb » To « eee », Nombre
26. ‘Effectuer le code si N = »ttt » ou si N est compris entre « bbb » et « eee » (ordre alphabétique) ou si N = Nombre
27.End Select

Exercice : Reprendre le même exercice que précédemment (avec IF…Then…Else) mais en changeant la structure.

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 pour faire des calculs itératifs (Méthode d’Euler) ou pour 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 »

Structure générale :
1.For Variable = Debut To Fin
2. ‘Execute la boucle
3.Next Variable

•For : Mot-clé permettant d’ouvrir la boucle.
•To : Mot-clé signifiant Jusqu’à.
•Next : Mot-clé pour fermer la boucle.
•Variable : Variable qui va servir de compteur pour la boucle.
•Debut : Début du compteur.
•Fin : Fin du compteur.
1.‘Exemple de boucle
2.Dim i As Integer
3.For i = 3 To 10
4. ‘Exécute la boucle pour i variant de 3 à 10
5.Next i

La variable i va s’incrémenter automatiquement de 1 à la fin de chaque boucle.
On peut aussi définir un pas, le compteur s’incrémente de la valeur du pas à chaque boucle :
1.‘Exemple de boucle
2.Dim i As Integer
3.For i = 3 To 10 Step 2
4. MsgBox(i.ToString) ‘affiche 3 puis 5 puis 7 et enfin 9
5.Next i

NB : On peut aussi utiliser un pas négatif mais cela est plus compliqué.
La variable de la boucle peut être déclarée en même temps que la boucle. De plus, la variable après le Next est facultative.
1.‘Exemple
2.For Test As Integer = 0 To 43
3. ‘boucle de 0 à 43
4.Next

Dernière chose, on peut quitter la boucle prématurément :
1.‘Exemple de sortie de boucle
2.For Test As Integer = 0 To 43
3. If Test = 3 then Exit For ‘Quand Test sera égale à 3, on sort…
4.Next

Structure générale :
1.Do
2. ‘Instructions
3.Loop Until Condition
4.
5.Do
6. ‘Instructions
7.Loop While Condition

•Do : Mot-clé qui ouvre la boucle.
•Loop : Mot-clé qui ferme la boucle.
•While : Mot-clé qui signifie Tant que.
•Until : Mot-clé qui signifie Jusqu’à ce que.
•Condition : La condition pour rester dans un Loop While ou pour sortir d’un Loop Until.
Attention : Le premier élément d’un tableau est toujours à l’indice 0.
Le dernier élément d’un tableau est toujours à l’indice Length – 1 (dans l’exemple 7 – 1 = 6)
1.‘Exemple avec Until
2.Dim i As Integer = 0
3.Do
4. i = i + 1 ‘incrémente i de 1
5. MsgBox(i.ToString) ‘affiche la valeur de i
6.Loop Until i = 10 ‘Quand i = 10 on sort de la boucle.
7.
8.
9.‘Exemple avec While
10.Dim Fichier As String
11.Do
12. ‘Liste les fichiers d’un répertoire
13.Loop While Fichier « NomDeMonFichier » ‘Tant que Fichier n’est pas égal à NomDeMonFichier alors on boucle sinon on sort.

Structure générale :
1.While Condition
2. ‘Execute la boucle
3.End While

•While : Mot-clé permettant d’ouvrir la boucle.
•End While : Mot-clé qui ferme la boucle.
•Condition : La condition pour rester dans la boucle.

Structure générale :
1.For Each Item In Collection
2. ‘boucle
3.Next Item

•For : Mot-clé pour ouvrir la boucle.
•Each : Mot-clé signifiant Chaque.
•In : Mot-clé signifiant Dans.
•Next : Mot-clé pour fermer la boucle.
•Item : Objet à récupérer dans la collection.
•Collection : Tableau qui contient des Objets.
1.‘Exemple
2.Dim Var_Item As String
3.For Each Item As Object In MonTableau
4. Var_Item = Var_Item + Item ‘Var_Item va contenir tous les éléments du tableau en admettant que le tableau soit déjà remplit.
5.Next Item
6.
7.‘Autre exemple
8.Dim Chaine As String = “Toto va bien”
9.Dim Caractere As String
10.For Each Caractere In Chaine
11. Msgbox(Caractere.ToString) ‘affiche chaque caractère de Chaine
12.Next

La structure For Each – Next est donc très utile pour tester une chaîne de caractère.

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 chaîne de caractères), les opérateurs de logiques et les opérateurs de comparaisons.

OpérateurOpération réalisée par l’opérateur
+Additionne deux nombres
–Soustrait deux nombres
*Multiplie deux nombres
/Divise deux nombres et retourne un nombre à virgule flottante (décimal)
Divise deux nombres et retourne un entier
Mod (ou Modulo)Divise deux nombres et retourne seulement le reste
^Elève à la puissance un nombre
&Additionne (concatène) deux chaînes
1. ‘Exemples
2.Dim x, y, Somme As Single
3.X = 10
4.Y = 15.4
5.Somme = X + Y ‘Somme retourne 25,4
6.
7.Dim Revenu, Taxes, Revenu_Reel As Integer
8.Revenu = 2000
9.Taxes = 2500
10.Revenu_Reel = Revenu – Taxes ‘retourne -500
11.
12.Dim a, b, c As Integer
13.a = 12
14.b = 3
15.c = a Mod b ‘c = 0 car la division tombre juste donc le reste = 0
16.
17.Dim Prenom, Nom, NomComplet As String
18.Prenom = « Florent »
19.Nom = « Aspic »
20.NomComplet = Prenom & Nom ‘retourne « FlorentAspic »

Les opérateurs de logique manipulent des valeurs True ou False.
OpérateurSyntaxeEmploi
And (et)Var_1 And Var_2True si Var_1 et Var_2 sont vraies
Or (ou)Var_1 Or Var_2True si une des deux est vraie
Xor (ou exclusif)Var_1 Xor Var_2True si une et une seule est vraie
Not (non)Not VarTrue si Var est faux et vice versa
1. ‘Exemples
2.Dim a, b As Integer
3.Dim Var, Var_1 As String
4.a = 13
5.b = – 15
6.Var = « Cool »
7.Var_1 = « Snif »
8.
9.If (a Or b) < 0 Then
10. ‘Evalue la condition si a ou b est négative : ici c’est Vrai
11.End If
12.
13.If (a And b) > 0 Then
14. ‘Evalue la condition si a et b sont positifs : ici c’est Faux
15.End If
16.
17.If Not Var = Var_1 Then
18. ‘Evalue la condition si Var est différent de Var_1 : Ici c’est Vrai
19.End If

Les opérateurs de comparaison comparent deux nombres ou chaînes pour voir si ces nombres ou chaînes sont égaux, différents, supérieurs ou inférieurs.
OpérateurSignification
> Strictement supérieur à
< Strictement inférieur à
>=Supérieur ou égal à
= 46 Then
22. EntreeBoiteDeNuit = False ‘La condition est Fausse
23.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.
1. ‘Exemples de constantes
2.Private Const Pi As Decimal = 3.14
3.Public Const Plat_Prefere As String = « Pates »
4.
5. ‘Ensuite on peut les utiliser
6.Dim Rayon As Decimal = 5 ‘Soit un cercle de rayon 5
7.Dim AireCercle, PerimetreCercle As Decimal
8.
9.AireCercle = Pi * Rayon ^ 2
10.PerimetreCercle = 2 * Pi * Rayon
11.
12.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
1. ‘Exemple
2.Private Enum Erreur
3. Logique
4. Execution
5. Syntaxe
6. Grammaire
7.End Enum
8.
9. ‘les constantes ainsi créées sont
10.Erreur.Logique
11.Erreur.Execution
12.Erreur.Syntaxe
13.Erreur.Grammaire
14.
15. ‘Exemple concret d’utilisation des constantes :
16. ‘On crée une énumération
17.Enum Action
18. Ajouter
19. Supprimer
20. Inserer
21. Selectionner
22.End Enum
23.
24. ‘Plus loin dans le code
25.Select Case Action
26. Case Action.Ajouter ‘dans ce cas on ajoute quelque chose
27. ‘ici le bloc de code
28. Case Action.Supprimer ‘dans ce cas on supprime un élément
29. ‘ici le bloc de code
30. Case Action.Selectionner ‘ici on sélectionne un élément
31. ‘ici le bloc de code
32. Case Action.Inserer ‘ici on insère un élément dans un tableau par ex
33. ‘ici le bloc de code
34. Case Else
35. MsgBox(« Enumération non reconnue »)
36.End Select

Les énumérations comme les constantes allègent le programme et le rende 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 :
1.‘Exemple création tableau
2.Dim Tableau(6) As Integer ‘déclare un tableau de 7 entiers

Attention : Les index d’un tableau commencent toujours à 0. Le premier élément dans un tableau est toujours à l’indice 0. (dans l’exemple 6) + 1 = 7
On peut modifier des valeurs dans le tableau :
1.‘Exemple d’ajout de valeurs
2.Tableau(2) = 3 ‘assigne pour l’indice 2 la valeur de 3
3.Tableau(0)= 98 ‘assigne pour l’indice 0 la valeur de 98
4.Tableau(7) = 3 ‘provoquera une erreur car l’indice est supérieur à 6

Le tableau contient donc les valeurs suivantes :
98
0
3
0
0
0
0
Pour assigner un élément du tableau à une variable, on procède comme ceci :
1. ‘Affectation à une variable
2.Dim Var As Integer
3.Var = Tableau(0) ‘Var contient donc 98

Pour effacer un tableau et récupérer la mémoire allouée par le tableau :
1. ‘Efface le tableau
2.Erase Tableau
3.Tableau = Nothing
4. ‘Ces deux commandes sont équivalentes.

Pour réinitialiser le tableau (remise à zéro des éléments) :
1.‘Réinitialisation du tableau de l’index 0 au dernier index du tableau
2.Array.Clear(Tableau, 0, Tableau.Length)

Pour parcourir un tableau, rien de plus simple. On utilise généralement une boucle :
1. ‘Lister les éléments d’un tableau
2.Dim Tableau(5) As Integer
3.For Each Item As Object In Tableau
4. MsgBox(Item.ToString) ‘affiche chaque valeur du tableau
5.Next Item
6.
7. ‘une autre méthode
8.For i As Integer = 0 To Tableau.Length – 1
9. MsgBox(tableau(i).ToString)
10.Next

Il existe une classe spéciale pour les tableaux ArrayList et SortedList.

Il existe seulement trois types d’option de codage dont deux sont très utilisés. 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 :
1. ‘Ces lignes de code doivent être écrites tout en haut de la feuille
2.Option Strict On ‘active le mode Strict
3.Option Strict Off ‘désactive le mode Strict
4.Option Explicit On ‘active le mode Explicit
5.Option Explicit Off ‘désactive le mode Explicit
6.Option Compare Binary ‘mode binaire pour la comparaison de chaînes
7.Option Compare Text ‘mode texte pour la comparaison de chaînes
8.
9. ‘Si Option Strict Off
10.Dim a As Decimal = 5.987
11.Dim b As Integer
12.b = a ‘a vaut 5. Il y a eu une conversion implicite de Decimal vers Integer. VB accepte.
13.
14. ‘Si Option Strict On
15.Dim a As Decimal = 5.987
16.Dim b As Integer
17.b = a ‘VB plante !!
18. ‘Il faut écrire
19.b = CInt(a)
20.
21. ‘Si Option Strict Off
22.Dim a As Object = « Toto »
23.Dim b As Integer
24.b = a.Length ‘a vaut 4. Il y a eu une liaison tardive. VB accepte.
25.
26. ‘Si Option Strict On
27.Dim a As Object = « Toto »
28.Dim b As Integer
29.b = a.Length ‘VB plante !!
30. ‘Il faut être strict et écrire :
31.b = CType(a, String).Length
32.
33. ‘Si Option Explicit Off
34.a = « Toto » ‘a est un String
35.b = 13 ‘b est un Integer
36. ‘VB accepte cela mais cela est très déconseillé !
37.
38. ‘Exemple de problèmes causés avec les déclarations implicites de variables :
39.Dim Var ‘Déclare Var implicitement
40.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 !!
41.
42. ‘Si Option Explicit On
43.a = « Toto » ‘a est un String
44.b = 13 ‘b est un Integer
45. ‘Cela est tout simplement refusé par Visual Basic.

Option Strict Off permet de faire 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.
Par défaut, l’Option Explicit est activée et l’Option Strict désactivée. En revanche, les deux options sont désactivées par défaut sous Visual Basic 2003 !

Désormais, vous connaissez toutes les bases de la programmation orientée objet (POO). Vous êtes enfin prêt à créer vous propres applications !
Pour vous aidez à faire des applications attractives et fonctionnelles… rendez vous dans les prochains chapitres…
Ici nous sommes dans la section Interface utilisateur. On va apprendre à créer des éléments pour rendre dynamique 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 contrôles présentés dans ce chapitre sont des contrôles de Visual Basic .NET Version 2005 (Framework 2.0). Il se peut que certaines propriétés n’existent pas avec la version 2003 de VB.NET.

Donc ne vous affolez pas si toutes les propriétés des tableaux ci-dessous n’apparaissent pas pour les différents composants de la boîte à outils.

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, aller dans Fichier puis Nouveau Projet suivit Application Console.
1.‘Exemple de lignes de code utilisant la console
2.Dim LigneTapee As String = Console.In.ReadLine() ‘permet de lire du texte
3.Console.ReadLine() ‘marche aussi
4.Console.Out.WriteLine(« Ligne à afficher ») ‘pour afficher du texte
5.Console.WriteLine ‘est aussi accepté
6.
7.‘Petit programme en application console
8.Console.Out.Write(« Tapez une ligne : « )
9.Dim LigneTapee As String = Console.In.ReadLine()
10.Console.Out.WriteLine(« Je viens de taper :  » & LigneTapee)

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 boîte de propriétés, cliquez sur le contrôle puis appuyez sur F4.
Tableau des propriétés d’une Form :
PropriétéDescription
BackColorDéfinit l’arrière plan du contrôle
BackGroundImageL’image en arrière plan du contrôle
CursorPermet de changer le curseur lors du passage
FontLa font (police) utilisée dans le contrôle
ForeColorLa couleur du premier plan pour le texte
FormBorderStyleComportement de la form (bordure et barre de titre)
TextLe titre de la form
AllowDropIndique si on autorise le glisser / coller
ContextMenuStripAssocie un menu contextuel au contrôle
EnabledIndique si le contrôle est activé ou pas
NameLe nom du contrôle utilisé dans le codage
SizeLa taille du contrôle en pixels
WindowsStateL’état de la form au démarrage (minimize…)
AcceptButtonLe bouton d’acceptation du formulaire
CancelButtonLe bouton d’annulation du formulaire
ControlBoxIndique si le menu système est activée ou pas
HelpButtonIndique si le bouton d’aide est activé ou pas
IconDéfinit l’icône du contrôle
MainMenuStripDéfinit le menu principal du formulaire
MaximizeBoxIndique si le bouton d’agrandissement est activé
ShowIconIndique si l’icône est visible
ShowInTaskBarIndique si le formulaire est visible dans la TaskBar
TopMostIndique si le formulaire est au premier plan
Bien sûr il existe d’autres fonctions…

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 d’un bouton :
PropriétéDescription
BackColorDéfinit l’arrière plan du contrôle
BackGroundImageL’image en arrière plan du contrôle
CursorPermet de changer le curseur lors du passage de la souris
FlatStyleLe style du bouton
FontLa font (police) utilisée dans le contrôle
ForeColorLa couleur du premier plan pour le texte
TextLe texte du bouton
TextAlignL’alignement du texte du bouton
AllowDropIndique si on autorise le glisser / coller
ContextMenuStripAssocie un menu contextuel au contrôle
EnabledIndique si le contrôle est activé ou pas
VisibleIndique si le contrôle est visible ou pas
NameLe nom du contrôle utilisé dans le codage
SizeLa taille du contrôle en pixels
AutoSizeDéfinit si le contrôle est dimensionné automatiquement

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 propriétés d’un Label :
PropriétéDescription
BackColorDéfinit l’arrière plan du contrôle
ImageL’image affichée sur le label
CursorPermet de changer le curseur lors du passage de la souris
FlatStyleLe style du bouton
FontLa font (police) utilisée dans le contrôle
ForeColorLa couleur du premier plan pour le texte
TextLe texte du bouton
TextAlignL’alignement du texte du bouton
AllowDropIndique si on autorise le glisser / coller
ContextMenuStripAssocie un menu contextuel au contrôle
EnabledIndique si le contrôle est activé ou pas
VisibleIndique si le contrôle est visible ou pas
NameLe nom du contrôle utilisé dans le codage
SizeLa taille du contrôle en pixels
AutoSizeDéfinit si le contrôle est dimensionné automatiquement

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 vôtre login et vôtre mot de passe dans des TextBox prévues à cet effet. Une TextBox peut donc être modifiée par l’utilisateur.
Tableau des propriétés d’une TextBox :
PropriétéDescription
BackColorDéfinit l’arrière plan du contrôle
CursorPermet de changer le curseur lors du passage de la souris
FontLa font (police) utilisée dans le contrôle
ForeColorLa couleur du premier plan pour le texte
TextLe texte initial visible dans la TextBox
TextAlignL’alignement du texte
ContextMenuStripAssocie un menu contextuel au contrôle
EnabledIndique si le contrôle est activé ou pas
MaxLengthIndique le nombre maximal de caractères dans la TextBox
MultilineIndique si la TextBox est multi ligne ou pas
PasswordCharCaractère à afficher pour la saisie du mot de passe
ReadOnlyIndique si la TextBox est en lecture seule
VisibleIndique si le contrôle est visible ou pas
NameLe nom du contrôle utilisé dans le codage
SizeLa taille du contrôle en pixels
AllowDropIndique si on autorise le glisser / coller

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 d’une CheckBox :
PropriétéDescription
AppearanceIndique l’apparence du contrôle
BackColorDéfinit l’arrière plan du contrôle
BackGroundImageL’image en arrière plan du contrôle
CheckAlignEmplacement de la case à cocher
CheckedIndique si la case est cochée
CheckStateIndique l’état de la case à cocher
CursorPermet de changer le curseur lors du passage de la souris
FlatStyleLe style du bouton
FontLa font (police) utilisée dans le contrôle
ForeColorLa couleur du premier plan pour le texte
TextLe texte de la CheckBox
TextAlignL’alignement du texte
AllowDropIndique si on autorise le glisser / coller
AutoCheckIndique si la case se coche automatiquement
ContextMenuStripAssocie un menu contextuel au contrôle
EnabledIndique si le contrôle est activé ou pas
ThreeStateIndique si la case à 3 états d’activation
VisibleIndique si le contrôle est visible ou pas
NameLe nom du contrôle utilisé dans le codage
SizeLa taille du contrôle en pixels

Les RadioButton sont identiques aux CheckBox. Cependant il ne peut y avoir qu’un seul RadioButton activé contrairement aux CheckBox où il peut y avoir autant de cases cochées que de CheckBox. Les propriétés sont identiques aux CheckBox. La seule différence est que les propriétés ‘CheckState’ et ‘ThreeState’ n’existent pas.

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 d’une ComboBox :
PropriétéDescription
BackColorDéfinit l’arrière plan du contrôle
CursorPermet de changer le curseur lors du passage de la souris
DropDownStyleApparence de la zone du menu déroulant
FlatStyleLe style de la ComboBox
FontLa font (police) utilisée dans le contrôle
ForeColorLa couleur du premier plan pour le texte
TextLe texte de la ComboBox
AllowDropIndique si on autorise le glisser / coller
ContextMenuStripAssocie un menu contextuel au contrôle
DrawModeIndique si le code gère le dessin des éléments de la liste
EnabledIndique si le contrôle est activé ou pas
SortedIndique comment sont triés les éléments de la liste
VisibleIndique si le contrôle est visible ou pas
NameLe nom du contrôle utilisé dans le codage
SizeLa taille du contrôle en pixels
ItemsPermet d’ajouter les éléments dans la liste déroulante
TagDonnées définies par l’utilisateur associées à l’objet

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, icones, grandes icones.). 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 nouds. Dans une TreeView, il y a un noud racine, suivit de nouds puis de sous-nouds, ce qui rend ce contrôle difficile d’accès aux débutants (comme je l’étais avant. Je confirme avoir galéré à utiliser 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 :
PropriétéDescription
BackColorDéfinit l’arrière plan du contrôle
CursorPermet de changer le curseur lors du passage de la souris
FontLa font (police) utilisée dans le contrôle
ForeColorLa couleur du premier plan pour le texte
AllowDropIndique si on autorise le glisser / coller
DrawModeIndique si le code gère le dessin des éléments de la liste
ContextMenuStripAssocie un menu contextuel au contrôle
MultiColumnIndique comment doivent être affichées les données
SortedIndique comment sont triés les éléments de la liste
VisibleIndique si le contrôle est visible ou pas
NameLe nom du contrôle utilisé dans le codage
SizeLa taille du contrôle en pixels
ItemsPermet d’ajouter les éléments dans la ListBox
TagDonnées définies par l’utilisateur associées à l’objet
EnabledIndique si le contrôle est activé ou pas
Tableau des propriétés d’une ListView :
PropriétéDescription
BackColorDéfinit l’arrière plan du contrôle
BackGroundImageL’image en arrière plan du contrôle
BorderStyleIndique le style de la bordure de la ListView
CursorPermet de changer le curseur lors du passage de la souris
CheckBoxesIndique si des CheckBox sont visibles à coté des éléments
FontLa font (police) utilisée dans le contrôle
ForeColorLa couleur du premier plan pour le texte
FullRowSelectIndique si toute la ligne est sélectionnée
GridLinesAffiche un quadrillage autour des éléments en mode détails
ViewDéfinit la vue dans laquelle les éléments seront affichés
AllowDropIndique si on autorise le glisser / coller
ColumnsGère les colonnes de la ListView
ContextMenuStripAssocie un menu contextuel au contrôle
ItemsGère les éléments de la ListView
SortingIndique comment sont triés les éléments de la liste
VisibleIndique si le contrôle est visible ou pas
NameLe nom du contrôle utilisé dans le codage
SizeLa taille du contrôle en pixels
TagDonnées définies par l’utilisateur associées à l’objet
EnabledIndique si le contrôle est activé ou pas
Tableau des propriétés d’une TreeView :
PropriétéDescription
BackColorDéfinit l’arrière plan du contrôle
BorderStyleIndique le style de la bordure de la TreeView
CursorPermet de changer le curseur lors du passage de la souris
CheckBoxesIndique si des CheckBox sont visibles à coté des éléments
FontLa font (police) utilisée dans le contrôle
ForeColorLa couleur du premier plan pour le texte
AllowDropIndique si on autorise le glisser / coller
ContextMenuStripAssocie un menu contextuel au contrôle
DrawModeIndique si le code gère le dessin des éléments de la liste
FullRowSelectIndique si la surbrillance s’étend sur la largeur du TreeView
NodesGère l’ensemble des nœuds du contrôle TreeView
VisibleIndique si le contrôle est visible ou pas
NameLe nom du contrôle utilisé dans le codage
SizeLa taille du contrôle en pixels
TagDonnées définies par l’utilisateur associées à l’objet
EnabledIndique si le contrôle est activé ou pas

Les PictureBox permettent d’afficher des images et de les redimensionner.
Tableau des propriétés d’une PictureBox :
PropriétéDescription
BackColorDéfinit l’arrière plan du contrôle
BackGroundImageL’image en arrière plan du contrôle
CursorPermet de changer le curseur lors du passage de la souris
ImageL’image a affichée dans la PictureBox
ErrorImageIcone à afficher lorsque le chargement d’une image échoue
InitialImageImage à afficher pendant le chargement d’une autre image
ContextMenuStripAssocie un menu contextuel au contrôle
EnabledIndique si le contrôle est activé ou pas
SizeModeManière dont l’image va être redimensionnée
VisibleIndique si le contrôle est visible ou pas
NameLe nom du contrôle utilisé dans le codage
SizeLa taille du contrôle en pixels

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 marcher 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 :
PropriétéDescription
BackColorDéfinit l’arrière plan du contrôle
CursorPermet de changer le curseur lors du passage de la souris
ForeColorLa couleur du premier plan pour le texte
MaximumLimite supérieure de la plage que la ProgressBar utilise
MinimumLimite inférieure de la plage que la ProgressBar utilise
StyleDéfinit le style de la ProgressBar
ValueValeur actuelle pour la ProgressBar
ContextMenuStripAssocie un menu contextuel au contrôle
VisibleIndique si le contrôle est visible ou pas
NameLe nom du contrôle utilisé dans le codage
SizeLa taille du contrôle en pixels
TagDonnées définies par l’utilisateur associées à l’objet
EnabledIndique si le contrôle est activé ou pas
NB : Dans Visual Studio 2005, le mode Marquee (comme style) est disponible pour la ProgressBar. Il permet de faire défiler une barre de gauche à droite comme lors du chargement de windows XP. Ce mode est utilisé dans le cas où vous ne connaissez pas la durée d’un processus. (Exemple : le chargement d’une application peut prendre plus ou moins de temps en fonction du processeur (UC) ).

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 :
PropriétéDescription
CursorPermet de changer le curseur lors du passage de la souris
FontLa font (police) utilisée dans le contrôle
ImageListObjet qui permet de contenir des images pour les onglets
AllowDropIndique si on autorise le glisser / coller
DrawModeIndique si l’utilisateur ou le système peint les légendes
HotTrackIndique si l’aspect des onglets change lors du survol de la souris
ContextMenuStripAssocie un menu contextuel au contrôle
MultiLineIndique si plusieurs lignes d’onglets sont autorisées
SizeModeIndique la façon dont les onglets sont redimentionnés
TabPagesLa liste des TabPages contenus dans le TabControl
VisibleIndique si le contrôle est visible ou pas
NameLe nom du contrôle utilisé dans le codage
SizeLa taille du contrôle en pixels
TagDonnées définies par l’utilisateur associées à l’objet
EnabledIndique si le contrôle est activé ou pas

Les boîtes de dialogue sont des fenêtres utilisées par Windows pour exécuter une fonction précise. Il existe en gros cinq boîtes de dialogue avec chacune un rôle spécifique :
•L’OpenFileDialog permet de demander à l’utilisateur d’ouvrir un fichier. Cela est très utile pour effectuer un transfert de fichier par exemple.
•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.
•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.
•La SaveFileDialog, comme son nom l’indique, permet tout simplement de sauvegarder un fichier.
•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 :
1. ‘Exemples avec les boîtes de dialogues
2.Dim Selection As String
3.Dim Couleur As Color
4.Dim MonFont As Font
5.
6.FolderBrowserDialog.ShowDialog()
7.Selection = FolderBrowserDialog.SelectedPath ‘récupère le chemin du dossier
8.
9.OpenFileDialog.ShowDialog()
10.Selection = OpenFileDialog.FileName ‘récupère le nom et le chemin du fichier
11.
12.ColorDialog.ShowDialog()
13.Couleur = ColorDialog.Color ‘récupère la couleur sélectionnée
14.
15.FontDialog.ShowDialog()
16.MonFont = FontDialog.Font ‘récupère le font (police, taille et style)
17.

Fin de la leçon… Ouf ! Désormais les contrôles n’ont plus aucun secret pout vous ^^ Bref, après avoir créer son programme, il faut penser à le distribuer et pour cela il faut créer une installation. Suivez le guide…
Le débogage est une étape très importante et fastidieuse. Elle permet de trouver et de corriger les bugs du programme. De nombreux outils sont à notre disposition pour nous aider mais le débogage reste encore une tâche difficile.

En programmation, il existe trois types d’erreurs possibles :
•Les erreurs de syntaxe
•Les erreurs d’exécution
•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 n 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, commander 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’en suivra une erreur d’exécution. (C’est une image mais c’est compréhensible).
1. ‘Exemple d’erreur d’exécution
2.Dim MonTableau As New ArrayList ‘déclare un tableau
3.MonTableau = Nothing ‘détruit le tableau
4.MonTableau.Items.Add(« Cool ») ‘provoquera une erreur d’exécution car MonTableau n’existe plus puisqu’il vaut « nothing »

Sachez que même les grands programmes (MSN et autres) comportent des bugs qui sont des erreurs d’exécution. Il est impossible de créer un gros programme sans aucune erreur. Les programmeurs professionnels utilisent des méthodes permettant d’anticiper, détecter et corriger le plus d’erreurs possibles.
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, demander 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).

Etant donné que les bugs sont inévitables et en plus invisibles à l’oeil 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’etre 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 !
1. ‘Exemple de piège à erreur dans VB.NET
2.Try ‘Ouvre le piège
3. Dim a As Integer = 30
4. Dim b As Integer = 0
5.
6. Dim Resultat As Decimal = a / b
7.
8. Call CalculerPi()
9.Catch Ex As Exception ‘Intercepte l’erreur en cas de pb
10. MsgBox(Ex.ToString) ‘Affiche l’erreur : Ici Division par 0 impossible
11.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 l’insérer dans un bloc Try / 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 une 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 clique 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).
Imaginer que votre prgramme soit terminé ! Vous aimeriez bien, dans certains cas, le distribuer à vos amis ? Pourtant, il est impossible de disbribuer l’application dans cet état. Pour remédier au problème, on a la possibilité de créer une installation (Setup en Anglais).
Comment s’y prendre avec Visual Studio ?

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 suivit de Nouveau Projet. Dans le volet de gauche, déroulez le menu Autre 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).

NB : S’il s’agit d’une application Web, choisissez l’autre option. Ne cocher rien dans Voulez vous créer un package redistribuable.
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 appuyer 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. Cliquez 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 boîtes de dialogue puisqu’elles sont expliquées dans l’explorateur de Visual Studio (cliquez sur une boîte 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, faites un clic droit sur la boîte de dialogue et sélectionnez 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 clique droit sur la sortie principale du projet et sélectionnez Créer un raccourci. Renommez votre raccourci puis glissez 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électionnez le puis faites un clic droit et allez dans Propriétés. Cliquez sur Aucun dans Icon et sélectionnez 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.
NB : Si vous avez oublié d’ajouter un fichier à votre installation, pas de panique ! Clique droit sur Setup1 (et oui encore là !!) et faites Ajouter puis Fichier.
Voilà c’est vraiment fini, c’était si dur que ca ? 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 à 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.

NB : Il existe deux modes de génération Debug et Release. Si votre application est en Beta-Test, choisissez le mode Debug sinon si votre application est finie et ne comporte aucun bug, sélectionner Release. Pour changer le mode de génération, clic droit sur Setup1 puis Propriétés. En haut à gauche, dans configuration, choisissez Release ou Debug. Faites une nouvelle génération puis prendre en compte les modifications.
Dans cette rubrique, vous trouverez de nombreux petits bouts de code permettant de faire des choses interssantes !
Sommaire :
•Internet :
oSavoir si on est connecté à internet
oRécupérer les IP sur un PC
oRécupérer la liste des PC
•Fichiers :
oSérialisation XML
oSérialisation binaire
oLister un répertoire dans une ListBox
oLister un répertoire dans une Treeview
oCompresser un fichier
oDécompresser un fichier
•Maths :
oRésoudre équations 2eme degrés
oRésoudre équations 3eme degrés
oCalculer une factorielle
oCalculer un PGCD
oSavoir si un nombre est premier
oSavoir si un nombre est divisible par un autre

Savoir si on est connecté à Internet (API)
1.‘Déclaration de l’API
2. Private Declare Function InternetGetConnectedState Lib « wininet.dll » ( _
3. ByRef lpdwFlags As Integer, _
4. ByVal dwReserved As Integer) As Boolean
5.
6. ‘fonction pour savoir si on est connecté à Internet
7. Public Function IsConnected() As Boolean
8. Dim Desc As Integer
9. Return InternetGetConnectedState(Desc, 0)
10. End Function

Comment récupérer les IP sur un PC ?
1.Public Function GetIPaddresses(Optional ByVal computername As String = « localhost ») As String()
2. Dim saddr() As String = New String() {}
3. Dim addr() As Net.IPAddress = Net.Dns.Resolve(computername).AddressList()
4. Dim i As Integer
5. If addr.Length > 0 Then
6. saddr = New String(addr.Length – 1) {}
7. For i = 0 To addr.Length – 1
8. saddr(i) = addr(i).ToString
9. Next
10. End If
11.
12. Return saddr
13.End Function

Comment récupérer la liste des PC ?
1.Private Function GetPCList(ByVal DomainPath As String) As ArrayList
2. Dim PCList As New ArrayList
3. Dim DomainEntry As New DirectoryEntry(DomainPath)
4. Dim Entry As DirectoryEntry
5.
6. DomainEntry.Children.SchemaFilter.Add(« Computer »)
7. For Each Entry In DomainEntry.Children
8. PCList.Add(Entry.Name)
9. Next
10.
11. Return PCList
12.End Function

Sérialisation XML d’une Treeview par exemple
Télécharger l’exemple (Format RAR)
Sérialisation binaire d’une Treeview par exemple
Télécharger l’exemple (Format RAR)
Lister les répertoires dans une ListBox (récursivité itérative)
1.Public Sub ListerMesRepertoire(ByVal Rep As String)
2. Try
3. ‘Recupere la liste des entrees du repetoire
4. Dim Liste As String() = Directory.GetFileSystemEntries(Rep)
5. Dim Entree As String
6.
7. For Each Entree In Liste ‘Pour chaque entree de la liste
8. Dim TmpName As String = Microsoft.VisualBasic.Mid(Entree, Len(Rep) + 1) ‘On decoupe proprement le nom du fichier ou repertoire
9. TmpName = Replace(TmpName,  » » », «  ») ‘On enleve les caracteres parasite
10.
11. If File.Exists(Entree) Then ‘Si c’est un fichier
12. ListBox1.Items.Add(TmpName)
13. Else ‘Si c’est un repertoire
14. ListerMesRepertoire(Entree) ‘On Liste le contenus de ce repertoire
15. End If
16. Next Entree
17. Catch Ex As System.UnauthorizedAccessException ‘Si le répertoire est interdit
18. Exit Sub
19. Catch e As Exception ‘en cas d’erreurs
20. MsgBox(« Erreur dans la dll :  » & e.Message, MsgBoxStyle.Critical)
21. End Try
22.End Sub

Lister les répertoires dans une Treeview (recursivité iterative)
Télécharger l’exemple (Format RAR)
Compresser un fichier en VB.NET 2005
1.Public Function CompresserFichier(ByVal cheminSource As String, ByVal cheminDestination As String) As Boolean
2. ‘cheminSource : chemin complet du fichier à compresser
3. ‘cheminDestination : chemin complet du fichier compressé à créer
4. Try
5. ‘Le fichier est placé dans le FileStream
6. Dim monFileStream As New FileStream(cheminSource, FileMode.Open)
7.
8. Dim monBuffer(CInt(monFileStream.Length)) As Byte
9. ‘Lecture de l’intégralité du FileStream
10. monFileStream.Read(monBuffer, 0, CInt(monFileStream.Length))
11. ‘Fermeture du FileStream
12. monFileStream.Close()
13. ‘Création du fichier qui va contenir le fichier compressé
14. monFileStream = New FileStream(cheminDestination, FileMode.Create)
15. ‘Compression des données
16. Dim monGZipStream As New GZipStream(monFileStream, CompressionMode.Compress, False)
17. ‘Ecriture des données compressées dans le fichier de destination
18. monGZipStream.Write(monBuffer, 0, monBuffer.Length)
19. ‘Fermeture du GZipStream
20. monGZipStream.Close()
21. Return True
22. Catch ex As Exception
23. MessageBox.Show(ex.Message)
24. Return False
25. End Try
26. End Function

Décompresser un fichier en VB.NET 2005
1.Public Function DecompresserFichier(ByVal cheminSource As String, ByVal cheminDestination As String) As Boolean
2. ‘cheminSource : chemin complet du fichier compressé
3. ‘cheminDestination : chemin complet du fichier où le fichier doit être décompressé
4. Try
5. ‘Lecture du fichier compresse
6. Dim monFileStream As New FileStream(cheminSource, FileMode.Open)
7. ‘ Données du fichier placées dans un GZipStream
8. Dim monGzipStream As New GZipStream(monFileStream, CompressionMode.Decompress)
9. ‘Tableau qui va contenir la taille du fichier
10. Dim tailleOctets(3) As Byte
11. ‘Positionnement dans le Stream pour récupérer la taille
12. Dim position As Integer = CInt(monFileStream.Length – 4)
13. monFileStream.Position = position
14. ‘Récupération de la taille du fichier
15. monFileStream.Read(tailleOctets, 0, 4)
16. ‘Repositionnement en début du Stream
17. monFileStream.Position = 0
18. ‘Conversion de la taille du fichier en entier
19. Dim tailleFichier As Integer = BitConverter.ToInt32(tailleOctets, 0)
20. ‘Dimesionnement du buffer
21. Dim buffer(tailleFichier + 100) As Byte
22. ‘Offset qui permettra de se repérer dans le Stream
23.

Dim monOffset As Integer = 0
24.
25. While (True)
26. ‘Les données sont décompressées et placées dans le buffer
27. Dim decompressionOctets As Integer = monGzipStream.Read(buffer, monOffset, 100)
28. ‘Tant qu’il reste des données on continue
29. If (decompressionOctets = 0) Then
30. Exit While
31. End If
32. ‘On icrémente l’offset pour ne pas repartir de 0 à chaque fois…
33. monOffset += decompressionOctets
34. End While
35.
36. ‘Création du fichier décompressé
37. monFileStream = New FileStream(cheminDestination, FileMode.Create)
38. ‘Ecriture des données décomrpessées dans le fichier
39. monFileStream.Write(buffer, 0, tailleFichier – 1)
40. ‘Efface les données en mémoire tampon
41. monFileStream.Flush()
42. ‘Fermeture des Streams
43. monFileStream.Close()
44. monGzipStream.Close()
45.
46. Return True
47. Catch ex As Exception
48. MessageBox.Show(ex.Message)
49. Return False
50. End Try
51. End Function

Résoudre des équations du 2 ème degrés
1.Public Function Resolution_Equation_2emeDegres(ByVal a As Integer, ByVal b As Integer, ByVal c As Integer) As ArrayList
2. Dim discriminant, x1, x2, racinediscri, enracin, x_double As Decimal
3.
4. Resolution_Equation_2emeDegres = New ArrayList
5. discriminant = (b * b – (4 * a * c))
6.
7. If a = 0 Then
8. Resolution_Equation_2emeDegres.Add(« La fonction saisie n’est pas un trinome »)
9. ElseIf discriminant > 0 And a 0 Then
10. ‘ 2 solutins dans R
11. racinediscri = CDec(Sqrt(discriminant))
12. enracin = Int(racinediscri)
13. x1 = (-b + racinediscri) / (2 * a)
14. x2 = (-b – racinediscri) / (2 * a)
15.
16. Resolution_Equation_2emeDegres.Add(x1.ToString)
17. Resolution_Equation_2emeDegres.Add(x2.ToString)
18. ElseIf discriminant < 0 Then
19. ‘pas de solutions dans R
20. Resolution_Equation_2emeDegres.Add(« Pas de racine dans R »)
21. ElseIf discriminant = 0 Then
22. ‘une racine double
23. x_double = CDec(-b / (2 * a))
24. Resolution_Equation_2emeDegres.Add(x_double.ToString)
25. End If
26. End Function

Résoudre des équations du 3 ème degrés
Télécharger l’exemple (Format RAR)
Calculer une factorielle
1.Public Function Factorielle(ByVal N As Long) As Long
2. If N = 1 Then
3. Return 1
4. Else
5. Return N * Factorielle(N – 1)
6. End If
7. End Function

Calculer un PGCD
1.Public Function PGCD(ByVal P As Long, ByVal Q As Long) As Long
2. If Q Mod P = 0 Then
3. Return P
4. Else
5. Return PGCD(Q, P Mod Q)
6. End If
7.End Function

Savoir si un nombre est premier
1.Public Function IsPremier(ByVal nombre As Integer) As Boolean
2. Dim Max As Integer = CInt(Math.Sqrt(nombre))
3. For j As Integer = 2 To Max
4. If Divisible(j, nombre) = True Then Return False
5. If j = Max Then Return True
6. Next
7.End Function

Savoir si un nombre est divisible par un autre
1.Public Function Divisible(ByVal p As Integer, ByVal nb As Integer) As Boolean
2. If nb Mod p = 0 Then
3. Return True
4. Else
5. Return False
6. End If
7.End Function