INFO : Conventions d'affectation de noms de MCS (Microsoft Consulting Services) pour Visual Basic

Traductions disponibles Traductions disponibles
Numéro d'article: 110264 - Voir les produits auxquels s'applique cet article
Ancien nº de publication de cet article : F110264
Agrandir tout | Réduire tout

Sommaire

Résumé

Il est judicieux d'établir des conventions d'affectation de noms pour votre code Visual Basic. Cet article vous donne les conventions d'affectation de noms utilisées par MCS (Microsoft Consulting Services).

Il rassemble les conventions de codage de Visual Basic que vous pouvez trouver dans le Guide du programmeur Visual Basic.

REMARQUE : Les contrôles tiers mentionnés dans cet article sont fabriqués par des fournisseurs indépendants de Microsoft. Microsoft exclut toute garantie, implicite ou autre, concernant les performances ou la fiabilité de ces contrôles.

Plus d'informations

Les conventions d'affectation de noms aident les programmeurs de Visual Basic à :

  • normaliser la structure, le style de codage et la logique d'une application.
  • créer un code source précis, lisible et non ambigu.
  • être cohérent avec les conventions d'autres langages (notamment le Guide du programmeur Visual Basic et la notation hongroise Windows C standard).
  • être efficace du point de vue de la longueur des chaînes et du travail, offrant ainsi plus de possibilités pour des noms d'objets plus longs et plus complets.
  • définir les exigences minimales nécessaires pour atteindre les objectifs ci-dessus.

Définition des options de l'environnement

Utilisez Option Explicit. Déclarez toutes les variables pour réduire le temps de programmation en diminuant le nombre de bogues causés par les fautes de frappe (par exemple, aUserNameTmp, sUserNameTmp et sUserNameTemp). Dans la boîte de dialogue Options d'environnement, définissez Déclaration des variables obligatoire sur Oui. L'instruction Option Explicit requiert la déclaration de toutes les variables dans votre programme Visual Basic. Enregistrez les fichiers en texte ASCII. Enregistrez les fichiers de feuille (.FRM) et de module (.BAS) en texte ASCII pour faciliter l'utilisation des systèmes de contrôle de version et minimiser les problèmes liés aux altérations du disque. De plus, vous pouvez :

  • utiliser votre propre éditeur
  • utiliser des outils automatisés, tels que grep
  • créer la génération de code ou les outils CASE pour Visual Basic
  • effectuer une analyse externe de votre code Visual Basic
Pour que Visual Basic enregistre toujours vos fichiers en texte ASCII, définissez l'option Format d'enregistrement par défaut sur Texte dans la boîte de dialogue Options d'environnement.

Conventions d'affectation de noms d'objets pour les objets standard

Les tableaux suivants définissent les préfixes des noms d'objets standard de MCS. Ces préfixes sont cohérents avec ceux qui figurent dans le Guide du programmeur Visual Basic.
Préfixe    Type d'objet                                        Exemple
----------------------------------------------------------------------
ani       Bouton Animation                                     aniMailBox
bed       Stylet Bedit                                         bedFirstName
cbo       Liste modifiable et zone de liste déroulante         cboEnglish
chk       Case à cocher                                        chkReadOnly
clp       Clip image                                           clpToolbar
cmd (3d)  Bouton de commande (3D)                              cmdOk (cmd3dOk)
com       Communications                                       comFax
ctr       Contrôle (si type spécifique inconnu)                ctrCurrent
dat       Contrôle Data                                        datBiblio
dir       Zone de liste de répertoires                         dirSource
dlg       Contrôle Common dialog                               dlgFileOpen
drv       Zone de liste de lecteurs                            drvTarget
fil       Zone de liste de fichiers                            filSource
frm       Feuille                                              frmEntry
fra (3d)  Cadre (3d)                                           fraStyle (fra3dStyle)
gau       Indicateur                                           gauStatus
gpb       Groupe de boutons                                    gpbChannel
gra       Graphique                                            graRevenue
grd       Grille                                               grdPrices
hed       Stylet Hedit                                         hedSignature
hsb       Barre de défilement horizontale                      hsbVolume
img       Image                                                imgIcon
ink       Encre stylet                                         inkMap
key       Statut touches clavier                               keyCaps
lbl       Étiquette                                            lblHelpMessage
lin       Ligne                                                linVertical
lst       Zone de liste                                        lstPolicyCodes
mdi       Feuille MDI fille                                    mdiNote
mpm       Message MAPI                                         mpmSentMessage
mps       Session MAPI                                         mpsSession
mci       MCI                                                  mciVideo
mnu       Menu                                                 mnuFileOpen
opt (3d)  Bouton d'option (3d)                                 optRed (opt3dRed)
ole       Contrôle OLE                                         oleWorksheet
out       Contrôle Outline                                     outOrgChart
pic       Image                                                picVGA
pnl3d     Panel 3d                                             pnl3d
rpt       Contrôle Report                                      rptQtr1Earnings
shp       Contrôles Shape                                      shpCircle
spn       Contrôle Spin                                        spnPages
txt       Zone de texte                                        txtLastName
tmr       Minuterie                                            tmrAlarm
vsb       Barre de défilement verticale                        vsbRate

