Cours VB.NET

Image non disponible


précédentsommairesuivant

IX. Programmation procédurale

IX-A. La programmation procédurale

Image non disponible

En programmation 'procédurale'(pas en programmation objet):

Chaque problème complexe est décomposé en 'Fonctions'(Les Subs et Fonctions) plus simples.

Ces fonctions sont stockées dans des modules standards (ou dans les modules de formulaire).

Dans une application en programmation 'procédurale' il y a habituellement:

- Des modules de formulaires

- Des modules standards contenant des Sub et Function.

Chaque fonction peut être appelée d'une autre fonction.

Exemple:

Créons une Function nommée CalculCarré.

 
Sélectionnez

Public Function CalculCarré ( c As Single) As Single

    Return c*c

End Function 

Cette fonction est Public (elle peut être appelée de n'importe où dans le programme).

Elle accepte un paramètre qui doit être un Single.

Comme c'est une fonction, elle retourne une valeur qui est aussi un Single.

Comment l'appeler?

 
Sélectionnez

Dim carré As Single

carré= CalculCarré (12)  

Une Sub par contre ne retourne pas de valeur.

 
Sélectionnez

Public Sub Affiche Carré ( c As Single)

..

End Sub

Comment l'appeler?

 
Sélectionnez

AfficheCarré (12) ou Call AfficheCarré (12)  

 

L'autre manière de programmer en VisualBasic est la programmation 'Objet'

IX-A-1. Comment créer un module standard, une Sub ?

Faire Menu Projet>Ajouter un module. Donner un nom au module. C'est Module1.vb par défaut.

 
Sélectionnez

Module Module1        'Nom du Module

...

End Module

On remarque que le module est bien enregistré dans un fichier .vb

Un module standard ne contient que du code.

Comment ajouter une Sub dans un module Standard?

Taper Sub Calcul puis valider, cela donne:

 
Sélectionnez

Sub Calcul()

End Sub

IX-A-2. Exemple d'utilisation de procédures et de modules

Exemple simple de programmation procédurale.

L'utilisateur saisit un nombre puis il clique sur un bouton; cela affiche le carré de ce nombre:

Il faut créer l'interface utilisateur: créer une fenêtre (Form1), y mettre un bouton (nommé Button1), une zone de texte (Text1) permettant de saisir un nombre, un label (label1) permettant l'affichage du résultat.

Créer un module standard (Module1) pour y mettre les procédures communes.

On observera uniquement l'agencement des procédures et non leur contenu. Pour un programme d'une telle complexité , la structure aurait pu être plus simple, mais l'intérêt de ce qui suit est didactique.

On décompose le programme en taches plus simples: En particulier une procédure sert au calcul, une sert à l'affichage.

La procédure CalculCarré calcule le carré.

La procédure AfficheCarre affiche le résultat dans le label.

La procédure Button1_Click (qui est déclenchée par le Click de l'utilisateur):

Lit le chiffre tapé par l'utilisateur dans la zone texte.

Appelle la procédure CalculCarré pour calculer le carré.

Appelle la procédure AfficheCarré pour afficher le résultat.

Ou sont placées les procédures?

La procédure Button1_Click est automatiquement dans le module du formulaire, Form1 (elle est liée au contrôle Bouton1) elle est créée automatiquement quand on crée le bouton.

La procédure AfficheCarré est créée dans le module du formulaire (Form1) car elle agit sur le contrôle Label1 de ce formulaire.

La procédure CalculCarré est créée dans le module Standard (Module1) car elle doit être appelable de n'importe où; elle est d'ailleurs 'Public' pour cette raison. Elle n'agit sur aucune fenêtre, aucun contrôle, elle est 'd'intérêt général', c'est pour cela qu'on la met dans un module standard.

Image non disponible

Voyons le cheminement du programme:

Image non disponible

Quand l'utilisateur clique sur le bouton la Sub Button1_Click démarre.

Elle appelle CalculCarre avec comme paramètre le nombre qui a été tapé dans le textbox (nommé Text1).

Val(Text1.Text) permet de transformer la String Text1.Text en numérique.

CalculCarre calcule le carré et renvoie la valeur de ce carré.

La Sub Button1_Click appelle ensuite AfficheCarre (en envoyant le paramètre Carré) qui affiche le résultat.

On remarque:

On appelle la Function CalculCarre par

 
Sélectionnez

Carre= CalculCarre(Valeur)

On envoie un paramètre Single , la fonction retourne dans la variable Carre, la valeur du carré.

Par contre la Sub AfficheCarre reçoit un paramètre, et ne retourne rien puisque c'est une Sub!!

IX-B. Exemple : Calcul de l'IMC

Image non disponible

Ce chapitre permet de 'réviser' pas mal de notions

IX-B-1. Qu'est-ce que l'IMC ?

L'index de masse corporelle est très utilisé par les médecins. Il est calculé à partir du poids et de la taille:

IMC=Poids/(Taille*Taille) (avec Poids en Kg, Taille en mètres)

Cela permet de savoir si le sujet est

maigre (IMC inférieur à 18.5)

normal (IMC idéale=22)

en surpoids (IMC supérieur à 25)

obèse (IMC>30).

On peut calculer le poids idéal par exemple PI= 22* T*T

Nous allons détailler ce petit programme:

IX-B-2. Quel est le cahier des charges du programme ?

L'utilisateur doit pouvoir:

Saisir un poids, une taille, cliquer sur un bouton 'Calculer'

Les routines doivent:

Vérifier que l'utilisateur ne fait pas n'importe quoi.

Calculer et afficher les résultats: l'IMC mais aussi, en fonction de la taille, le poids idéal, les poids limites de maigreur, surpoids, obésité.

IX-B-3. Création de l'interface

Il faut 2 zones de saisie pour saisir le poids et la taille:

On crée 2 'TextBox' que l'on nomme

TexBoxPoids

TextBoxTaille.

On laisse la propriété Multiline à False pour n'avoir qu'une ligne de saisie.

Pour afficher les résultats , on crée 5 'label' les uns sous les autres. (Pour aller plus vite et que les labels soient de la même taille, on en crée un puis par un copier et des coller, on crée les autres).

 
Sélectionnez

labelImc    'pour afficher l'Imc

labelPi     'pour afficher le poids idéal

labelM      'pour afficher le poids limite de la maigreur.

labelS      'pour afficher le poids limite du surpoids

labelO      'pour afficher le poids limite de l'obésité.

Ensuite on ajoute des labels devant et derrière chaque TextBox pour indiquer devant, ce qu'ils contiennent et derrière, l'unité.

On ajoute 2 boutons:

ButtonCalcul ayant pour propriété Text= "&Calculer"

ButtonQuitter ayant pour propriété Text= "&Quitter"

Cela donne:

Image non disponible

Pour faire beau:

La propriété Text de la fenêtre contient "Calcul IMC", pour afficher cela dans la barre de titre.

La propriété ForeColor de labelImc est en rouge.

La propriété BorderStyle des labels a la valeur 'Fixed3d' ce qui rend les bords visibles.

Ajout du Code

La procédure évènement Form1_Load qui se déclenche lorsque la fenêtre se charge initialise les zones d'affichage en les vidant:

 
Sélectionnez

Private Sub Form1_Load(..)

TextBoxTaille.Text = ""

TextBoxPoids.Text = ""

LabelImc.Text = ""

LabelPi.Text = ""

LabelM.Text = ""

LabelS.Text = ""

LabelO.Text = ""

End Sub

La procédure ButtonCalcul_Click qui se déclenche lorsque l'utilisateur clique sur le bouton 'Calculer' contient le code principal.

Voici la totalité du code, on le détaillera dessous.

 
Sélectionnez

Private Sub ButtonCalcul_Click(..)

 

Dim sPoids As Single  'Variable Single contenant le poids

Dim sTaille As Single 'Variable Single contenant la taille


'******contrôle de validité des entrées************

'Les valeurs saisies sont-elles numérique?

If Not (IsNumeric(TextBoxTaille.Text)) Then

    MsgBox("Entrez une valeur numérique pour la taille")

    Exit Sub

End If

If Not (IsNumeric(TextBoxPoids.Text)) Then

    MsgBox("Entrez une valeur numérique pour le poids")

    Exit Sub

End If


'Convertir les textes saisis en single 

' et les mettre dans les variables

sTaille = CType(TextBoxTaille.Text, Single) / 100

sPoids = CType(TextBoxPoids.Text, Single)


'Les valeurs saisies sont-elles cohérentes?

If sTaille < 0.50 Or sTaille > 2.50 Then

    MsgBox("Entrez une taille valide")

    Exit Sub

End If

    If sPoids < 20 Or sPoids > 200 Then

    MsgBox("Entrez un poids valide")

Exit Sub

End If


'Effectuer les calculs et afficher les résultats.

LabelImc.Text = (Math.Round(sPoids / (sTaille * sTaille), 2)).ToString

LabelPi.Text = (Math.Round(22 * (sTaille * sTaille), 2)).ToString

LabelM.Text = (Math.Round(18.5 * (sTaille * sTaille), 2)).ToString

LabelS.Text = (Math.Round(25 * (sTaille * sTaille), 2)).ToString

LabelO.Text = (Math.Round(30 * (sTaille * sTaille), 2)).ToString

End Sub

Détaillons:

Quelles sont les différentes étapes?
  • On déclare les variables.
  • On vérifie que ce qui a été tapé est numérique.
  • On convertit le texte qui est dans la TextBox en Single
  • On teste si les valeurs de poids et taille sont cohérentes.
  • On fait le calcul et on affiche.

Déclaration de variables.

 
Sélectionnez

Dim sPoids As Single  'Variable Single contenant le poids

Dim sTaille As Single 'Variable Single contenant la taille

Ce sont des variables 'privées' propres à la procédure (utilisation de Dim ou Private).

Contrôle de validité:

L'utilisateur est censé taper un poids et une taille puis cliquer sur le bouton 'Calculer'. Mais il ne faut absolument pas lui faire confiance: il a peut-être oublié de taper le poids ou a donner une taille=0 (l'ordinateur n'aime pas diviser par 0!!), il a peut-être fait une faute de frappe et tapé du texte!!..

Donc il faut tester ce qui a été tapé, s'il y a erreur, on prévient l'utilisateur avec une 'MessageBox' puis on sort de la routine par (Exit Sub )sans effectuer de calcul.

Ici par exemple, on teste si le texte saisi dans la zone taille n'est pas numérique:

 
Sélectionnez

If Not (IsNumeric(TextBoxTaille.Text)) Then

    MsgBox("Entrez une valeur numérique pour la taille")

    Exit Sub

End If

Amélioration: On aurait pu automatiquement effacer la valeur erronée et placer le curseur dans la zone à ressaisir:

 
Sélectionnez

If Not (IsNumeric(TextBoxTaille.Text)) Then

    MsgBox("Entrez une valeur numérique pour la taille")

    TextBoxTaille.Text=""

    TextBoxTaille.Select()

    Exit Sub

End If

Conversion:

Si le texte est bien 'Numéric', on fait la conversion en réel simple précision (Single)

 
Sélectionnez

sTaille = CType(TextBoxTaille.Text, Single) / 100

On utilise CType pour convertir une String en Single.

On divise taille par 100 car l'utilisateur à saisi la taille en centimètre et les formules nécessitent une taille en mètre.

Problème du séparateur décimal dans les saisies.

Pourquoi saisir la taille en Cm? c'est pour éviter d'avoir à gérer le problème du séparateur décimal.

Si la taille était saisie en mètre, l'utilisateur aurait-il tapé "1.75" ou "1,75"?

On rappelle que pour convertir un texte en Single VB accepte le point et pas la virgule.

Pour ma part, si j'avais demandé de saisir des mètres, voici ma solution: j'ajouterais en début de routine une instruction transformant les ',' en '.':

 
Sélectionnez

TextBoxTaille.Text = Replace(TextBoxTaille.Text, ",", ".")

Faire les calculs et afficher les résultats.

Je fais le calcul:

 
Sélectionnez

sPoids / (sTaille * sTaille)

J'arrondis à 2 décimales après la virgule grâce à Math.Round( ,2):

 
Sélectionnez

Math.Round(sPoids / (sTaille * sTaille), 2)

Je convertis en String:

 
Sélectionnez

(Math.Round(sPoids / (sTaille * sTaille), 2)).ToString

J'affiche dans le label 'labelImc':

 
Sélectionnez

LabelImc.Text = (Math.Round(sPoids / (sTaille * sTaille), 2)).ToString

(J'aurais pu aussi ne pas arrondir le calcul mais formater l'affichage pour que 2 décimales soient affichées)

La procédure ButtonQuitter_Click déclenchée quand l'utilisateur clique sur le bouton 'Quitter' ferme la seule fenêtre du projet (c'est Me , celle où on se trouve), ce qui arrête le programme.

 
Sélectionnez

Private Sub ButtonQuitter_Click()

    Me.Close()

End Sub

IX-B-4. Structuration

Ici on a fait simple : une procédure évènement calcule et affiche les résultats.

On pourrait, dans un but didactique 'structurer' le programme.

On pourrait découper le programme en procédure.
Une procédure (une fonction) faisant le calcul.
Une procédure (une fonction) affichant les résultats.

Si plusieurs procédures utilisent les mêmes variables il y a dans ce cas 2 possibilités:
Mettre les variables en 'Public' dans un module Standard.
Utiliser des variables privées et les passer en paramètres.

Première solution: Variables 'Public'.
Créer dans un module standard des variables 'Public' pour stocker les variables Poids et Taille, résultats (Public sIMC A Single par exemple),créer dans ce même module standard une procédure Public nommée 'Calculer' qui fait les calculs et met les résultats dans les variables 'Public'; enfin dans le module de formulaire créer une procédure 'AfficheResultat' affichant les résultats.

Module standard:

 
Sélectionnez

'Déclaration de variables Public 

Public sPoids As Single

Public sTaille As Single

Public sIMC A Single

..

'Procedure Public de calcul

Public Sub Calculer

    sIMC=Math.Round(sPoids / (sTaille * sTaille), 2)

    ...

End Sub

Module de formulaire Form1:

 
Sélectionnez

'Procédure évènement qui appelle les divers routines

Private Sub ButtonCalculer_Click

    ...

    sTaille = CType(TextBoxTaille.Text, Single) / 100

    Calculer()    'Appelle la routine de calcul

    AfficheResultat() 'Appelle la routine d'affichage

End Sub

 

'routine d'affichage toujours dans le formulaire

Private Sub AfficheResultat()

    

    LabelImc.Text = sIMC.ToString

    ...

End Sub

On voit bien que la routine de Calcul est générale et donc mise dans un module standard et d'accès 'Public', alors que la routine d'affichage affichant sur Form1 est privée et dans le module du formulaire.

Seconde solution: Variables 'Privées' et passage de paramètres.

On peut ne pas créer de variables 'public' mais créer des fonctions (CalculIMC par exemple) à qui on passe en paramètre le poids et la taille et qui retourne le résultat du calcul. Une procédure AfficheResultatIMC récupère en paramètre la valeur de l'IMC à afficher.

Module standard:

 
Sélectionnez

'Pas de déclaration de variables Public 

..

'Function Public de calcul: reçoit en paramètre le poids et la taille

'retourne l'Imc

Public Function CalculerIMC (T as Single, P As Single) As Single

    Return Math.Round(P / (T*T), 2)

End Sub

Module de formulaire Form1:

 
Sélectionnez

'Procédure évènement qui appelle les divers routines

Private Sub ButtonCalculer_Click

    ...

    sTaille = CType(TextBoxTaille.Text, Single) / 100

    

    'Appelle de la routine calcul avec l'envoie de paramètres sPoids et sTaille

    'Au retour on a la valeur de L'imc que l'on envoie à la routine d'affichage.

    AfficheResultatIMC(CalculerIMC(sTaille, sPoids)) 'Appelle la routine d'affichage

End Sub

 

'routine d'affichage 

Private Sub AfficheResultatIMC(I As Single)

    LabelImc.Text = i.ToString

End Sub

Remarque:

La ligne AfficheResultatIMC(CalculerIMC(sTaille, sPoids))

est équivalente à:

 
Sélectionnez

Dim s As single

s=(CalculerIMC(sTaille, sPoids)

AfficheResultatIMC(s))

mais on se passe d'une variable temporaire.

Conclusion:

Faut-il travailler avec des variables Public ou passer des paramètres?

Réponses:

Les savants disent qu'il faut éviter les variables Publics. Toutes les routines ayant accès à ces variables, il est toujours possible qu'une routine modifie une valeur sans qu'on le sache!!

Utiliser donc des variables le plus privées possible.
(on y reviendra)

IX-C. Exemple : Conversion Francs/Euros

Comment créer un programme de conversion Francs=>Euros et Euros=> Francs ?

Voici l'interface utilisateur:

Image non disponible

Il y a une zone de saisie Euros, une zone Francs, si je tape dans la zone Euros '2' il s'affiche '13.12' dans la zone Francs; cela fonctionne aussi dans le sens Francs=>Euros. On n'utilise pas d ebouton pour déclencher le calcul; le seul fait d'écrire dans un textBox déclenche le calcul et l'affichage des résultats.

Conseils:

Un formulaire affichera les zones de saisie, un module standard contiendra les procédures de conversion.

On crée un formulaire Form1 contenant :

2 TextBox BoiteF et BoiteE, leurs propriétés Text=""

2 labels dont la propriété Text sera ="Euros" et "Francs", on les positionnera comme ci-dessus.

Un module Module1 contiendra 2 routines ConversionFE ConversionEF

Dans le formulaire, je dimensionne un flag (ou drapeau): flagAffiche, il sera donc visible dans la totalité du formulaire. Je l'initialise à True.

 
Sélectionnez

Public Class Form1

Inherits System.Windows.Forms.Form

Dim flagAffiche As Boolean = True

Comme la conversion doit se déclencher automatiquement lorsque le texte de BoiteF ou BoiteE change, j'utilise les évènements 'TextChanged' de ces TextBox:

Pour la conversion Euros=>Francs, dans la procédure TextChanged de BoiteE, je récupère le texte tapé (BoiteE.Text), j'appelle la fonction ConversionEF en lui envoyant comme paramètre ce texte. La fonction me retourne un double que je transforme en string et que j'affiche dans l'autre TextBox(BoiteF).

 
Sélectionnez

Private Sub BoiteE_TextChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) 
_Handles BoiteE.TextChanged

