Ce chapitre est très important car il constitue les bases de la programmation orientée objet (POO). Si vous êtes débutants, vous ne pouvez pas passer ce chapitre.

Bon trêve de paroles, passons aux choses sérieuses !

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 !

‘Exemples de noms de variables MaVariable ‘est acceptée COOL ‘est acceptée Je_Suis_1_Variable ‘est aussi acceptée 2Variable ‘est refusée 2_Variable ‘est également refusée The Variable ‘est réfutée 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)

‘Exemple : Variable_pour_calculer_pi 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)

‘Exemples de déclarations de variables Dim Ma_Variable As String Dim Nombre As Integer Dim Compteur As Integer ‘Instancier des variables Dim Msn As New Msn_Protocol ‘Msn_Protocol est une class Dim Test As New Class

On peut aussi instancier les variables précédentes comme cela :

‘Exemple avec les variables précédentes Dim Ma_Variable As String = « toto » Dim Nombre As Integer = 45 Dim Compteur As Integer = 1000

Une variable peut aussi être instanciée par une fonction :

‘Exemple de variable instanciée par une fonction 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 variable	Mémoire occupée	Plage de nombres acceptés
Boolean	2 octets	True (1) ou False (0)
Byte	1 octet	De 0 à 255
Char	2 octets	De 0 à 65 535
Date	8 octets	Dates entre le 1 Janvier 0001 et le 31 Décembre 9999
Decimal	16 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
Double	8 octets	- 1,79769313486231E+308 à - 4.94065645841247E-324 (nombres négatifs) et 4.94065645841247E-324 à 1,79769313486231E+308 (nombres positifs)
Integer	4 octets	De - 2 147 483 648 à 2 147 483 647
Long	8 octets	De - 9 223 372 036 854 775 808 à 9 223 372 036 854 775 807
Short	2 octets	De - 32 768 à 32 767
Single	4 octets	De - 3.402823E-45 à - 1.401298E+38
String	Variable	0 à 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 :

Fonction	Type
CBool	Boolean
CByte	Byte
CChar	Char
CDate	Date
CDbl	Double
CDec	Decimal
CInt	Integer
CLng	Long
CObj	Object
CShort	Short
CSng	Single
CStr	String

Dim Pi As Decimal = 3.14 ‘crée la variable Pi qui vaut 3.14 Dim a As Integer = 15 ‘crée la variable a qui vaut 15 Dim Pi_Entier As Integer = CInt(Pi) ‘retournera 3 Dim a_caractère As String = CStr(a) ‘retourner "15" 'en chaîne de caractère

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
Public	Partout dans le programme.
Private	Partout dans la classe ou le module où elle a été créée.
Dim	Seulement dans la procédure ou la fonction créée.
Protected	Les membres Protected sont similaires aux Private, mais ils ont une particularité en cas d'héritage. Ce point ne sera pas abordé.
Friend	Les membres Friend ne sont accessibles qu'à l'intérieur du projet, et pas par des éléments extérieurs au projet en cours.
Shared	Permet de partager une variable. N’est pas indispensable.

NB : Ce tableau est aussi valable pour la portée des procédures et des fonctions

‘Exemple avec des sub et fonctions Module Test_Portee Private Sub Test() End Sub Protected Sub Azerty(ByVal Argument As String) End Sub Private Shared Function Calcul(ByVal Nombre As Integer) End Function End Module

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.

‘Exemple de procédure d'affectation Module Test Public Nombre As Integer Public Sub Routine_Qui_Va_Affecter_La_Variable(ByVal Valeur As Integer) Nombre = Valeur End Sub End Module ‘Quelque part d’autre dans le programme on appel la procédure avec un argument de type Integer Call Routine_Qui_Va_Affecter_La_Variable(45) ‘Ensuite dans le programme totale, la variable Nombre va valoir 45 MsgBox(Nombre.ToString) ‘Affiche dans une boite de dialogue la valeur

Bien sûr, il est possible de faire directement :

‘attention source d'erreurs 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 :

If condition 1 vraie Then ‘exécuter condition 2 Else ‘exécuter condition 3 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

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