Convention d'affectation de noms d'objets pour les objets de base de données

Préfixe        Type d'objet                    Exemple
------------------------------------------------------
db            Base de données ODBC             dbAccounts
ds            Objet Dynaset ODBC               dsSalesByRegion
fdc           Collection Field                 fdcCustomer
fd            Objet Field                      fdAddress
ix            Objet Index                      ixAge
ixc           Collection Index                 ixcNewAge
qd            Objet QueryDef                   qdSalesByRegion
qry (suffixe) Requête (voir REMARQUE)          SalesByRegionQry
ss            Objet Snapshot                   ssForecast
tb            Objet Table                      tbCustomer
td            Objet TableDef                   tdCustomers
REMARQUE : L'utilisation d'un suffixe pour les requêtes permet à chaque requête d'être triée avec sa table associée dans les boîtes de dialogue Microsoft Access (Ajouter une table, Lister les tables Snapshot).

Conventions d'affectation de noms des menus

Les applications utilisent fréquemment de très nombreux contrôles Menu. Par conséquent, vous devez utiliser un jeu différent de conventions d'affectation de noms pour ces contrôles. Les préfixes des contrôles Menu doivent être étendus au-delà de l'étiquette mnu initiale par l'ajout d'un préfixe supplémentaire pour chaque niveau d'imbrication, avec la légende de menu finale à la fin de la chaîne du nom. Par exemple :
Séquence de menus         Nom du gestionnaire de menu
Aide.Sommaire             mnuAideSommaire
Fichier.Ouvrir            mnuFichierOuvrir
Format.Caractère          mnuFormatCaractère
Fichier.Envoyer.Fax       mnuFichierEnvoyerFax
Fichier.Envoyer.Email     mnuFichierEnvoyerEmail
Lorsque cette convention est utilisée, tous les membres d'un groupe de menus particulier sont listés les uns à côté des autres dans les zones de liste déroulantes d'objets (dans la fenêtre de code et la fenêtre des propriétés). De plus, les noms des contrôles de menu documentent clairement les éléments des menus auxquels ils se rapportent.

Conventions d'affectation de noms des menus pour les autres contrôles

Pour les nouveaux contrôles qui ne sont pas énumérés ci-dessus, essayez de trouver un préfixe unique de trois caractères. Cependant, il est plus important d'être clair que d'adhérer à tout prix à la règle des trois caractères.

Pour les contrôles dérivés, tels qu'une zone de liste améliorée, étendez les préfixes ci-dessus de sorte qu'il n'y ait pas de confusion quant au contrôle réellement utilisé. Une abréviation du fabricant en minuscules pourrait aussi être ajoutée au préfixe. Par exemple, vous pouvez utiliser un préfixe fra3d pour une instance de contrôle créée à partir du cadre 3D de Visual Basic Professional pour éviter toute confusion quant au contrôle réellement utilisé. Vous pouvez utiliser cmdm pour un bouton de commande MicroHelp pour le différencier d'un bouton de commande standard (cmd).

Contrôles tiers

