Le tableau suivant présente les types de données reconnus en précisant la taille des enregistrements et la plage des valeurs.
Type de données Taille en mémoire Plage Byte 1 octet 0 à 255 Boolean 2 octets True ou False Integer 2 octets -32 768 à 32 767 Long (entier long) 4 octets -2 147 483 648 à 2 147 483 647 Single (à virgule flottante en simple précision) 4 octets -3,402823E38 à -1,401298E-45 pour les valeurs négatives ; 1,401298E-45 à 3,402823E38 pour les valeurs positives
Double (à virgule flottante en double précision) 8 octets -1,79769313486232E308 à
-4,94065645841247E-324 pour les valeurs négatives ;4,94065645841247E-324 à 1,79769313486232E308 pour les valeurs positives
Currency (entier à décalage) 8 octets -922 337 203 685 477,5808 à 922 337 203 685 477,5807 Decimal 14 octets +/-79 228 162 514 264 337 593 543 950 335 sans séparateur décimal ;
+/-7,9 228 162 514 264 337 593 543 950 335 avec 28 chiffres à droite du séparateur décimal ;le plus petit nombre différent de zéro est +/-0.0000000000000000000000000001.
Date 8 octets 1er janvier 100 au 31 décembre 9999 Object 4 octets Toute référence à des données de type Object String
(longueur variable)10 octets + longueur de la chaîne 0 à environ 2 milliards String
(longueur fixe)Longueur de la chaîne 1 à environ 65 400 Variant (nombres) 16 octets Toute valeur numérique, avec la même plage de valeurs qu’une donnée de type Double Variant (caractères) 22 octets + longueur de la chaîne Même plage de valeurs qu’une donnée de type String de longueur variable Type défini par l’utilisateur
(avec Type)En fonction des éléments La plage de valeurs de chaque élément correspond à celle de son type de données. Note Quel que soit le type de données, les tableaux nécessitent 20 octets de mémoire, auxquels viennent s’ajouter quatre octets pour chaque dimension et le nombre d’octets occupés par les données. L’espace occupé en mémoire par les données peut être calculé en multipliant le nombre d’éléments par la taille de chacun d’eux. Par exemple, les données stockées dans un tableau unidimensionnel constitué de quatre éléments de type Integer de deux octets chacun occupent huit octets. Ajoutés aux 24 octets d’espace mémoire de base, ces huit octets de données portent la mémoire totale nécessaire pour le tableau à 32 octets.
Une variable de type Variant contenant un tableau nécessite 12 octets de plus qu’un tableau seul.
2 - Règles de nommage Visual Basic
Les noms d'objets doivent comporter un préfixe cohérent, permettant d'identifier facilement leur type. Vous trouverez ci-dessous la liste des conventions relatives à certains objets pris en charge par Visual Basic.
2.1 - choix des préfixes de contrôles.
Objet Nom Prefixe Exemple Barre de défilement verticale (VscrollBar) vsb vsbRate Bouton animé (AniPushButton) ani aniMailBox Bouton de commande (CommandButton) cmd cmdExit Cadre (Frame) fra fraLanguage Case à cocher (CheckBox) chk chkReadOnly Boites de dialogue communes (CommonDialog) dlg dlgFileOpen Communications (MSComm) com comFax Plan (Outline) out outOrgChart Contrôle (Control) (type spécifique inconnu) ctr ctrCurrent Contrôle de données (Data) dat datBiblio État (CrystalReport) rpt rptQtr1Earnings État de la touche (Mhstate) key keyCaps Étiquette (Label) lbl lblHelpMessage Feuille (Form) frm frmEntry Feuille MDI fille (MDI child form) mdi mdiNote Forme (Shape) shp shpCircle Graphique (Graph) gra graRevenue Grille (Grid) grd grdPrices Grille dépendante (DBGrid) dbgrd dbgrdQueryResult Image img imgIcon Image (Picture) pic picVGA Liste d’images (ImageList) ils ilsAllIcons Indicateur (Gauge) gau gauStatus Ligne (Line) lin linVertical Liste de fichiers (FileListBox) fil filSource Liste de dossiers (DirListBox) dir dirSource Liste de lecteurs (DriveList Box) drv drvTarget Liste modifiable dépendante (DBCombo) dbcbo dbcboLanguage Affichage de listes (ListView) lvw lvwHeadings Multimédia MCI mci mciVideo Menu mnu mnuFileOpen Message MAPI (MAPI message) mpm mpmSentMessage Minuterie (Timer) tmr tmrAlarm MS Flex grid msg msgClients Onglet (MSTab) mst mstFirst OLE ole oleWorksheet Panneau 3D (3D Panel) pnl pnlGroup Pen Bedit bed bedFirstName Pen Hedit hed hedSignature Pen ink ink inkMap Jeu d’image (PictureClip) clp clpToolbar Barre de progression (ProgressBar) prg prgLoadFile Éditeur RTF (RichTextBox) rtf rtfReport Session MAPI (MAPI session) mps mpsSession Curseur (Slider) sld sldScale Compteur (SpinButton) spn spnPages Barre d’état (StatusBar) sta staDateTime Barre d’onglets (TabStrip) tab tabOptions Barre d’outils (Toolbar) tlb tlbActions Affichage de l’arborescence (TreeView) tre treOrganization Barre de défilement (UpDown) upd updDirection Zone de liste (ListBox) lst lstPolicyCodes Zone de liste dépendante (Dblist) dblst dblstJobType zone de liste déroulante (ComboBox) cbo cboEnglish Zone de texte (TextBox) txt txtLastName
2.2 - Choix des préfixes d’objets d’accès aux données (DAO)
Utilisez les préfixes suivants pour signaler des objets d’accès aux données.
Objet de base de données Préfixe Exemple Container con conReports Database db dbAccounts DBEngine dbe dbeJet Document doc docSalesReport Field fld fldAddress Group grp grpFinance Index idx idxAge Parameter prm prmJobCode QueryDef qry qrySalesByRegion Recordset rec recForecast Relation rel relEmployeeDept TableDef tbd tbdCustomers User usr usrNew Workspace wsp wspMine Exemples :
Dim dbBiblio As Database
Dim recPubsInNY As Recordset, strSQLStmt As String
Const DB_READONLY = 4’ Définit la constante.
‘Ouvre la base de données.
Set dbBiblio = OpenDatabase(" BIBLIO.MDB ")
‘ Définit le texte de l’instruction SQL.
StrSQLStmt = " SELECT * FROM Publishers WHERE State =‘NY’ "
‘ Crée l’objet Recordset.
Set recPubsInNY = db.OpenRecordset(strSQLStmt, dbReadOnly)
2.3 - Choix des préfixes de menus
Les applications utilisent généralement de nombreux contrôles de menus ; il est donc utile d'adopter pour ces contrôles un ensemble unique de conventions d'affectation de noms. Nous vous conseillons d'ajouter à l'étiquette initiale "mnu " des préfixes de contrôles de menus un préfixe supplémentaire pour chaque niveau d'imbrication, le libellé de menu final figurant à la fin de la chaîne de nom. Le tableau suivant fournit quelques exemples.
Séquence de libellés de menu Nom du gestionnaire de menu Fichier Ouvrir mnuFileOpen Fichier Envoyer Email mnuFileSendEmail Fichier Envoyer télécopie mnuFileSendFax Format caractère mnuFormatCharacter Index d'Aide mnuHelpContents Si vous utilisez cette convention d'affectation de noms, tous les membres d'un menu donné figurent les uns à côté des autres dans la fenêtre Propriétés de Visual Basic. De plus, les noms de contrôles de menus permettent d'identifier facilement les éléments de menu auxquels ils sont associés.
2.4 - Choix de préfixes pour les autres contrôles
Pour les contrôles qui ne figurent pas ci-dessus, utilisez un préfixe standard, constitué de deux ou trois caractères. Utilisez plus de trois caractères uniquement si cela s’impose pour des raisons de clarté.
Pour les contrôles dérivés ou modifiés, par exemple, ajoutez des lettres aux préfixes ci-dessus afin d’éviter toute confusion quant au contrôle réellement utilisé. Pour les contrôles provenant de fournisseurs tiers, ajoutez au préfixe une abréviation en minuscules du nom du fournisseur. Par exemple, une instance d’un contrôle créé à l’aide du cadre 3D Visual Basic Édition Professionnelle peut être signalée par le préfixe fra3d afin d’éviter toute confusion quant au contrôle réellement utilisé.
Outre les objets, les constantes et les variables nécessitent également l’adoption de conventions d’affectation de noms standard. Cette section présente les conventions prises en charge par Visual Basic que nous vous recommandons d’utiliser. Elle traite également des problèmes d’identification du type de données et de la portée.
Il est conseillé de toujours définir les variables avec la plus petite portée possible. Les variables globales (Public) peuvent entraîner des situations d’une complexité extrême et rendre la logique d’une application très difficile à comprendre. Elles peuvent également rendre la réutilisation et la gestion de votre code beaucoup plus délicates.
2.5 - Portée des variables
Dans Visual Basic, les variables peuvent être dotées de la portée suivante :
Portée de la Déclaration Visible dans De niveau procédure ‘Private’ dans la procédure, la Sub ou la Fonction La procédure dans laquelle elle est déclarée De niveau module ‘Private’ dans la section des déclarations d’une feuille ou d’un module de code (.frm, .bas) Toute procédure dans la feuille ou le module de code Déclarations Globale’Public’ dans la section des déclarations d’un module de code Partout dans l’application Dans une application Visual Basic, il est conseillé de n’utiliser des variables globales que s’il n’existe aucun autre moyen adéquat de partager des données entre des feuilles. Si vous devez utiliser des variables globales, il est recommandé de les déclarer toutes dans un seul module, regroupées par fonction. Attribuez au module un nom évocateur, indiquant son but, tel que Public.bas.
Il est conseillé d’écrire un code modulaire chaque fois que cela est possible. Par exemple, si votre application affiche une boîte de dialogue, placez la totalité des contrôles et du code nécessaires à la tâche prévue pour la boîte de dialogue dans une feuille unique. Vous pouvez ainsi organiser le code de l’application en composants significatifs et gagner du temps au moment de l’exécution.
À l’exception des variables globales (qui ne doivent pas être passées), les procédures et les fonctions ne doivent traiter que des objets qui leur sont transmis. Les variables globales utilisées dans des procédures doivent être indiquées dans la section des déclarations au début de la procédure. De plus, il est conseillé de transmettre des arguments aux procédures Sub et aux fonctions à l’aide du mot clé ByVal, à moins que vous ne soyez obligé de modifier explicitement la valeur de l’argument transmis.
2.6 - Préfixes de portée de variables
Plus le projet grandit, plus il est important de déterminer rapidement la portée des variables. Un préfixe de portée constitué d'une lettre précédant le préfixe de type permet d'arriver à ce résultat sans pour autant augmenter de manière significative la taille des noms de variables.
Portée Préfixe Exemple Globale g gstrUserName De niveau module m mblnCalcInProgress Locale à une procédure Aucun dblVelocity Une variable est dotée d'une portée globale si elle est déclarée comme Public dans un module standard ou un module de la feuille. Une variable est dotée d'une portée de niveau module si elle est déclarée comme Private, respectivement dans un module standard ou un module de feuille.
Note : Pour que cette technique vous apporte tous les avantages escomptés, il est absolument nécessaire d'être cohérent ; en effet, le vérificateur de syntaxe de Visual Basic ne s'arrêtera pas sur des variables de niveau module commençant par la lettre "p".
2.7 - Constantes
Le corps des noms de constantes doit être constitué de lettres de casse différente, chaque mot commençant par une lettre majuscule. Bien que les constantes Visual Basic standard ne comprennent pas d'informations sur le type de données et la portée, des préfixes tels que i, s, g et m peuvent s'avérer très utiles pour comprendre la valeur et la portée d'une constante. Pour les noms de constantes, respectez les mêmes conventions que pour les variables. Exemple :
mintUserListMax'Limite d'entrée maximale de la liste des utilisateurs (nombre entier, local à un module)
gstrNewLine'Caractère de saut de ligne (chaîne, globale à une application)
2.8 - Variables
Le fait de déclarer toutes les variables réduit le temps de programmation en limitant le nombre d'erreurs causées par des fautes de frappe (par exemple : aUserNameTmp, sUserNameTmp et sUserNameTemp). Dans l'onglet Éditeur de la boîte de dialogue Options, cochez l'option Requiert la déclaration de variables. L'instruction Option Explicit vous oblige à déclarer toutes les variables dans votre programme Visual Basic.
Les variables doivent comporter un préfixe indiquant leur type de données. Ce préfixe peut éventuellement être complété pour indiquer la portée de la variable, en particulier dans le cas de programmes volumineux.
2.9 - Type de données des variables
Utilisez les préfixes suivants pour indiquer le type de données d’une variable.
Type de données Préfixe Exemple Boolean bln blnFound Byte byt bytRasterData Collection (Objet) col colWidgets Currency cur curRevenue Date (Time) dtm dtmStart Double dbl dblTolerance Error err errOrderNum Integer int intQuantity Long lng lngDistance Object obj objCurrent Single sng sngAverage String str strFName Type défini par l’utilisateur udt udtEmployee Variant vnt vntCheckSum
2.10 - Noms de procédures et de variables descriptifs
Le corps d'un nom de variable ou de procédure doit comporter des lettres de casse différente et être aussi long que la description de sa fonction le demande. De plus, les noms de fonction doivent commencer par un verbe, tel que InitNameArray ou CloseDialog.
Pour les termes fréquemment utilisés ou particulièrement longs, nous vous recommandons d'utiliser des abréviations standard afin de réduire la longueur des noms. En règle générale, des noms de variables supérieurs à 32 caractères peuvent devenir difficiles à lire en affichage VGA.
Si vous utilisez des abréviations, vérifiez qu'elles sont cohérentes dans la totalité de l'application. Par exemple, l'utilisation de Cnt et Count indifféremment dans un projet risque de semer la confusion.
2.11 - Types définis par l'utilisateur
Dans un gros projet comportant de nombreux types définis par l'utilisateur, il est très utile d'attribuer à chacun d'entre eux un préfixe de trois caractères distincts. Si ces préfixes commencent par la lettre "u", ils seront aisément identifiables lorsque vous travaillerez avec un type défini par l'utilisateur. Par exemple, le préfixe "ucli" peut être utilisé pour les variables dotées du type défini par l'utilisateur Client.
3.1 - Structure d'un tableau.
On a souvent besoin de travailler sur un ensemble de données.
Un exemple : les températures moyennes des 12 mois de l'année.
On pourrait déclarer 12 variables identiques :
Dim Temp1, Temp2, Temp3, Temp4, … … …, Temp12 as SingleOn dispose d'une structure de données appelée Tableau qui permet de conserver dans une seule "entité" plusieurs valeurs de même type.
Le nom du tableau est une variable qu'il est recommandé de préfixer par Tab.
Le nombre de valeurs de types identiques est à déclarer entre parenthèses.Exemple de déclaration d’un tableau à une dimension :
Dim TabTemp(12) As Single
Numéro 1 2 3 4 5 ...Température 6 5.5 7 11.5 15 ...L'accés à la case numéro 3 se fait par TabTemp(3) qui vaut 7.
Exemple de déclaration d’un tableau à deux dimensions :
Dim TabMajMin(1 to 2,65 to 90) As String
Numéro 65 66 67 ... 89 901 A B C ... Y Z 2 a b c ... y zL'accés à la case qui contient le petit "c"se fait grâce à la syntaxe suivante : TabMajMin(2,67) qui vaut "c".
3.2 - Boucles.
La Boucle "For Next" :
Cette boucle est utilisée lorsqu’on connaît à l’avance le nombre de fois qu’elle sera parcourue.
Syntaxe :
For Compteur = Début To Fin [Step Incrément]Instructions[ ... Exit For][Instructions]Next [Compteur]Le test est effectué au début de la boucle.
La variable numérique Compteur est incrémentée à chaque fin de boucle du nombre indiqué par l’incrément. Si l’incrément n’est pas spécifié il est fixé à 1.
Si la valeur de Fin est inférieure à la valeur de Début l’incrément est négatif.
La valeur de Compteur peut être utilisée (par exemple pour numéroter le passage dans la boucle) mais ne doit pas être modifiée dans le corps de la boucle.Exemple :
Pour remplir un tableau on le balaye avec une boucle For … To … Next (car le nombre de cases est connu à l'avance).
For i = 1 To 50TabInitial(i) = 0 ‘ Initialisation de chaque case à 0
Next i
La Boucle "tant que" :
Syntaxe première version :
Do While ConditionInstructions
[... Exit Do]
[Instructions]
Loop
La condition est ici testée au début c'est à dire à l’entrée de la boucle.
Avec While (tant que) la boucle est répétée tant que la condition est vraie.
Si la condition n’est pas vraie au départ les instructions de la boucle ne sont pas exécutées.Exemple :
Do While MotProposé <> MotDePasseMotProposé = InputBox("Donnez votre mot de passe")
Loop
Cela présuppose MotProposé initialisé par une valeur autre que MotDePasse (par exemple la valeur par défaut "").
Syntaxe deuxième version :
DoInstructions
[... Exit Do]
[Instructions]
Loop While Condition
La condition est alors testée à la fin de la boucle.
Avec While (tant que) la boucle est répétée tant que la condition est vraie.
Les instructions de la boucle sont donc exécutées au moins une fois.Exemple :
DoMotProposé = InputBox("Donnez votre mot de passe")
Loop While MotProposé <> MotDePasse
Cet exemple ne présuppose aucune initialisation de MotProposé.
Les boucles "Tant que", "Jusqu’à" :
Syntaxe :
DoInstructions
[... Exit Do]
[Instructions]
Loop Until Condition
La condition est alors testée à la fin de la boucle.
Les instructions de la boucle sont donc exécutées au moins une fois.
Avec Until ("Jusqu'à") la boucle est répétée jusqu'à ce que la condition soit vraie.Exemple :
DoMotProposé = InputBox("Donnez votre mot de passe")
Loop Until MotProposé = MotDePasse
Cet exemple ne présuppose aucune initialisation de MotProposé.
Boucle For … Each … Next :C’est une extension de la boucle For ... To … Next. Elle est utilisée pour parcourir les collections(ensembles).
Syntaxe :
For Each Elément In EnsembleInstructions
[ ... Exit For]
[Instructions]
Next [Elément]
Ensemble est le plus souvent un tableau.
Exemple :
Dim TabHasard(100) As Integer
Dim Cellule As Integer
Dim Réponse As String
Randomize
For Each Cellule In TabHasardCellule = Rnd * 100 + 1
Next
For Each Cellule In TabHasardRéponse = Réponse & Cellule & " "
Next
MsgBox (Réponse)
Les données manipulées par un programme sont essentiellement des nombres (type numérique) ou du texte (chaîne de caractères).
Une variable chaîne de caractères se déclare avec le type String.Exemple 1 :
Dim MotProposé As String
La variable contient alors une chaîne de longueur variable selon l'affectation qui suivra.Exemple 2 :
Dim Lettre As String * 1
La variable contient alors une chaîne de longueur 1 c'est à dire un seul caractère.Exemple 3 :
Dim Adresse As String * 30
La variable contient alors une chaîne de longueur 30. Si l'on n'affecte que 18 caractères dans une telle chaîne, le reste est rempli d'espaces. Si l'on affecte plus de 30 caractères le surplus est tronqué.4.1 - Comparaison de chaînes de charactères.
Longueur d'une chaîne :
La longueur d'une chaîne est donnée par la fonction Len.
Exemple :
Phrase = "Visual Basic”
La fonction Len(Phrase) retournera la valeur 12.
Il est évident que si deux chaînes de caractères n'ont pas la même longueur elles sont différentes. Par contre deux chaînes de même longueur ne sont pas forcément identiques.
Comparaison binaire :
On compare deux chaînes par la fonction StrComp.
Elle renvoie la valeur numérique 0 si les deux chaînes sont rigoureusement identiques et la valeur numérique 1 si les chaînes diffèrent même par un seul octet.
Exemple :
Phrase1 = "Visual Basic."
Phrase2 = "Visual basic."
Phrase3 = " Visual Basic.”
La fonction StrComp(Phrase1,Phrase2) retournera la valeur …
La fonction StrComp(Phrase1,Phrase3) retournera la valeur …Recherche d'une chaîne de caractères :
La fonction InStr permet de rechercher si une chaîne de caractères existe à l'intérieur d'une autre chaîne de caractères. Si c’est le cas, elle retourne la position de la première occurrence de la chaîne recherchée.
Syntaxe :
InStr(Chaîne1, Chaîne2)
Chaîne1 est la chaîne de caractères à traiter (sur laquelle porte la recherche).
Chaîne2 est la chaîne de caractères recherchée dans Chaîne1.
Exemple :
Chaîne1 = "Visual Basic et ses fonctions"
Chaîne2 = "Basic"
Chaîne3 = "Basics"
La fonction InStr(Chaîne1,Chaîne2) retournera la valeur 8
La fonction InStr(Chaîne1,Chaîne3) retournera la valeur 0.Autres fonctions utiles :
La fonction Ucase met tout le texte en majuscules et permet de rechercher indépendamment une lettre minuscule ou majuscule.La fonction Lcase met tout le texte en minuscules et permet…
La fonction Right donne la partie droite d'une chaîne de caractères. Le nombre de caractères de cette partie doit être précisé.
Exemple :
Chaîne = "Visual Basic et ses fonctions"
La fonction Right(Chaîne,5) retournera la valeur "tions"La fonction Left donne la partie gauche d'une chaîne de caractères. Le nombre de caractères de cette partie doit être précisé.
Exemple :
Chaîne = "Visual Basic et ses fonctions"
La fonction Left(Chaîne,5) retournera la valeur "Visua"La fonction Mid extrait une partie d'une chaîne de caractères.
Le nombre de caractères de cette partie doit être précisé ainsi que la position du premier caractère extrait.
Syntaxe :
Mid(Texte, Position, Nombre)
Texte est la chaîne de caractère à traiter.
Position est la position du caractère à partir duquel il faut extraire une sous-chaîne de caractères.
Nombre est le nombre de caractères à extraire.
Exemple :
Chaîne = "Visual Basic et ses fonctions"
La fonction Mid(Chaîne,8,5) retournera la valeur "Basic"
La fonction Mid(Chaîne,21) retournera la valeur "fonctions"
Exemple pour Rechercher un mot dans une chaîne de caractères :
Dim Chaine, Mot As String
Dim Position As Integer
Chaine = "Visual Basic et ses fonctions."
Mot = InputBox("Taper le mot à rechercher")
Position = InStr(Chaine, Mot)
If Position = 0 ThenMsgBox "Le mot '" & Mot & "'" & " n'a pas été introuvé !")
Else
MsgBox("Le mot '" & Mot & "'"&" a été trouvé à la position "_
& Position)End If
Exemple pour Compter le nombre d'espaces dans une chaîne :
Dim Phrase, Caractère As String
Dim Compteur, Longueur, i As Integer
Phrase = InputBox("Tapez votre phrase")
Longueur = Len (Phrase)
For i = 1 To LongueurCaractère = Mid(Phrase, i, 1)
If Caractère = " " Then Compteur = Compteur + 1Next i
MsgBox("Cette phrase contient " & Compteur & " espaces.")
La fonction Date donne la date système.
La fonction Time donne l'heure système.
La fonction Day() donne le numéro du jour dans le mois.
La fonction Month() donne le numéro du mois dans l'année.
La fonction Year() donne le numéro de l'année.
La fonction WeekDay() donne le numéro du jour dans la semaine sachant que le dimanche porte le numéro 1.
La fonction FormatDateTime(date [, constante vb]) donne Retourne une expression formatée sous forme de date ou d’heure. Où constante vb peut prendre les valeurs suivantes : [, vGeneralDate ou vbLongDate, vbShortDate, vbShortTime, …]Get Déclare le nom, les arguments et le code formant le corps d'une procédure Property, qui lit la valeur d'une propriété.
Syntaxe:
[Public | Private | Friend] [Static] Property Get NomPropriété [(arglist)] [As type]
[instructions]
[Exit Property]
[instructions]
End PropertyLet : Déclare le nom, les arguments et le code formant le corps d'une procédure Property Let, qui attribue une valeur à une propriété.
Syntaxe
[Public | Private | Friend] [Static] Property Let name ([arglist,] value)
[instructions]
[Exit Property]
[instructions]
End PropertyExemple :
Private dblBalance As DoublePublic Property Get Balance() As Double
Balance = dblBalance
End Property
Property Let Balance(dblNewBalance As Double)
dblBalance = dblNewBalance
End Property
CallByName : cette fonction permet d’obtenir ou de définir une propriété ou d’invoquer une méthode pendant l’exécution.
Syntaxe :
CallByName(Objet, NomProcédure,CallType)
Où :
- Objet(objet variant) est le nom de l’objet sur lequel on souhaite exécuter la fonction CallByName.
- NomProcédure (variant) désigne le nom de la propriété ou de la méthode de l’objet .
- CallType est une constante qui représente le type de procédure appelée(vbGet, VbLet,vbMethod).Exemple :
- Obtenir le contenu de la propriété NomGroupe de l’objet objGroupe :
Resulat = CallByName(objgroupe, “NomGroupe”, VbGet)
- Définir la propriété NomGroupe de l’objet objGroupe :
CallByName(objgroupe, ObjField.Name, VbLet)
- Exécuter la méthode "InitialisationObj" de l’objet objGroupe :
CallByName(objgroupe, “InitialisationObj”, Vbmethod)
Les procédures :
Une procédure est un ensemble d'instructions qui traite une tâche donnée.
Elle débute par le mot réservé Sub et se termine par End Sub.Exemple de procédure événementielle :
Private Sub cmdQuitter_Click
End
End SubSi un bloc d'instructions doit être utilisé à plusieurs endroits (par exemple dans plusieurs procédures événementielles) il est préférable d'en faire une procédure publique qui sera pourra être appelée dans n’importe quel autre sous-programme du module.
Exemple de procédure publique :
Public Sub SaisieNote()
Do
Note = InputBox("Tapez une note")
Loop Until Note>=0 And Note<=20
End Sub
Pour utiliser cette procédure il suffira de l'appeler par son nom : SaisieNoteLes fonctions :
Une fonction débute par le mot réservé Function et se termine par End Function.
Elle a un type et peut retourner une valeur contenue dans le nom même de la fonction. Cette valeur pourra être utilisée par la suite dans une autre expression.Exemple de fonction :
Public Function Carré(x) As Single
Carré = x * x
End Function
Par exemple Carré(7) retournera la valeur 49.Les procédures Property :
Elles servent à définir les propriétés d’un objet par exemple dans un module, dans une classe ou dans une feuille. Elles sont délimitée par les mots clés Property et End Property.
Exemple de propriété :
Public Property Let Nom(ByVal parametre As String)
mvarNom = parametre
End Property
Remarques :
ByVal Indique que l'argument est passé par valeur.
ByRef(valeur par défaut). Indique que l'argument est passé par référence
1 - Créer un programme standard (sans DLL).
Ajouter ou retrancher un nombre à un autre (deux fonctions <> deux boutons)
Créer un nouveau projet VB5 "EXE Standard".
Ajouter dans la form (feuille) trois TextBox : Text1, Text2, Text3
et deux boutons : Command1 et Command2 (un pour chaque fonction).
Puis saisissez le code suivant :
Private Sub Command1_Click()
Text3.Text = CLng(Text1.Text) + CLng(Text2.Text)
End Sub
Private Sub Command2_Click()
Text3.Text = CLng(Text1.Text) - CLng(Text2.Text)
End Sub
Exemple1 : Le programme standard sans DLL.
Testez le programme (rien d'extraordinaire, c'est une calculatrice deux fonctions)
2 - Créer un programme standard et une DLL.
Dans le même projet ajouter un nouveau projet ActiveX DLL. (Fichier - Ajouter projet).
Dans le projet DLL vous trouverez une Class destinée à recevoir le code des fonctions, ouvrer la Class et saisissez le code suivant :
Public Function Ajouter(Op1 As Long, op2 As Long) As Long
Ajouter = Op1 + op2
End Function
Public Function Oter(Op1 As Long, op2 As Long) As Long
Oter = Op1 - op2
End Function
Exemple 1 : Le code de la DLL.
Nous retrouvons ici le source de nos deux fonctions Ajouter et Oter, ces fonctions sont déclarés "public" afin que les programmes appelants puissent les "voir".
Si nous les avions déclarés "private", elles ne serait pas visible depuis les programmes appelants, se sont alors des fonctions internes à la DLL qui sont par exemple utilisées par les fonctions "public"
3 - Le code de notre programme appelant.
Remplacer le code du premier programme par celui-ci
Puis saisissez le code suivant :
Private MesFonctions As Class1
Private Sub Command1_Click()
Set MesFonctions = New Class1
Text3.Text = MesFonctions.ajouter(CLng(Text1.Text), CLng(Text2.Text))
Set MesFonctions = Nothing
End Sub
Private Sub Command2_Click()
Set MesFonctions = New Class1
Text3.Text = MesFonctions.oter(CLng(Text1.Text), CLng(Text2.Text))
Set MesFonctions = Nothing
End Sub
Depuis votre projet EXE aller dans le Menu Projet-Références sélectionner (cocher) votre DLL dans la liste pour la référencer dans votre projet (noter au passage que de nombreuse DLL sont ici accessible comme Microsoft Excel, Word, DAO pour les accés bases de données ...).
Si votre Dll n'apparait pas dans la liste compilez-la (file-make MaDll.dll)
Lancez le programme, le resultat est le même que dans l'exemple initial, mais les fonctions sont en DLL, elle sont donc réutilisable à souhait et cela apporte des gains enorme dans les développements (ecrire une fois, utiliser dans plusieurs programmes).
Autre avantage et de taille :
Set MesFonctions = Nothing
Cette instruction libère la mémoire réservée par la DLL ainsi vous verrez la taille de votre exécutable fondre mais aussi la place mémoire occupée par le programme.
Variables publics pour ou contre ?
Lorsque nous écrivons une DLL, nous sommes tous tentés d'utiliser des variables Publics qui serviront par exemple de propriétés.
Public MaPropriété as String
Cela pose plusieurs problèmes :
MaPropriété sera consultable par tous les programmes qui utilisent la DLL mais ça, c'est justement ce que l'on veut. Mais chaque programme pourrat aussi mettre à jour cette "propriété", et là les problémes commence car la DLL n'est pas en mesure de tester les valeurs fixées à MaPropriété, elle perd le contrôle sur MaPropriété.
MaDll.MaPropriété = 1 'Ce n'est pas un string mais ça va passer !!!!
Je n'ose même pas penser au conséquence si MaPropriété etait Static c'est à dire partagé par tous les programmes qui utilisent Ma DLL.
Pour éviter ce genre de problème nous utilisons généralement ceci :
Private p_MaPropriété as String
Public Property Get MaPropriété() As string
MaPropriété = p_MaPropriété
End Property
Public Property Let MaPropriété(valeur as String)
'Ajouter les testes ICI
p_MaPropriété = MaPropriété
End Property
Ainsi lorsque je fixe un valeur à MaPropriété, je peux ajouter tous les testes possibles, mais je peux aussi retirer la possibilité de mettre à jour MaPropriété (en retirant Public Property Let MaPropriété(valeur as String).....End Property)
Un conseil n'utilisez jamais de caractères accentués dans les nom de variables, méthodes, propriétés....
1 - Une DLL C simple avec Visual C++ 5.
Avec VC++5.0 créer un nouveau projet Win32 Dynamic-Link Library.
Créer un nouveau fichier de définition (.def) :
LIBRARY MaDLL
EXPORTS
AjouteDouble @1
OteDouble @2
Exemple1 : Le fichier .DEF.
AjouteDouble et OteDouble sont les deux fonctions que nous allons retrouver dans notre source C. Pour ajouter de nouvelle fonctions, les inscrirent dans le fichier .def et augmenter le numéro de fonction : DiviseDouble @3
Puis créer un nouveau fichier contenant les fonctions de la DLL (.c) :
#include <windows.h>
#include <ole2.h>
double _stdcall AjouteDouble(double a, double b)
{
return (a + b);
}
double _stdcall OteDouble(double a, double b)
{
return (a - b);
}
Exemple 1 : Le source.
Nous retrouvons ici le source de nos deux fonctions AjouteDouble et OteDouble et le code qui leurs est associés.
Enfin construire la DLL (Rebuild All).
La DLL devrat enfin être copiée dans le répertoire system de Windows (c:\WinNt\System32 pour NT)
2 - Utilisation de la DLL dans VB 5.
Créer un nouveau projet VB5 "EXE Standard".
Ajouter dans la form (feuille) trois TextBox : Text1, Text2, Text3
et deux boutons : Command1 et Command2 (un pour chaque fonction).
Puis saisissez le code suivant :
Option Explicit
' Déclaration de la fonction externe AjouteDouble
Private Declare Function AjouteDouble _
Lib "MaDLL.dll" ( _
ByVal a as double, _
ByVal a as double _
) as double
' Déclaration de la fonction externe OteDouble
Private Declare Function OteDouble _
Lib "MaDLL.dll" ( _
ByVal a as double, _
ByVal a as double _
) as double
___________________________________________________________________________
Private Sub Command1_Click()
' Text3 contient la valeur de retour (le resultat) de la fonction AjouteDouble
' alors que Text1 et Text2 sont les deux paramètres de la fonction
' La fonction retourne un double, pour cette raison, nous devons le convertir en texte (Str)
' Les paramètres de la fonction C sont des double, nous devons donc convertir Text1 et Text2 en double (Clng)
Text3.text = Str(AjouteDouble(Clng(Text1.Text), Clng(Text2.Text)))
End Sub
__________________________________________________________________________
Private Sub Command2_Click()
' Text3 contient la valeur de retour (le resultat) de la fonction OteDouble
' alors que Text1 et Text2 sont les deux paramètres de la fonction
' La fonction retourne un double, pour cette raison, nous devons le convertir en texte (Str)
' Les paramètres de la fonction C sont des double, nous devons donc convertir Text1 et Text2 en double (Clng)
Text3.text = Str(OteDouble(Clng(Text1.Text), Clng(Text2.Text)))
End Sub
Le plus simple est d'utiliser l'API qui est à généreusement mise à notre disposition : GetUserName
Private Declare Function GetUserName Lib "advapi32.dll" Alias "GetUserNameA" (ByVal lpBuffer As String, nSize As Long) As Long
Private Sub Command1_Click()
Dim strBuffer As String * 255
Dim lngBufferLength As Long
Dim lngRet As Long
Dim strTemp As String
lngBufferLength = 255
lngRet = GetUserName(strBuffer, lngBufferLength)
strTemp = UCase(Trim$(strBuffer))
NTDomainUserName = Left$(strTemp, Len(strTemp) - 1)
Label1.Caption = NTDomainUserName ' Ne pas oublier le label Label1dans la form...
End Sub