If flagAffiche = True Then

flagAffiche = False

BoiteF.Text = (ConversionEF(BoiteE.Text)).ToString

flagAffiche = True

End If

End Sub

Idem pour l'autre TextBox:

 
Sélectionnez

Private Sub BoiteF_TextChanged(ByVal sender As Object, ByVal e As System.EventArgs) 
_Handles BoiteF.TextChanged

If flagAffiche = True Then

flagAffiche = False

BoiteE.Text = (ConversionFE(BoiteF.Text)).ToString

flagAffiche = True

End If

End Sub

End Class

A quoi sert le flag : flagAffiche?

A éviter une boucle sans fin: sans flag, BoiteF_TextChanged modifie BoiteE_Text qui déclenche BoiteE_TextChanged qui modifie BoiteF_Text qui déclenche BoiteF_TextChanged.....

Avec le flag, quand je vais modifier la propriété Text d'une TextBox, je mets le flag à False, cela indique à l'autre évènement TextChanged de ne pas lui aussi convertir et afficher.

Enfin il faut écrire les procédures qui font la conversion: ConversionEF et ConversionFE dans un module standard. Ces procédures 'Function' appellent elles mêmes une autre fonction qui arrondi les résultats à 2 décimales.

Pour transformer des Euros en Francs, je les multiplie par 6.55957 puis j'arrondis.