Chaque contrôle tiers utilisé dans une application doit être énuméré dans la section de commentaires de présentation de l'application, donnant le préfixe utilisé pour le contrôle, le nom complet du contrôle et le nom du fournisseur de logiciel :
Préfixe    Type de contrôle        Fournisseur
cmdm       Bouton de commande      MicroHelp

Affectation de noms des variables et des routines

Les noms des variables et des fonctions ont la structure suivante : <préfixe><corps><qualificateur><suffixe>
Partie            Description                                       Exemple
-------------------------------------------------------------------------------
<préfixe>         Décrit l'utilisation et la portée de la variable. iGetRecordNext
<corps>           Décrit la variable.                               iGetNameFirst
<qualificateur>   Signale un dérivé de la variable.                 iGetNameLast
<suffixe>         Caractère Visual Basic facultatif.                iGetRecordNext%
Préfixes :

Les tableaux suivants définissent les préfixes des variables et des noms de fonction qui sont basés sur la notation C hongroise pour Windows. Ces préfixes doivent être utilisés avec toutes les variables et les noms de fonction. L'utilisation des anciens suffixes Basic (tels que %, &, #, etc.) est déconseillée.

Préfixes des variables et des noms de fonction :
Préfixe    Convergé    Utilisation variable         Type de données  Suffixe
--------------------------------------------------------------------------
b         bln          Booléen                      Entier           %
c         cur          Monétaire - 64 bits          Monétaire        @
d         dbl          Double - Quantité            Double           #
                       signée 64 bits
dt        dat          Date et heure                Variante
e         err          Erreur
f         sng          Flottant/Unique - Virgule    Unique           !
                       flottante signée
                       32 bits
h                      Descripteur                  Entier           %
i                      Index                        Entier           %
l         lng          Longue - Quantité            Longue           &
                       signée 32 bits
n         int          Nombre/Compteur              Entier           %
s         str          Chaîne                       Chaîne           $
u                      Non signée - Quantité        Longue           &
                       non signée 16 bits
          udt          Type défini par l'utilisateur
vnt       vnt          Variante                     Variante
a                      Tableau
REMARQUE : Les valeurs dans la colonne Convergé correspondent aux efforts conjugués pour réunir les affectations de noms standard de Visual Basic, Visual Basic for Applications et Access Basic. Il est probable que ces préfixes deviendront des standards Microsoft dans un avenir proche.

Préfixes de portée et d'utilisation :
Préfixe           Description
g                 Global
m                 Local au module ou à la feuille
st                Variable statique
(pas de préfixe)  Variable non statique, préfixe local à la procédure
v                 Variable passée par valeur (local à une routine)
r                 Variable passée par référence (locale à une routine)
La notation hongroise est aussi utile en Visual Basic qu'en C. Bien que les suffixes Visual Basic indiquent le type de données d'une variable, ils n'expliquent ni comment une variable ou une fonction est utilisée, ni la manière dont il est possible d'y accéder. En voici quelques exemples :
iSend - Représente le nombre de messages envoyés.
bSend - Indicateur booléen définissant le succès de la dernière opération Send.
hSend - Descripteur de l'interface Comm.
Chacun de ces noms de variables a une signification très différente pour un programmeur. Ces informations sont perdues lorsque le nom de la variable est réduit à Send%. Les préfixes de portée tels que g et m permettent aussi de réduire le problème lié aux conflits de noms, surtout dans des projets impliquant plusieurs développeurs.

La notation hongroise est aussi largement utilisée par les programmeurs en Windows C et est constamment référencée dans la documentation des produits Microsoft et dans les livres de programmation de l'industrie. De plus, les relations entre les programmeurs en C et les programmeurs en Visual Basic pourront se renforcer à mesure que le système de développement Visual C++ prend de la vitesse. Cette transition permettra à de nombreux programmeurs en Visual Basic de passer au C pour la première fois et à de nombreux développeurs de se déplacer fréquemment entre les deux environnements.

Corps d'une variable et noms de routines

Le corps d'une variable ou le nom de routine doit utiliser des majuscules et des minuscules et décrire son objectif, peu importe sa longueur. De plus, les noms de fonction doivent commencer par un verbe, tels que InitNameArray ou CloseDialog.