On peut tester une condition fausse et dans ce cas utiliser Not.

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

Il peut y avoir des opérateurs logiques dans la condition :

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 :

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

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 :

If Condition1 vraie Then .. ElseIf condition2 Then ‘sinon on teste la condition 2 .. ElseIf condition3 Then ‘la condition 3 .. 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 :

Select Case X Case 1 : ‘faire Y Case 2 : ‘faire Z Case Else : ‘faire A 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 :

Select Case code Case 1 : ‘se connecter Case 2 : ‘se déconnecter Case Else : ‘erreur code non reconnu 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.

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

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 :

For Variable = Debut To Fin ‘Execute la boucle 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.

‘Exemple de boucle Dim i As Integer For i = 3 To 10 ‘Exécute la boucle pour i variant de 3 à 10 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 :

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

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.

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

Dernière chose, on peut quitter la boucle prématurément :

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

Structure générale :

Do ‘Instructions Loop Until Condition Do ‘Instructions 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)

‘Exemple avec Until Dim i As Integer = 0 Do i = i + 1 ‘incrémente i de 1 MsgBox(i.ToString) ‘affiche la valeur de i Loop Until i = 10 ‘Quand i = 10 on sort de la boucle. ‘Exemple avec While Dim Fichier As String Do ‘Liste les fichiers d’un répertoire Loop While Fichier << "NomDeMonFichier" ‘Tant que Fichier n’est pas égal à NomDeMonFichier alors on boucle sinon on sort.

Structure générale :

While Condition ‘Execute la boucle 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.

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

Structure générale :

For Each Item In Collection ‘boucle 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.

‘Exemple Dim Var_Item As String For Each Item As Object In MonTableau Var_Item = Var_Item + Item ‘Var_Item va contenir tous les éléments du tableau en admettant que le tableau soit déjà remplit. Next Item ‘Autre exemple Dim Chaine As String = “Toto va bien” Dim Caractere As String For Each Caractere In Chaine Msgbox(Caractere.ToString) ‘affiche chaque caractère de Chaine Next

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érateur	Opé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

‘Exemples Dim x, y, Somme As Single X = 10 Y = 15.4 Somme = X + Y 'Somme retourne 25,4 Dim Revenu, Taxes, Revenu_Reel As Integer Revenu = 2000 Taxes = 2500 Revenu_Reel = Revenu - Taxes 'retourne -500 Dim a, b, c As Integer a = 12 b = 3 c = a Mod b 'c = 0 car la division tombre juste donc le reste = 0 Dim Prenom, Nom, NomComplet As String Prenom = "Florent" Nom = "Aspic" NomComplet = Prenom & Nom 'retourne "FlorentAspic"

Les opérateurs de logique manipulent des valeurs True ou False.

Opérateur	Syntaxe	Emploi
And (et)	Var_1 And Var_2	True si Var_1 et Var_2 sont vraies
Or (ou)	Var_1 Or Var_2	True si une des deux est vraie
Xor (ou exclusif)	Var_1 Xor Var_2	True si une et une seule est vraie
Not (non)	Not Var	True si Var est faux et vice versa

‘Exemples Dim a, b As Integer Dim Var, Var_1 As String a = 13 b = - 15 Var = "Cool" Var_1 = "Snif" If (a Or b) < 0 Then ‘Evalue la condition si a ou b est négative : ici c'est Vrai End If If (a And b) > 0 Then ‘Evalue la condition si a et b sont positifs : ici c'est Faux End If If Not Var = Var_1 Then ‘Evalue la condition si Var est différent de Var_1 : Ici c'est Vrai 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érateur	Signification
>	Strictement supérieur à
<	Strictement inférieur à
>=	Supérieur ou égal à
<=	Inférieur ou égal à
<>	Différent de
=	Egal à