On remarque que ces procédures reçoivent une string en paramètres et retourne un double.

 
Sélectionnez

Module Module1

Public Function ConversionEF(ByVal e As String) As Double

Dim somme As Double

Dim resultat As Double

somme = Val(e)

resultat = Arrondir(somme * 6.55957)

Return resultat

End Function

 

Public Function ConversionFE(ByVal e As String) As Double

Dim somme As Double

Dim resultat As Double

somme = Val(e)

resultat = Arrondir(somme / 6.55957)

Return resultat

End Function

Enfin la Function Arrondir arrondit à 2 décimales: pour cela on multiplie par 100, on arrondit à l'entier avec Round puis on divise par 100.

 
Sélectionnez

Public Function Arrondir(ByVal Valeur As Double) As Double

'arrondi a 2 chiffres après la virgule

Return (Math.Round(Valeur * 100)) / 100

End Function

End Module

A noter que l'on aurait pu utiliser une surcharge de Round qui arrondit directement à 2 décimales:

 
Sélectionnez

Return (Math.Round(Valeur, 2))

Exercice:

Quel code mettre dans la procédure Button_Click d'un bouton nommé 'Remise à zéro' qui met les 2 zones de saisie à zéro?

(Penser au flag)

Amélioration:

Si l'utilisateur tape une virgule il y a problème car la fonction Val utilisée pour convertir le nombre saisi en numérique reconnaît uniquement le point, il faut donc transformer les virgules en points avec

 
Sélectionnez