Pour les termes longs ou fréquemment utilisés, il est recommandé d'utiliser des abréviations standard pour que la longueur des noms reste raisonnable. En général, les noms de variables dont la longueur est supérieure à 32 caractères peuvent être difficiles à lire en mode VGA.

Lorsque vous utilisez des abréviations, assurez-vous qu'elles sont cohérentes tout au long de l'application. En choisissant au hasard Cnt ou Count dans un projet, vous créerez une confusion inutile.

Qualificateurs sur les noms de variables et de routines

Les variables et les routines associés servent souvent à gérer et à manipuler un objet courant. Dans ces cas, utilisez des qualificateurs standard pour étiqueter les variables et les routines dérivées. Bien qu'il puisse paraître bizarre de placer le qualificateur après le corps du nom (comme dans sGetNameFirst, sGetNameLast au lieu de sGetFirstName, sGetLastName), cette pratique permet d'organiser ces noms ensemble dans les listes de routine de l'éditeur Visual Basic, facilitant ainsi la compréhension de la logique et de la structure de l'application. Le tableau suivant définit les qualificateurs courants et leur signification standard :
Qualificateur  Description (suit le corps)
--------------------------------------------------------------------------
First          Premier élément d'un jeu.
Last           Dernier élément d'un jeu.
Next           Élément suivant d'un jeu.
Prev           Élément précédent d'un jeu.
Cur            Élément en cours d'un jeu.
Min            Valeur minimale d'un jeu.
Max            Valeur maximale d'un jeu.
Save           Utilisé pour préserver une autre variable qui doit être 
               réinitialisée plus tard.
Tmp            Variable dont la portée est hautement localisée dans le
               code. La valeur d'une variable Tmp est de manière générale 
               seulement valide dans un jeu d'instructions contiguës au sein 
               d'une procédure unique.
Src            Source. Utilisé fréquemment avec des routines de comparaison 
               et de transfert.
Dst            Destination. Souvent utilisé conjointement avec Source.

Types définis par l'utilisateur

Déclare des types définis par l'utilisateur en majuscules avec _TYPE ajouté à la fin du symbole. Par exemple :
Type CUSTOMER_TYPE
      sName As String
      sState As String * 2
      lID as Long
   End Type
En déclarant une variable d'instance d'un type défini par l'utilisateur, ajoutez un préfixe au nom de la variable pour référencer le type. Par exemple :
   Dim custNew as CUSTOMER_TYPE

Constantes d'affectation de noms

Le corps des noms de constantes doit être en MAJUSCULES et comporter des caractères soulignés (_) entre les mots. Bien que les constantes en Visual Basic n'incluent pas d'informations en notation hongroise, les préfixes (tels que i, s, g et m) peuvent être très utiles pour comprendre la valeur et la portée d'une constante. Pour les noms de constantes, suivez les mêmes règles que pour les variables. Par exemple :
<mnUSER_LIST_MAX   ' Entrée limite max pour la liste des utilisateurs
                     ' (valeur entière, locale au module)
   gsNEW_LINE        ' Chaîne de caractères nouvelle ligne (globale
                     ' à l'application entière)

Type de données Variant

Si vous savez qu'une variable enregistrera toujours des données d'un type particulier, Visual Basic peut traiter ces données plus efficacement si vous déclarez une variable de ce type.

Cependant, le type de donnée Variant peut être extrêmement utile lorsque vous travaillez avec des bases de données, des messages, DDE ou OLE. De nombreuses bases de données autorisent la valeur NULL comme étant valide pour un champ. Votre code doit faire la distinction entre NULL, 0 (zéro) et "" (chaîne vide). Très souvent, ces types d'opérations peuvent utiliser une routine de service générique qui n'a pas besoin de connaître le type de données reçu pour traiter ou passer les données. Par exemple :
   Sub ConvertNulls(rvntOrg As Variant, rvntSub As Variant)
      ' Si rvntOrg = Null, remplace Null par rvntSub
      If IsNull(rvntOrg) Then rvntOrg = rvntSub
   End Sub