‘Exemples Dim Age, AgeMin, AgeMax As Integer Dim EntreeBoiteDeNuit As Boolean Age = 12 AgeMin = 16 AgeMax = 45 If AgeMin < Age AndAlso Age < AgeMax Then EntreeBoiteDeNuit = True ‘La condition est Vraie End If If Age < AgeMin Then EntreeBoiteDeNuit = False ‘La condition est Fausse End If If Age = AgeMin then EntreeBoiteDeNuit = True ‘La condition est Vraie End If If Age >= 46 Then EntreeBoiteDeNuit = False ‘La condition est Fausse End If

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

‘Exemples de constantes Private Const Pi As Decimal = 3.14 Public Const Plat_Prefere As String = "Pates" ‘Ensuite on peut les utiliser Dim Rayon As Decimal = 5 ‘Soit un cercle de rayon 5 Dim AireCercle, PerimetreCercle As Decimal AireCercle = Pi * Rayon ^ 2 PerimetreCercle = 2 * Pi * Rayon MsgBox(Plat_Prefere) ‘Affiche mon plat préféré !!

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

‘Exemple Private Enum Erreur Logique Execution Syntaxe Grammaire End Enum ‘les constantes ainsi créées sont Erreur.Logique Erreur.Execution Erreur.Syntaxe Erreur.Grammaire ‘Exemple concret d'utilisation des constantes : ‘On crée une énumération Enum Action Ajouter Supprimer Inserer Selectionner End Enum ‘Plus loin dans le code Select Case Action Case Action.Ajouter 'dans ce cas on ajoute quelque chose ‘ici le bloc de code Case Action.Supprimer 'dans ce cas on supprime un élément ‘ici le bloc de code Case Action.Selectionner 'ici on sélectionne un élément ‘ici le bloc de code Case Action.Inserer 'ici on insère un élément dans un tableau par ex ‘ici le bloc de code Case Else MsgBox("Enumération non reconnue") 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 :

‘Exemple création tableau 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 :

‘Exemple d'ajout de valeurs Tableau(2) = 3 ‘assigne pour l'indice 2 la valeur de 3 Tableau(0)= 98 ‘assigne pour l'indice 0 la valeur de 98 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 :

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

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

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

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

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

Pour parcourir un tableau, rien de plus simple. On utilise généralement une boucle :

‘Lister les éléments d'un tableau Dim Tableau(5) As Integer For Each Item As Object In Tableau MsgBox(Item.ToString) ‘affiche chaque valeur du tableau Next Item ‘une autre méthode For i As Integer = 0 To Tableau.Length - 1 MsgBox(tableau(i).ToString) Next

Il existe 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 :

‘Ces lignes de code doivent être écrites tout en haut de la feuille Option Strict On ‘active le mode Strict Option Strict Off ‘désactive le mode Strict Option Explicit On ‘active le mode Explicit Option Explicit Off ‘désactive le mode Explicit Option Compare Binary ‘mode binaire pour la comparaison de chaînes Option Compare Text ‘mode texte pour la comparaison de chaînes ‘Si Option Strict Off Dim a As Decimal = 5.987 Dim b As Integer b = a ‘a vaut 5. Il y a eu une conversion implicite de Decimal vers Integer. VB accepte. ‘Si Option Strict On Dim a As Decimal = 5.987 Dim b As Integer b = a ‘VB plante !! ‘Il faut écrire b = CInt(a) ‘Si Option Strict Off Dim a As Object = "Toto" Dim b As Integer b = a.Length ‘a vaut 4. Il y a eu une liaison tardive. VB accepte. ‘Si Option Strict On Dim a As Object = "Toto" Dim b As Integer b = a.Length ‘VB plante !! ‘Il faut être strict et écrire : b = CType(a, String).Length ‘Si Option Explicit Off a = "Toto" 'a est un String b = 13 'b est un Integer ‘VB accepte cela mais cela est très déconseillé ! ‘Exemple de problèmes causés avec les déclarations implicites de variables : Dim Var ‘Déclare Var implicitement Varr = 10 ‘On croit avoir mis 10 dans Var mais en fait on créé une nouvelle variable nommée Varr et qui vaut 10 et Var vaut toujours 0 !! ‘Si Option Explicit On a = "Toto" ‘a est un String b = 13 ‘b est un Integer ‘Cela est tout simplement refusé par Visual Basic.

Option Strict Off permet 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...