e = Replace(e, ",", ".")

On peut tester si l'utilisateur a bien tapé un nombre, avec la fonction IsNumeric.

IX-D. Exemple : Calcul d'un prêt (les fonctions financières de VB)

Comment créer un programme qui calcul les mensualités d'un prêt ?

Dans l'espace Microsoft.VisualBasic il existe des fonctions financières. (VB 2003 et VB 2005)

Pmt calcul les mensualités d'un prêt.

Remboursement mensuel= Pmt( Rate, NPer, PV, FV, Due)

Rate  
  Obligatoire. Donnée de type Double indiquant le taux d'intérêt par période. Si taux d'intérêt annuel de 10 pour cent et si vous effectuez des remboursements mensuels, le taux par échéance est de 0,1/12, soit 0,0083.
NPer  
  Obligatoire. Donnée de type Double indiquant le nombre total d'échéances. Par exemple, si vous effectuez des remboursements mensuels dans le cadre d'un emprunt de quatre ans,il y a 4 * 12 (soit 48) échéances.
PV  
  Obligatoire. Double indiquant la valeur actuelle . Par exemple, lorsque vous empruntez de l'argent pour acheter une voiture, le montant du prêt correspond à la valeur actuelle (pour un emprunts il est négatif).
FV  
  Facultatif. Double indiquant la valeur future ou le solde en liquide souhaité au terme du dernier remboursement. Par exemple, la valeur future d'un emprunt est de 0 F car il s'agit de sa valeur après le dernier remboursement. Par contre, si vous souhaitez économiser 70 000 F sur 15 ans, ce montant constitue la valeur future. Si cet argument est omis, 0 est utilisée par défaut.