L'utilisation de ce type de données présente cependant quelques inconvénients. Les instructions de code qui utilisent des variantes peuvent être ambiguës pour le programmeur. Par exemple :
   vnt1 = "10.01" : vnt2 = 11 : vnt3 = "11" : vnt4 = "x4"
   vntResult = vnt1 + vnt2  ' Est-ce que vntResult = 21.01 ou 10.0111 ?
   vntResult = vnt1 + vnt2  ' Est-ce que vntResult = 21.01 ou 1110.01 ?
   vntResult = vnt1 + vnt3  ' Est-ce que vntResult = 21.01 ou 10.0111 ?
   vntResult = vnt3 + vnt1  ' Est-ce que vntResult = 21.01 ou 1110.01 ?
   vntResult = vnt2 + vnt4  ' Est-ce que vntResult = 11x4 ou ERROR ?
   vntResult = vnt3 + vnt4  ' Est-ce que vntResult = 11x4 ou ERROR ?
Les exemples ci-dessus seraient moins ambigus et plus facile à lire, à déboguer et à maintenir si les routines de conversion de type Visual Basic étaient utilisées. Par exemple :
   iVar1 = 5 + val(sVar2)   ' utilise ceci (conversion explicite)
   vntVar1 = 5 + vntVar2    ' non cela (conversion implicite)

Commentaire de votre code

Toutes les procédures et les fonctions doivent commencer par un bref commentaire décrivant les caractéristiques fonctionnelles de la routine (ce q'elle fait). Cette description ne doit pas inclure les détails de l'implémentation (comment elle le fait) car ceux-ci changent souvent au cours du temps, entraînant une maintenance inutile des commentaires ou, pire encore, des commentaires erronés. Le code en lui-même et tout commentaire local ou dans la ligne nécessaire décriront l'implémentation.

Les paramètres passés à une routine doivent être décrits lorsque leurs fonctions ne sont pas évidentes et lorsque la routine s'attend à ce que les paramètres soient compris dans une plage spécifique. Les valeurs de retour de fonctions et les variables globales qui sont changées par la routine (surtout par l'intermédiaire des paramètres de référence) doivent aussi être décrites au début de chaque routine.

Les blocs de commentaires en en-tête des routines devraient ressembler à ceci (voir la section "Format de votre code" ci-après pour un exemple) :
Section     Description du commentaire
--------------------------------------------------------------------------
Objectif    Ce que fait la routine (et non la manière dont elle le fait).
Entrées     Chaque paramètre non évident sur une ligne séparée
            avec des commentaires sur la ligne.
Assume      Liste de chaque variable externe non évidente, contrôle, fichier
            ouvert, etc.
Renvoie     Explication de la valeur renvoyée pour les fonctions.
Affecte     Liste de chaque variable externe affectée, contrôle, fichier,
            etc. et l'effet encouru (uniquement si ce n'est pas évident)
Chaque déclaration de variable complexe doit inclure un commentaire sur la ligne décrivant l'utilisation de la variable déclarée.

Les variables, les contrôles et les routines doivent être clairement nommés de sorte que les commentaires sur la ligne soient seulement nécessaires pour des détails d'implémentation non intuitifs ou complexes.

Une description d'ensemble de l'application, énumérant les objets de données primaires, les routines, les algorithmes, les boîtes de dialogue, les dépendances système des bases de données et des fichiers, et ainsi de suite, doivent être incluse au début du module .BAS contenant les déclarations des constantes génériques Visual Basic du projet.

REMARQUE : Le fenêtre Projet décrit par nature la liste des fichiers dans un projet ; cette section de présentation doit seulement fournir des informations sur les fichiers et les modules les plus importants, ou sur les fichiers non répertoriés dans la fenêtre Projet, tels que les fichiers d'initialisation (.INI) ou de base de données.

Format de votre code

De nombreux programmeurs utilisant toujours des modes d'affichage VGA, l'état de l'écran doit être conservé le plus possible, tout en veillant à ce que le code puisse être formaté pour refléter la structure logique et l'imbrication.

