Un livre de Wikilivres.
Une version à jour et éditable de ce livre est disponible sur Wikilivres, une bibliothèque de livres pédagogiques, à l'URL :
Vous avez la permission de copier, distribuer et/ou modifier ce document selon les termes de la Licence de documentation libre GNU, version 1.2 ou plus récente publiée par la Free Software Foundation ; sans sections
inaltérables, sans texte de première page de couverture et sans Texte de dernière page de couverture. Une copie de cette licence est inclue dans l'annexe nommée « Licence de documentation libre GNU ».
Visual Basic .NET fait partie du framework .NET de Microsoft. Inspiré de Visual Basic, il n'assure cependant aucun compatibilité ascendante avec : les scripts VB6 ne seront pas compilé en .
Il propose les fonctionnalités suivantes :
Comme tous les langages .NET, supporte pleinement les concepts orientés objets comme l'héritage.
Tout est un objet, y compris les primitives (Short, Integer, Long, String, Boolean, etc.) les types, et évènements. Tout hérite donc de la classe Object de base.
Toutes les précédentes version de Visual Basic géraient les événements, mais cette fonctionnalité a été améliorée dans le framework .NET. En effet, ils ne sont plus reconnus par convention de nommage (ObjectName_EventName), mais déclarés par clause Handles ObjectName.EventName. Les gestionnaires d’évènements peuvent aussi être déclarés comme runtime utilisant la commande AddHandler.
Comme son nom l'indique, utilise le framework .NET Microsoft, ce qui signifie que le langage a pleinement accès à toutes les classes supportées par le framework.
10.0 supporte classes génériques et anonymes, les fonctions lambda, les types anonymes, et bien d'autres.
Le compilateur gratuit Microsoft Visual Studio Express est téléchargeable depuis le site officiel : .
Sinon il existe plusieurs versions payantes de Microsoft Visual Studio : .
Il est également possible de lancer des programmes depuis Mono, l'alternative open-source à .NET multiplateforme (Windows, Linux et Mac OSX), présenté dans le paragraphe suivant.
Enfin, SharpDevelopTélécharger () [archive] constitue une autre alternative open-source.
MonoDevelopTélécharger () [archive] : bien que ne supportant pas toutes les fonctionnalités du langage, il autorise le développement multiplateforme.
Si vous n'utilisez pas Microsoft Windows vous pouvez passer au chapitre suivant.
Visual Studio est environnement de développement intégré (IDE), c'est-à-dire un logiciel qui aide les programmeurs à développer. Par exemple il indique les erreurs de compilation en temps réel sous le code.
L'environnement Visual Studio est composé de plusieurs sections, ou outils, visibles pendant la programmation. Dans un nouveau projet trois sections sont généralement visibles :
La boîte à outils sur la gauche
L'explorateur de solutions sur la droite La vue du code ou design au milieu.
La boîte à outils est une palette d'objets développeur, ou de contrôles, qui sont placées sur les formulaires ou pages web, puis le code est ajouté pour permettre à l'utilisateur d’interagir avec eux. Un exemple sont les contrôles TextBox, Button et ListBox, avec lesquels le développeur peut autoriser des acquisitions de l'utilisateur dans application, par exemple entrer un texte puis l'ajouter à une liste sur pression d'un bouton.
Cette section permet de voir et modifier les contenus du projet. Un projet Visual Studio Application Windows Forms contient généralement un formulaire avec une page de code associée, avec potentiellement des composants et modules de code employés par l'application.
La fenêtre propriétés montre les propriétés des contrôles (comme les TextBox) changeable lors du design. La plupart peuvent aussi être déclenchées par du code, mais basiquement elles changent l'affichage du contrôle dans l'application.
En pressant F2 ou en le choisissant dans le menu View menu, il est possible d'explorer tous les objets des bibliothèques (types, fonctions ).
Cette vue permet d'afficher sur plusieurs onglets les formulaires tels que les verront les utilisateurs, et le code. C'est ici que l'on dispose les objets sélectionnés dans la boîte à outils.
Tout comme en Visual Basic :
F5 exécute le code.
F8 le fait en pas à pas.
Remarque : en cliquant dans la marge il est possible de définir des "points d’arrêt", qui stopperont l'exécution du programme jusqu'à ce qu'on lui demande de la continuer.
Pour commencer à programmer en Visual Basic .NET, lancer l'interface choisie dans le premier chapitre et créer un nouveau projet de type Application Windows Forms.
Double-cliquer sur le formulaire vierge pour faire apparaitre son code dans un autre onglet, qui doit être une classe vierge :
| Public ClassForm1 Inherits [Windows Form Designer generated code] Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) End Sub End Class |
Han
Y ajouter la ligne suivante dans la fonction Form_Load (entre les lignes Private Sub et End Sub) :
("Hello World!")
En pressant F5 ou en cliquant dans le menu Debug sur Démarrer le programme, cela devrait afficher une boite contenant le message "Hello World!", qui si on clique dessus laisse place au formulaire vierge. On peut le fermer ensuite avec le bouton de croix en haut à droite.
Ajouter un projet via le menu File, puis New, et Project puis sélectionner Application console.
Ajouter dans la fonction Main() :
Console.WriteLine("Hello World!")
Console.ReadLine()
Ensuite en pressant F5 la console se lance.
Tout comme en Visual Basic, utilise :
1. ' avant les commentaires
2. _ pour scinder une commande sur la ligne suivante
3. : pour démarrer une nouvelle commande sur la même ligne.
En Visual Basic .NET, les variables sont déclarées avec la commande Dim (de l'anglais dimension). Voici la syntaxe :
Dim NomVariable As TypeVariable
NomVariable est le nom de la variable (le plus explicite possible).
TypeVariable est son type de données (ex : string, integer, double, boolean, etc.).
Par exemple, pour déclarer un nombre entier :
Dim NomNombre As Integer
Par défaut, la casse des variables ne permet pas de les distinguer, ainsi nomnariable sera automatiquement convertie en NomVariable par l'IDE si elle est déclarée comme telle.
Par contre, pour que le programme ignore la casse dans les valeurs chaines de caractères, il faut définir Option Compare Text.
| Option Compare Text ModuleModule1 | ' En commentant cette ligne le résultat devient False |
| Sub Main() Dim chaine1 As String = "a" Dim chaine2 As String = "A" MsgBox(chaine1 = chaine2) End Sub End Module | |
Les types incorporés par sont :
| Alias VB | Type .NET | Taille | Valeurs | ||||
| SByte | System.SByte | 8 bits (1 octet) | -128 à 127 | ||||
| Byte | 8 bits (1 octet) | 0 à 255 | |||||
| Short | System.Int16 | 16 bits (2 octets) | -32 768 à 32 767 | ||||
| UShort | System.UInt16 | 16 bits (2 octets) | 0 à 65 535 | ||||
| Integer | System.Int32 | 32 bits (4 octets) | -2 147 483 648 à 2 147 483 647 | ||||
| UInteger | System.UInt32 | 32 bits (4 octets) | 0 à 4 294 967 295 | ||||
| Long | System.Int64 | 64 bits (8 octets) | -9 223 372 036 854 775 808 à 9 223 372 036 854 775 807 | ||||
| ULong | System.UInt64 | 64 bits (8 octets) | 0 à 18 446 744 073 709 551 615 | .NET Type | Taille | Précision | Valeurs |
| Single | System.Single | 32 bits (4 octets) | 7 chiffres | 1,5 x 10-45 à 3,4 x 1038 | |||
| Double | System.Double | 64 bits (8 octets) | 15-16 chiffres | 5,0 x 10-324 à 1,7 x 10308 | |||
| Decimal | System.Decimal | 128 bits (16 octets) | 28-29 places décimales | 1,0 x 10-28 à 7,9 x 1028 |
| Alias VB | .NET Type | Taille | Valeurs |
| Char | 16 bits (2 octets) | Un symbole Unicode entre 0 et 65 535 | |
| Boolean | System.Boolean | 32 bits (4 octets) | True ou False |
| Object | System.Object | 32/64 bits (4/8 octets) | Dépendant de la plateforme |
| Date | System.DateTime | 64 bits (8 octets) | Du 1 janvier 0001 12:00:00 AM au 31 décembre 9999 11:59:59 PM |
| String | System.String | 80 + [16 * longueur] bits (10 + [2 * longueur] octets) | Une chaine Unicode avec une longueur maximum de 2 147 483 647 caractères. |
Pour connaitre le type d'une variable, utiliser sa méthode .GetType().
Assignation
'Les valeurs sont assignées aux variables par le signe égal.
Les nombres intégralement littéraux comme 42 et 1000, sont de type Integer par défaut. Les chaines et caractères littéraux, comme "Hello World!" et "A", sont de type String.
Pour spécifier le type d'un littéral, on utilise donc les suffixes. Ces derniers sont accolés immédiatement après les littéraux (sans espace), comme ceci : <littéral><suffixe>.
Les chaines de caractères doivent être entre guillemets pour ne pas être considérées comme des noms de variables :
strNomVariable = "Une chaine" chrNomVariable = "À"
Pour les variables dates, utiliser des croisillons autour de la valeur, au format #<jour>/<mois>/<année> <heure>:<minute>:<seconde> <AM|PM>#:
Pour tous les autres, ne pas entourer les valeurs :
bytNomVariable = 1 sbytNomVariable = -2 shrtNomVariable = 10S ushrtNomVariable = 10US intNomVariable = 100 uintNomVariable = 100UI lngNomVariable = 1000L ulngNomVariable = 1000UL sngNomVariable = 1.234F dblNomVariable = 1.567R decNomVariable = 1234567.89D boolNomVariable = True objNomObjet = New Object
Il est possible d'assigner une valeur à une variable pendant sa déclaration :
Dim NomVariable As String = "Valeur de la chaine"
Visual Basic assigne toujours la valeur de droite dans la variable à gauche du signe égal, sans modifier la première.
Les constantes sont considérées comme des variables qui ne changent pas. Elles sont déclarées avec le mot clé Const, et leurs valeurs sont définies durant leur déclaration :
Const cnstNomConstante As String = "Longue chaine de caractères"
Exemple :
Const cnstPi AsSingle = 3.14159265F
Pour convertir des radians en degrés on peut créer la constante 180/Pi :
Const cnstRadDeg AsSingle = 57,29579143
Degres = Radians / cnstRadDeg
Cette constante serait utile aux fonctions Sin, Cos, Tan, Arctan, etc.
Le type du tableau est imposé à tous ses éléments (un tableau Integer ne pourra stocker que des entiers). Voici un tableau de taille six (d'indice 0 à 5) :
Dim NomTableau(5) As Integer
Cette déclaration engendre la création de cet objet :
00 Nothing
01 Nothing
02 Nothing
03 Nothing
04 Nothing
05 Nothing
Que l'on peut parcourir ainsi : NomTableau(0), NomTableau(1), , NomTableau(10).
Pour assigner des valeurs pendant la déclaration on crée une instance de la classe du type (ici Integer) :
ModuleModule1
| Sub Main() Dim NomTableau() As Integer = New Integer(4) { 1, 2, 3, 4, 5 } ' Affichage du tableau déclaré For ligne = 0 To UBound(NomTableau) Next Console.ReadLine() End Sub End Module |
Voici un autre exemple avec une instance de String dont les valeurs sont attribuées ensuite :
| Dim NomTableau As System.Array NomTableau = System.Array.CreateInstance(GetType(String), 4) NomTableau(0) = "a" NomTableau(1) = "b" NomTableau(2) = "c" NomTableau(3) = "d" ' Affichage du tableau déclaré For ligne = 0 To NomTableau.Length Console.WriteLine(NomTableau(ligne)) Next Console.ReadLine() |
Pour afficher tous les éléments du tableau d'un coup on utilise un énumérateur :
| Dim En As System.Collections.IEnumerator Dim NomTableau As System.Array NomTableau = System.Array.CreateInstance(GetType(String), 4) NomTableau(0) = "a" NomTableau(1) = "d" NomTableau(2) = "b" NomTableau(3) = "c" ' Affichage du tableau déclaré En = NomTableau.GetEnumerator Do While En.MoveNext Console.WriteLine(En.Current()) Loop Console.WriteLine("Presser entrée pour continuer ") Console.ReadLine() |
Classer le tableau :
| Dim NomTableau As System.Array Dim En As System.Collections.IEnumerator NomTableau = System.Array.CreateInstance(GetType(String), 4) NomTableau(0) = "a" NomTableau(1) = "d" NomTableau(2) = "b" NomTableau(3) = "c" En = NomTableau.GetEnumerator Console.WriteLine("Avant classement") Do While En.MoveNext Console.WriteLine(En.Current()) |
| Loop (NomTableau) En = NomTableau.GetEnumerator Console.WriteLine("Après classement") Do While En.MoveNext Console.WriteLine(En.Current()) Loop Console.WriteLine("Presser entrée pour continuer ") Console.ReadLine() |
Classer le tableau par ordre décroissant :
| ModuleModule1 Sub Main() Dim NomTableau As System.Array Dim En As System.Collections.IEnumerator Dim DescSortCompare = New DescSortCompareClass NomTableau = System.Array.CreateInstance(GetType(String), 4) NomTableau(0) = "a" NomTableau(1) = "d" NomTableau(2) = "b" NomTableau(3) = "c" Console.WriteLine("Avant classement décroissant") Do While En.MoveNext Console.WriteLine(En.Current()) Loop (NomTableau, DescSortCompare) En = NomTableau.GetEnumerator Console.WriteLine("Après classement décroissant") Do While En.MoveNext Console.WriteLine(En.Current()) Loop Console.WriteLine("Presser entrée pour continuer ") Console.ReadLine() End Sub Public ClassDescSortCompareClass Implements IComparer Function Compare(ByVal x As Object, ByVal y As Object) As Integer Implements ICompa Return x > y End Function End Class End Module |
Renverser le tableau :
Dim NomTableau As System.Array
Dim En As System.Collections.IEnumerator
NomTableau = System.Array.CreateInstance(GetType(String), 4)
NomTableau(0) = "a"
NomTableau(1) = "d"
NomTableau(2) = "b"
NomTableau(3) = "c"
En = NomTableau.GetEnumerator
| Console.WriteLine("Avant renversement du tableau") Do While En.MoveNext Console.WriteLine(En.Current()) Loop Array.Reverse(NomTableau) En = NomTableau.GetEnumerator Console.WriteLine("Après renversement du tableau") Do While En.MoveNext Console.WriteLine(En.Current()) Loop Console.WriteLine("Presser entrée pour continuer ") Console.ReadLine() |
Une autre façon de classer de façon décroissante est de renverser le tableau croissant :
| Dim NomTableau As System.Array Dim En As System.Collections.IEnumerator NomTableau = System.Array.CreateInstance(GetType(String), 4) NomTableau(0) = "a" NomTableau(1) = "d" NomTableau(2) = "b" NomTableau(3) = "c" En = NomTableau.GetEnumerator Console.WriteLine("Avant classement décroissant") Do While En.MoveNext Console.WriteLine(En.Current()) Loop (NomTableau) Array.Reverse(NomTableau) En = NomTableau.GetEnumerator Console.WriteLine("Après classement décroissant") Do While En.MoveNext Console.WriteLine(En.Current()) Loop Console.WriteLine("Presser entrée pour continuer ") Console.ReadLine()
Tableaux à plusieurs dimensionsOn peut déclarer des tableaux 2D, 3D, 4D etc. ' Tableau 2D aux coordonnées (X, Y)Dim NomTableau2D(2, 2) As Integer Cela génère cet objet : Index Data
Pour le parcourir on peut utiliser des boucles imbriquées, ou bien un énumérateur :
Le résultat sera :
Méthodes de manipulation de tableauxSplit() : pour transformer une chaine de caractères en tableau, selon le séparateur placé en paramètre. Join() : convertit un tableau en chaine. Filter() : filtre les entrées d'un tableau. Exemple :
Voir aussiToutes les opérations sur les tableaux ( ) [archive] ConditionsConditionsListe des conditions : 1. If/Else/Endif 2. If/ElseIf/Else/Endif 3. Select Case/End Select If Else EndIf Soit les variables et les assertions suivantes : Dim Entier1 as Integer = 4 Dim Entier2 as Integer = 7 MsgBox(Entier1 = 4) ' affiche True MsgBox(Entier1 = 5) ' False MsgBox(Entier1 > 7) ' True MsgBox(Entier1 < Entier2) ' True If Entier1 = 4 Then MsgBox("Entier1 n'a pas changé") S'il y a plusieurs instructions derrière le Then, il est obligatoire de leur allouer une ligne chacune, puis de terminer la condition par un End if :
Si des instructions doive
Attention à bien prioriser avec des parenthèses : If Not Entier1 = 3 Or Entier2 = 7 Then MsgBox("Entier1 est différent de 3 et Entier2 = If Not (Entier1 = 3 Or Entier2 = 7) Then MsgBox("Entier1 est différent de 3 et Entier2 If ElseIf Else EndIf If/ElseIf permet de tester plusieurs conditions dans l'ordre séquentiel programmé. Exemple :
Select Case Ce procédé permet de raccourcir la syntaxe de longues chaines If/ElseIf/ /ElseIf/Else.
Opérateurs booléensLes opérateurs booléens en Visual Basic .NET peuvent être testés tels quels, sans fonction isTrue() que l'on peut trouver dans d'autres langages. Par exemple : functionA() and functionB() Dans cette instruction le circuit court fait en sorte que la seconde fonction ne s'exécute que si la première renvoie True. L'ordre des conditions est donc important pour optimiser la vitesse du programme. Outre les opérateurs compatibles avec les précédentes version de Visual Basic, il existe ceux-ci : Not And Or Xor Plus deux utilisant les circuits courts d'évaluation : AndAlso OrElse BouclesIl existe plusieurs structures de boucles en . Boucle Do Loop UntilUn Do Loop Until est une boucle qui itère tant que sa condition de sortie est fausse, cette dernière est testée à chaque fin de boucle, donc le programme y passe forcément au moins une fois.
Boucle Do Loop WhileUne boucle Do Loop While tourne tant que sa condition d'itération est vraie, cette dernière est testée à chaque fin de boucle, donc le programme y passe forcément au moins une fois.
Boucle Do Until LoopUn Do Until Loop est une boucle qui itère tant que sa condition de sortie est fausse (comme Do Until Loop), cette dernière est testée à chaque début de boucle, donc le programme n'y passe pas forcément.
Boucle Do While LoopDe la même manière, Do While Loop tourne tant que sa condition d'itération est vraie (comme Do Until Loop) et la teste en amont de chaque boucle.
Boucle ForUne boucle For s'exécute un certain nombre de fois, relativement prédéfinie car la valeur du compteur peut changer en cours de rouge.
Cet exemple s'exécute 10 fois, a = 1, puis 2 puis 10. Pour changer le sens du compteur :
S'exécute aussi 10 fois, mais a = 10, puis 9 puis 1. Remarque : à tout moment il est possible de sortir de la boucle sans attendre sa fin avec Exit for. Boucle For EachUne boucle For Each itère pour chaque entrée d'un tableau ou autre objet itérable, qui doit implémenter les interfaces IEnumerable ou IEnumerator. L'implémentation de IList par Array autorise un tableau à être utilisé comme un objet, car IList hérite de IEnumerable.
Assignation et comparaisonAssignationL'opérateur "=" sert pour l'affectation et la comparaison. Pour définir une variable : x = 7 ' x est à présent égal à sept x = -1294 x = "exemple" ComparaisonPour comparer deux valeurs (constantes ou variables) :
Cas particulier : plusieurs signes égaux consécutifs : Dim x As Boolean x = 2 = 7 Autres opérateurs de comparaison(x <> y) ' Différent (x < y) ' Inférieur (x > y) ' Supérieur (x <= y) ' Inférieur ou égal (x >= y) ' Supérieur ou égal ArithmétiqueOpérateurs arithmétiquesVisual Basic .NET fournit différent opérateurs arithmétiques : & ' Concaténation + ' Addition ou concaténation - ' Soustraction * ' Multiplication / ' Division \ ' Division entière Mod' Modulo (reste de division) ^ ' Exponentiation "7" & "2" ' "72" "7" + "2" ' "72" 7 + 2 ' 9 7 - 2 ' 5 7 * 2 ' 14 7 / 2 ' 3.5 7 \ 2 ' 3 7 Mod 2 ' 1 7 ^ 2 ' 49 Exemple (le séparateur décimal est le point contrairement en français où on utilise la virgule) : Dim Commission AsSingle Dim Ventes AsSingle Ventes = 3142.51 Commission = 0.3 * Ventes ' Calcule 30 % de commission. MsgBox(Commission) ' 942,753 Remarque : ces symboles sont les mêmes que dans la calculatrice scientifique Windows. Addition
L'opérateur "+=" incrémente la variable d'une valeur donnée : Dim x As Integer = 54 x += 89 ' 143 x += 7 ' 150 Il fonctionne aussi en concaténation :
Soustraction"-" soustrait deux nombres : Dim x As Integer x = 7 - 2 ' 5 x = 25 - -4 ' 29 MultiplicationLe symbole est l'étoile : Dim x As Integer x = 7 * 2 ' 14 x = 25 * -4 ' -100 DivisionIl existe plusieurs types de divisions. Division standardOpérateur "/" :
x = 7 / 2 ' 3,5 x = 25 / 4 ' 6,25 Dim x As Integer x = 7 \ 2 ' 3 x = 25 \ 4 ' 6 ModuloCet opérateur fourni le reste de la division : Dim x As Integer x = 7 Mod 2 ' 1 (7-2*3) x = 25 Mod 4 ' 1 (25-4*6) ExponentiationL'opérateur "^" élève un nombre à une puissance : Dim x As Integer x = 7 ^ 2 ' 7² = 49 Si la puissance est de 0,5 il peut aussi servir à calculer la racine carré d'un nombre : Dim x AsSingle x = 7 ^ 0.5 ' 2,645 Attention aux types des variables : Dim x As Integer x = 7 ^ 0.5 ' 3 La racine Nième se calcule donc généralement ainsi : Dim x AsSingle Dim n AsSingle n = 7 x = 2 ^ (1 / n) Car . ArrondisRound() : arrondit à l'entier le plus proche. Floor() : arrondit à l'inférieur. Ceiling() : arrondit au supérieur. Truncate() : tronque les chiffres décimaux. isNaN() : not a number, si ce n'est pas un nombre.
Remarque : avec Imports Math, plus besoin d'appeler ces fonctions avec ce préfixe. ComparaisonsMax() Min()
AutresAbs() : valeur absolue. Pow() : puissance. Sqrt() : racine carrée (square root). Chaines de caractèresJoindre des chaines de caractèresConcaténationL'opérateur "&" joint deux chaines ensemble : Dim Chaine1 As String = "123" Dim Chaine2 As String = "456" Dim Chaine3 As String
L'opérateur "+" peut être utilisé à la place de "&", mais non recommandé pour éviter la confusion avec les additions. Concat()La méthode String.Concat() est une alternative à l'opérateur :
Cela fonctionne aussi avec les tableaux : Dim TableauChaines As String() = {"1", "2", "3", "4", "5"} Resultat = String.Concat(TableauChaines) ' 12345 Méthodes sur les chaines de caractèresLcase() : convertit en bas de casse. Ucase() : convertit en haut de casse. Pour créer des sous-chaines, il existe toujours les fonctions VB6 : Left() : partie de gauche. Right() : partie de droite. Mid() : partie du milieu. InStr() : emplacement d'une chaine sans une autre. Replace() : remplace une sous-chaine par une autre.
LogiqueOpérateurs logiquesNotL'opérateur Not renvoie True quand la condition est False sinon False :
Truth Table
AndAnd retourne True quand ses deux opérandes sont True, sinon False. Il les évalue toutes les deux avant de se prononcer.
Truth Table
AndAlsoAndAlso est comme And sauf qu'il économise du temps : il dit False quand la condition qui le précède est False, puis sinon True si les deux opérandes sont True, sinon False. Cet ordre s'appelle un circuit court logique. Truth Table
OrOr est True quand au moins l'une de ses opérandes est True, sinon False. Il évalue les deux (comme And). Truth Table
OrElseOrElse est le circuit logique court de Or : il donne True quand sa première opérande est True, sinon il teste la seconde est renvoie True si elle est True, et False si les deux sont finalement False. Truth Table
XorXor ("ou exclusif", de l'anglais "exclusive or") est True uniquement si l'une des deux opérandes est True, mais pas quand elles le sont toutes les deux. Truth Table
Gestion d'exceptionLevées d'exceptionPour éviter que des erreurs bloquent l'exécution du programme il est possible de définir un comportement quand elles surviennent. On Error GoTo La méthode utilisée en VBA est toujours disponible. Celle-ci n'était pas structuré car fait appel à un Goto vers une étiquette :
Pour éviter d'avoir à définir des étiquettes on peut tout simplement ignorer les erreurs un moment (puis les réactiver avec On Error GoTo 0 : On Error Resume Next Dim Resultat As Integer = 2 Dim a = 1 Dim b = 0 Resultat = a / b On Error GoTo 0 (Resultat) Try Catch Finally
Remarque : pour relancer une exception dans un bloc Catch, utiliser le mot clé Throw sans argument. En effet il reset la propriété .StackTrace de l'objet exception en cas d'argument[2]. Références1. anglais 2. anglais Blog d'Eric Lippert () [archive] ClassesIntroductionTout comme en VB6, les classes sont utilisables pour la programmation orientée objet. Pour en créer une, dans l'Explorateur de solutions, après un clic droit sur l'application, Add, puis Class. Ou bien dans le menu Project, choisir Ajouter une classe . ChampsLes champs sont des variables déclarées directement dans la classe (pas dans ses fonctions ou propriétés), et que l'on ne peut pas appeler en dehors d'elle :
Les classes peuvent appeler ces variables privées à l'aide de Me :
ConstructeursUne fois la classe déclarée, il convient d'initialiser ses champs avec un constructeur :
PropriétésLes propriétés sont divisées en deux catégories : getter et setter. Un getter renvoie la valeur dans une classe, et un setter définit une valeur dans une classe.
La classe étant publique on peut y accéder en dehors de la classe, contrairement aux champs. Méthodes InstanciationOn utilise le mot New. Dim Client1 = New Client("Untel") MsgBox() NamespacesNamespacesLes espaces de noms permettent de séparer les différents programmes importés, notamment quand ils sont volumineux comme les bibliothèques. Dans un module, entrer simplement (sans nom de module) :
Pour les importer ensuite, utiliser Imports. Par exemple depuis un autre module du projet ConsoleApplication1 :
En commentant la ligne de l'importation, l'erreur suivante apparait : Type ClasseExterne non défini. RéférencesHéritageHéritage d'objetsL'héritage se traduit par le mot clé Inherits. On peut ensuite étendre et modifier une classe existante avec des propriétés et méthodes additionnelles. Par exemple en partant de la classe ci-dessous :
Sachant qu'un client est une personne avec un type et un numéro de client, il est plus rapide qu'il hérite de la classe Personne que de déclarer toutes ses propriétés et méthodes en repartant de zéro :
De plus, si la classe Personne est modifiée il ne sera pas nécessaire de mettre à jour la classe Client. InterfacesUtiliser les interfacesUne Interface est l'ensemble des méthodes publiques d'une classe. Elles se déclarent avec le mot clé Implements. Pour créer une interface : Function Fonction1() As String End Interface | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Pour l'utiliser dans une autre classe :
| Public ClassClasseDepuisInterfaceimplements Interface1() ' en appuyant sur entrée l'IDE crée automatiquement les éléments de l'interface implémPublic Function Fonction1() As String Implements Interface1.Fonction1 ' End Function End Class |
(anglais) (anglais)
IDisposable est implémentée quand un objet a besoin d'être réinitialisé. Généralement s'il contient une méthode Dispose, cette réinitialisation est nécessaire.
La plus simple façon de le faire est d'utiliser le mot clé Using.
| Using f AsNew Form f.Show End Using |
Quand un objet IDisposable est un formulaire, il doit être disposé dans l'évènement Form_Closed.
| Public ClassFormulaire1 Private FormulaireEnfant As Form Private Sub Formulaire1_Load(ByVal sender As System.Object, ByVal e As FormulaireEnfant = New Form = "Enfant" () End Sub Private Sub frmMain_FormClosed(ByVal sender As Object, ByVal e As System.Windows. FormulaireEnfant.Dispose() End Sub End Class |
F
Comme son prédécesseur, Visual Basic .NET excelle à la création d'interfaces graphiques. En travaillant sur des formulaires, il suffit de faire glisser les contrôles désirés depuis la ToolBox, de changer leur taille et de les configurer via la fenêtre des propriétés. Le gestionnaire d'évènement de chaque contrôle renvoie à la fenêtre de code.
La TextBox affiche du texte, sa fenêtre propriété permet de changer de police de caractère, sa taille, couleur, etc.
Pour contrôler la validité d'un mot de passe, une TextBox doit contenir un caractère de masquage dans PasswordChar. On trouve généralement * ou ? mais toute lettre peut faire l'affaire.
Pour restreindre certains mots dans la TextBox il faut créer un gestionnaire d'évènement de KeyPress.
L'exemple suivant n'autorise que des chiffres (de 0 à 9), la virgule et le signe moins :
| Private Sub SubName (ByVal sender As Object, ByVal e As System.Windows.Forms.KeyPressEvent Select Case Asc(e.KeyChar) Case 48 To 57, 8 Case 45 If InStr(, "-") <> 0 Or sender.selectionStart <> 0 Then e.Handled = True End If Case 46 If InStr(, ",") <> 0 Then e.Handled = True End If Case Else e.Handled = True End Select End Sub |
Les Labels affichent du texte non modifiable. Généralement, ils servent à décrire les autres contrôles du formulaire.
Les Buttons déclenchent une action prédéfinie quand on clique dessus.
| Public ClassForm1 Private Sub Button1_Click(sender As System.Object, e As System.EventArgs) Handles Butt MsgBox("Bouton 1 pressé") End Sub End Class |
Une CheckBox indique un choix deux états (True/False) que l’utilisateur peut cocher ou décocher. Bien sûr le code peut modifier sur le titre de la boite selon sa valeur.
| Public ClassForm1 Private Sub CheckBox1_CheckedChanged(sender As System.Object, e As System.EventArgs) If CheckBox1.Checked Then MsgBox("Case 1 cochée") End If End Sub End Class |
H
Le RadioButton permet d'effectuer un choix parmi une liste d'options.
Pour déclencher une action sur une case cochée :
| Public ClassForm1 Private Sub RadioButton1_CheckedChanged(sender As System.Object, e As System.EventArgs If RadioButton1.Checked Then MsgBox("Bouton 1 coché") End If End Sub Private Sub RadioButton2_CheckedChanged(sender As System.Object, e As System.EventArgs If RadioButton2.Checked Then MsgBox("Bouton 2 coché") End If End Sub End Class Autres contrôlesCertains contrôles sont stockés dans des sous-menus de la ToolBox. Boîtes de dialogueElles se placent sous le formulaire en mode design, et ne se voient pas en mode lecture. OpenFileDialog Une OpenFileDialog régit le parcourt du disque pour ouvrir un fichier, sans ses propriétés. SaveFileDialogPermet par exemple de prédéfinir une extension de de la sauvegarde des fichiers. FontDialog Liste des polices de caractères disponibles dans les boites texte de l'utilisateur. ÉnumérationsIntroductionUne énumération est un ensemble de constantes du même type. Par défaut il s'agit d'entiers dont le premier est à 0 et le deuxième à 1, etc. Créer des énumérations
Avec affectations :
Utiliser des énumérationsLes énumérations sont appelables en préfixant le nom de leur collection :
CollectionsUne collection est comme un tableau qui pourrait stocker plusieurs types d'entrées. De plus certaines collections ont leurs propres méthodes. Par exemple pour tout objet Collection, il existe les méthodes : Add() Remove() Item() Clear() ArrayListArrayList est un tableau dynamique, sa taille varie automatiquement selon son contenu, et peut stocker des objets de différents types. Méthode AddLa méthode (Object) peut incrémenter des ArrayList :
QueueUne queue est une collection FIFO, elle a deux uniques méthodes pour empiler et dépiler ses informations. En utilisant System.Collections.Queue.Enqueue, un objet peut être ajouté à la fin de la collection, et retiré s'il est au début via System.Collections.Queue.Dequeue. StackUne pile (stack en anglais) est une collection en LIFO. Elle prend en charge trois méthodes de stockage et restitution de l'information. Utiliser pour ajouter un objet au sommet de la pile, poussant celui qui s'y retrouvait en-dessous. renvoi l'objet su sommet de la pile et le retire. est similaire à Pop sauf qu'il ne retire pas l'objet renvoyé. SortedListUne SortedList est une collection d'objets classée selon un index (comme pour les tableaux) et aussi une clé, pouvant adopter n'importe quel type. Dictionary Tableau à au moins deux colonnes dont une clé. Hashtable Dictionnaire dont la clé est issue d'une fonction de hachage. GenericsLes Generics permettent de stocker des objets de types plus spécifiques, comme String et Integer. List Une List(d'un type) donne accès à un ensemble d'entrée comme un tableau, ou comme une collection.
RéférencesGDI+Objet graphiqueUn objet System.Drawing.Graphics représente une surface de dessin. Pour obtenir un tel objet dans un contrôle PictureBox, utiliser la propriété .Graphics du paramètre PaintEventArgs dans l'évènement Paint() de la PictureBox.
. Pour charger une image puis dessiner dessus, utiliser Graphics.FromImage() :
La méthode .Save() peut être utilisée pour sauvegarder le bitmap dans un fichier ou un Stream (flux). Remarque : Bitmap conserve le fichier image ouvert, il faut donc copier le fichier dans un MemoryStream pour ne pas avoir cette liaison. Méthodes de dessin des méthodes comme Graphics.DrawLine et Graphics.DrawString pour tracer lignes et textes. MesuresGraphics.MeasureString permet de mesurer la hauteur ou largeur d'une partie de texte, affichable avec .DrawString. ÉchelleÉchelle simple Utiliser la propriété Graphics.PageUnit comme une façon simple de changer les coordonnées du système. Coordonnées des systèmes World, Page et DeviceLes coordonnées d'un système font partie de celles d'un World. Par défaut ces unités sont en pixels, mais on peut les redéfinir. La transformation de World convertit ses coordonnées en celles d'une Page. Ces dernières expriment la distance visible sur le moniteur ou imprimée sur du papier. La transformation de Page convertit ses coordonnées en celles d'une Device. Cela permet à l'image de rester la même quel que soit le périphérique sur laquelle elle est envoyée. Il est possible de définir une matrice de traduction pour convertir les points spécifié dans le résultat final. Cette transformation peut traduire (offset), échelle, rotation, inclinaison dans le résultat, elle est appelée transformation affine. Convertir depuis TwipsLes précédentes versions de Visual Basic utilisaient Twips comme unité de mesure : 1,440 Twips = 1 pouce. Toutefois, utilise plutôt les pixels. Pour convertir les Twips en pixels dans un objet graphique, il faut connaitre : Si g est l'objet Graphics approprié : XPixels = XTwips * g.DpiX / 1440 Utiliser g.DpiY pour calcuer les coordonnées de l'axe des Y.
Récupérée de « /Version_imprimable&oldid=440905 » Dernière modification de cette page le 15 février 2014 à 19:48. Les textes sont disponibles sous licence Creative Commons attribution partage à l’identique ; d’autres termes peuvent s’appliquer. Voyez les termes d’utilisation pour plus de détails. Développeurs |