Due  
  Facultatif. Objet de type Microsoft.VisualBasic.DueDate indiquant la date d'échéance des paiements. Cet argument doit être DueDate.EndOfPeriod si les paiements sont dus à terme échu ou DueDate.BegOfPeriod si les paiements sont dus à terme à échoir (remboursement en début de mois). Si cet argument est omis, DueDate.EndOfPeriod est utilisé par défaut.
   

Noter que si Rate est par mois NPer doit être en mois; si Rate est en année NPer doit être en année.

 
Sélectionnez

Sub CalculPret()
Dim PVal, Taux, FVal, Mensualite, NPerVal As Double
Dim PayType As DueDate

Dim Response As MsgBoxResult
Dim Fmt As String

Fmt = "###,###,##0.00" ' format d'affichage.
FVal = 0  '0 pour un prêt.
 

PVal = CDbl(InputBox("Combien voulez-vous emprunter?"))
Taux = CDbl(InputBox("Quel est le taux d'intérêt annuel?"))
If Taux > 1 Then Taux = Taux / 100 ' Si l'utilisateur à tapé 4 transformer en 0.04.
NPerVal =12* CDbl(InputBox("Durée du prêt (en années)?"))
Response = MsgBox("Echéance en fin de mois?", MsgBoxStyle.YesNo)
If Response = MsgBoxResult.No Then
  PayType = DueDate.BegOfPeriod