Les mises en retrait d'imbrication standard, tabulées ou par blocs doivent contenir entre deux et quatre espaces. Il est inutile d'utiliser plus de quatre espaces car des instructions pourraient être cachées ou tronquées accidentellement. L'utilisation de moins de deux espaces n'est pas suffisante pour indiquer l'imbrication logique. Dans la Base de Connaissances Microsoft, nous utilisons une mise en retrait de trois espaces. Utilisez la boîte de dialogue Options d'environnement pour définir la largeur de la tabulation par défaut.

Le commentaire de présentation fonctionnelle d'une routine doit être mis en retrait d'un espace. Les instructions de haut niveau qui suivent le commentaire de présentation doivent être mises en retrait d'un espace, chaque bloc imbriqué étant mis en retrait d'un espace supplémentaire. Par exemple :
**************************************************************************
'Objectif :   Localiser la première occurence d'un utilisateur spécifié 
'             dans un tableau UserList.
'Entrées :    rasUserList():  la liste des utilisateurs à parcourir.
'             rsTargetUser:   le nom de l'utilisateur à rechercher.
'Renvoie :    l'index de la première occurrence de rsTargetUser 
'             dans la table rasUserList. Si l'utilisateur cible n'est pas
'             trouvé, renvoie -1.
'**************************************************************************

'VB3Line: Entrez les lignes suivantes sur une ligne
Function iFindUser (rasUserList() As String, rsTargetUser as String) _
   As Integer
   Dim i As Integer           ' compteur de boucles
   Dim bFound As Integer      ' indique que la cible a été trouvée
   iFindUser = -1
   i = 0
   While i <= Ubound(rasUserList) and Not bFound
      If rasUserList(i) = rsTargetUser Then
         bFound = True
         iFindUser = i
      End If
   Wend
End Function
Les variables et les constantes non génériques divent être groupées par fonction au lieu d'être séparées dans des zones isolées ou des fichiers spéciaux. Les constantes génériques de Visual Basic telles que HOURGLASS doivent être groupées dans un module unique (VB_STD.BAS) de façon à ce qu'elles soient séparées des déclarations spécifiques à l'application.

Opérateurs

Utilisez toujours une esperluette (&) lorsque vous concaténez des chaînes et utilisez le signe plus (+) lorsque vous travaillez avec des valeurs numériques. L'utilisation du signe plus (+) avec des valeurs non numériques peut causer des problèmes en opérant sur deux variantes. Par exemple :
   vntVar1 = "10.01"
   vntVar2 = 11
   vntResult = vntVar1 + vntVar2         ' vntResult =  21.01
   vntResult = vntVar1 & vntVar2         ' vntResult = 10.0111

Portée

Les variables doivent toujours être définies avec la plus petite portée possible. Les variables globales peuvent créer des machines très complexes et rendre la logique d'une application extrêmement difficile à comprendre. Les variables globales rendent aussi la réutilisation et la maintenance de votre code plus difficiles. Les variables dans Visual Basic peuvent avoir la portée suivante :
Portée             Variable déclarée dans :                Visibilité
----------------------------------------------------------------------------------
Niveau procédure   Procédure d'événement, sub ou           Visible dans la
                   fonction                                procédure dans laquelle
                                                           elle est déclarée
Niveau feuille,    Section de déclarations d'une feuille   Visible dans chaque
Niveau module      ou module principal (.FRM, .BAS)        procédure dans le
                                                           module feuille
                                                           ou code
Global             Section de déclarations d'un code        Toujours visible
                   module (.BAS, utilisant le mot-clé
                   global)
Dans une application Visual Basic, utilisez seulement des variables globales lorsqu'il n'y a pas d'autre moyen pratique de partager les données entre les feuilles. Vous pouvez considérer l'enregistrement des informations dans la propriété Tag d'un contrôle, à laquelle il est possible d'accéder globalement à l'aide de la syntaxe form.object.property.

Si vous devez utiliser des variables globales, il convient de les déclarer toutes dans un module unique et de les regrouper par fonction. Donnez au module un nom significatif qui indique son objectif, tel que GLOBAL.BAS.

