• Accueil
• Tutoriels
• Cours
• Culture
• Forum
• S'inscrire

Choix catégorie Informatique Visual Basic.NET (Vb.net) Le langage Visual Basic.net

Nom du cours :

Le langage Visual Basic.net

Auteur :

fdiedler

Description :

Apprenez les bases de la syntaxe du Visual Basic.net

Difficulté :

Visualisations :

6732

Modifié le :

29 Juillet 2010 à 22h19

Commentaires :

6 commentaires - Ajouter un commentaire

 

Sommaire

• Les variables et leurs utilisations
• Introduction
• Les structures de boucles
• Les différents opérateurs
• Les structures conditionnelles
• Les constantes et les énumérations
• Les tableaux
• Les options de codage
• Conclusion

Les variables et leurs utilisations

Définition

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, @, .).

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 refusée
Différent 'est aussi refusée

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 classe
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()

Les différents types de variables

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 :

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

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)

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 !

En VB.NET 2005 (dernière version de Microsoft), il existe 4 autres types de variables mais cela ne concerne pas notre cours.

Convertir des variables

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 :

 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

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’

Portée des variables

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 recense la portée des variables :

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

 'Exemple avec des sub et fonctions
Module Test_PorteePrivate
     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.

Introduction

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.

Les structures de boucles

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"

Les boucles de type "For - 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

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

Les boucles de type "Do - Loop"

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.

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.

Les boucles de type "While - End While"

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.

Les boucles de type "For Each - Next"

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.

Les différents opérateurs

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.

Les opérateurs arithmétiques

 
'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 = 2000Taxes = 2500
Revenu_Reel = Revenu - Taxes 'retourne -500

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

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

Les opérateurs de logique

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

 
'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

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.

 
'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 structures conditionnelles

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"

Les conditions de type "If - Then"

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

• 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é"

Les conditions de type "Select Case"

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"

Les constantes et les énumérations

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 exemple  
          '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.

Les tableaux

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

Les index d’un tableau commencent toujours à 0. Le premier élément dans un tableau est toujours à l'indice 0.
Dans l’exemple, on a 6 + 1 = 7 cases !

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 :

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 tableauDim Tableau(5) As Integer
For Each Item As Object In Tableau
     MsgBox(Item.ToString)  'affiche chaque valeur du tableau
Next Item

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

Il existe des classes spéciales pour les tableaux ArrayList et SortedList.

Les options de codage

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 = 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 = 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 .

Conclusion

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... apprenez à réaliser vos applications graphiques avec Visual Studio

Commentaires