Else
  PayType = DueDate.EndOfPeriod
End If
Mensualite = Pmt(Taux / 12, NPerVal, -PVal, FVal, PayType)
MsgBox("Vos mensualités seront de " & Format(Mensualite, Fmt) & " par mois")
End Sub

 

IPmt calcul les intérêts pour une période.

 

Calculons le total des intérêts:

Dim IntPmt, Total, P As Double

For P = 1 To TotPmts ' Total all interest.
IntPmt = IPmt(APR / 12, P, NPerVal, -PVal, Fval, PayType)
Total = Total + IntPmt
Next Period

Autres mots clés :

Calculer l'amortissement. DDB, SLN, SYD
Calculer la valeur future. FV
Calculer le taux d'intérêt. Rate
Calculer le taux de rendement interne. IRR, MIRR
Calculer le nombre de périodes. NPer
Calculer les paiements. IPmt, Pmt, PPmt
Calculer la valeur actuelle. NPV, PV

Par exemple:
Rate Permet de calculer le taux d'un prêt en connaissant la somme prêtée, le nombre de mois et la mensualité.

IX-E. Ordre des instructions dans un module : résumé

Contenu des modules.

Dans quel ordre écrire les instructions, options, énumérations, Class, Sub dans un module?

Le code Visual Basic est stocké dans des modules (modules de formulaire, modules standard, modules de classe ..), chaque module est dans un fichier ayant l'extension '.vb". Les projets sont composés de plusieurs fichiers '.vb', lesquels sont compilés pour créer des applications.