À l'exception des variables globales (qui ne doivent pas être passées), les procédures et les fonctions doivent seulement s'appliquer aux objets qui leur sont passés. Les variables globales qui sont utilisées dans des routines doivent être identifiées dans la zone de commentaires d'ordre général au début de la routine. De plus, passez les arguments aux sub et aux fonctions en utilisant ByVal, à moins que vous ne souhaitiez changer la valeur de l'argument passé.

Écrivez du code modulaire chaque fois que cela s'avère possible. Par exemple, si votre application affiche une boîte de dialogue, mettez tous les contrôles et le code requis pour effectuer la tâche de la boîte de dialogue dans une feuille unique. Cela permet de garder le code de l'application organisé en composants utiles et de minimiser sa gestion d'exécution.

Contrôles tiers

REMARQUE : Les produits mentionnés ci-dessous sont fabriqués par des fournisseurs indépendants de Microsoft. Microsoft exclut toute garantie, implicite ou autre, concernant les performances ou la fiabilité de ces produits.

Le tableau suivant répertorie les préfixes des noms des fournisseurs tiers standard à utiliser avec les préfixes des contrôles :
Fournisseur          Abr
------------------------

MicroHelp (VBTools)  m
Pioneer Software     p
Crescent Software    c
Sheridan Software    s
Autres (Divers)      o
Le tableau suivant répertorie les préfixes des contrôles tiers standard :
Type                 Nom         Abr  Fournisseur Exemple            Nom
Contrôle             Contrôle                                        Fichier VBX
--------------------------------------------------------------------------------
Alarme               Alarm       almm  MicroHelp  almmAlarm          MHTI200.VBX
Animer               Animate     anim  MicroHelp  animAnimate        MHTI200.VBX
Rappel               Callback    calm  MicroHelp  calmCallback       MHAD200.VBX
Liste modifiable     DB_Combo    cbop  Pioneer    cbopComboBox       QEVBDBF.VBX
Liste modifiable     SSCombo     cbos  Sheridan   cbosComboBox       SS3D2.VBX
Case à cocher        DB_Check    chkp  Pioneer    chkpCheckBox       QEVBDBF.VBX
Graphique            Chart       chtm  MicroHelp  chtmChart          MHGR200.VBX
Horloge              Clock       clkm  MicroHelp  clkmClock          MHTI200.VBX
Bouton               Command     cmdm  MicroHelp  cmdmCommandButton  MHEN200.VBX
                     Bouton
Bouton               DB_Command  cmdp  Pioneer    cmdpCommandButton  QEVBDBF.VBX
Bouton (Group)       Command     cmgm  MicroHelp  cmgmBtton          MHGR200.VBX
                     Bouton
                     (multiple)
Bouton               Command     cmim  MicroHelp  cmimCommandButton  MHEN200.VBX
                     Bouton
                     (icône)
Jeu de cartes        CardDeck    crdm  MicroHelp  crdmCard           MHGR200.VBX
Dés                  Dice        dicm  MicroHelp  dicmDice           MHGR200.VBX
Zone de liste (Dir)  SSDir       dirs  Sheridan   dirsDirList        SS3D2.VBX
Zone de liste (Drv)  SSDrive     drvs  Sheridan   drvsDriveList      SS3D2.VBX
Zone de liste (File) File List   film  MicroHelp  filmFileList       MHEN200.VBX
Zone de liste (File) SSFile      fils  Sheridan   filsFileList       SS3D2.VBX
Inverser             Flip        flpm  MicroHelp  flpmButton         MHEN200.VBX
Barre de défilement  Form Scroll fsrm  MicroHelp  fsrmFormScroll     ???
Indicateur           Gauge       gagm  MicroHelp  gagmGauge          MHGR200.VBX
Graphique            Graph       gpho  Other      gphoGraph          XYGRAPH.VBX
Grille               Q_Grid      grdp  Pioneer    grdpGrid           QEVBDBF.VBX
Barre de défilement  Horizontal  hsbm  MicroHelp  hsbmScroll         MHEN200.VBX
                     Barre de défilement
Barre de défilement  DB_HScroll  hsbp  Pioneer    hsbpScroll         QEVBDBF.VBX
Graphique            Histo       hstm  MicroHelp  hstmHistograph     MHGR200.VBX
Invisible            Invisible   invm  MicroHelp  invmInvisible      MHGR200.VBX
Zone de liste        Icon Tag    itgm  MicroHelp  itgmListBox        MHAD200.VBX
État clé             Key State   kstm  MicroHelp  kstmKeyState       MHTI200.VBX
Étiquette            Label (3d)  lblm  MicroHelp  lblmLabel          MHEN200.VBX
Ligne                Line        linm  MicroHelp  linmLine           MHGR200.VBX
Zone de liste        DB_List     lstp  Pioneer    lstpListBox        QEVBDBF.VBX
Zone de liste        SSList      lsts  Sheridan   lstsListBox        SS3D2.VBX
Enfant MDI           MDI Control mdcm  MicroHelp  mdcmMDIChild       ???
Menu                 SSMenu      mnus  Sheridan   mnusMenu           SS3D3.VBX
Marque               Marque      mrqm  MicroHelp  mrqmMarque         MHTI200.VB
Image                OddPic      odpm  MicroHelp  odpmPicture        MHGR200.VBX
Image                Picture     picm  MicroHelp  picmPicture        MHGR200.VBX
Image                DB_Picture  picp  Pioneer    picpPicture        QEVBDBF.VBX
Propriété Vwr        Property    pvrm  MicroHelp  pvrmPropertyViewer MHPR200.VBX
                     Afficheur
Option (Group)       DB_RadioGroup radp Pioneer   radqRadioGroup     QEVBDBF.VBX
Curseur              Slider      sldm  MicroHelp  sldmSlider         MHGR200.VBX
Bouton (Spin)        Spinner     spnm  MicroHelp  spnmSpinner        MHEN200.VBX
Feuille de calcul    Spreadsheet sprm  MicroHelp  sprmSpreadsheet    MHAD200.VBX
Image                Stretcher   strm  MicroHelp  strmStretcher      MHAD200.VBX
Écran de veille      Screen Saver svrm MicroHelp  svrmSaver          MHTI200.VBX
Interrupteur         Switcher    swtm  MicroHelp  swtmSwitcher       ???
Zone de liste        Tag         tagm  MicroHelp  tagmListBox        MHEN200.VBX
Minuterie            Timer       tmrm  MicroHelp  tmrmTimer          MHTI200.VBX
Barre d'outils       ToolBar     tolm  MicroHelp  tolmToolBar        MHAD200.VBX
Zone de liste        Tree        trem  MicroHelp  tremTree           MHEN200.VBX
Boîte d'entrée       Input (Text) txtm MicroHelp  inpmText           MHEN200.VBX
Boîte d'entrée       DB_Text     txtp  Pioneer    txtpText           QEVBDBF.VBX
Barre de défilement  Vertical    vsbm  MicroHelp  vsbmScroll         MHEN200.VBX
                     Barre de défilement
Barre de défilement  DB_VScroll  vsbp  Pioneer    vsbpScroll         QEVBDBF.VBX

Propriétés

Numéro d'article: 110264 - Dernière mise à jour: mardi 24 février 2004 - Version: 2.0
Les informations contenues dans cet article s'appliquent au(x) produit(s) suivant(s):
  • Microsoft Visual Basic 2.0 Édition professionnelle
  • Microsoft Visual Basic 3.0 Édition professionnelle
Mots-clés : 
kb3rdparty kbdocs kbinfo kbprg kbref kbtophit kbvbp400 prgother vb4win vbwin KB110264
L'INFORMATION CONTENUE DANS CE DOCUMENT EST FOURNIE PAR MICROSOFT SANS GARANTIE D'AUCUNE SORTE, EXPLICITE OU IMPLICITE. L'UTILISATEUR ASSUME LE RISQUE DE L'UTILISATION DU CONTENU DE CE DOCUMENT. CE DOCUMENT NE PEUT ETRE REVENDU OU CEDE EN ECHANGE D'UN QUELCONQUE PROFIT.
Exclusion de responsabilité concernant les contenus obsolètes dans la Base de connaissances
Cet article concerne des produits pour lesquels Microsoft n'offre plus de support. Il est par conséquent fourni « en l'état » et ne sera plus mis à jour.

Envoyer des commentaires

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com