Respecter l'ordre suivant :
  1. Instructions Option toujours en premier.(force des contraintes de déclaration de variables, de conversion de variables, de comparaison)
  2. Instructions Imports (charge des espaces de nom)
  3. Les énumérations, les structures 'générales'.
  4. Instructions Class, Module et Namespace, le cas échéant
  5. En haut de la classe du module les énumérations et structures 'locales'.
  6. Les Subs et Functions.

Exemple1: Un Formulaire.

 
Sélectionnez

Option Explicit On     'Toujours en premier.

 

Imports System.AppDomain

Imports Microsoft.VisualBasic.Conversion

 

Enum Fichier           'Ici une énumération utilisable dans la totalité du programme

    Doc

    Rtf

End Enum    

    

Public Class Form1         'la classe, le moule du formulaire

Inherits System.Windows.Forms.Form                    

    Dim WithEvents m As PrintDocument1                

#Region " Code généré par le Concepteur Windows Form"

                                                      

Public Sructure MaStructure  'Structure utilisable dans la Classe uniquement.

    i As Integer                                      

    J As Integer                                      

End Structure                                         

Public d As Integer                                   

                                                      

Private Sub Form1_Load(...) Handles Form.load        'Ici une Sub

    Dim A As integer                                  

    ...                                               

End Sub                                               

End Class    

On remarque de nouveau l'importance de l'endroit où les variables sont déclarées: Dans notre exemple A est accessible uniquement dans Form_Load, alors que d est public.

Exemple2: Un module standard Module2.

 
Sélectionnez

Imports System.Activator

Enum MyEnum  'Ici une énumération utilisable dans la totalité du programme

    Toto

    titi

End Enum

Structure MyStructure  'Ici une structure utilisable dans la totalité du programme

    Dim i As Integer

End Structure

 

Module Module2

Sub Main()    

End Sub       

End Module    

On remarque donc que Option et Imports sous toujours avant Class et Module.

La position de Enum et Structure (avant ou après les mots Class et module) gère leur visibilité.

Si vous entrez les instructions dans un ordre différent, vous risquez de créer des erreurs de compilation.


précédentsommairesuivant

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © . Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.