INFO: Namenskonventionen der Microsoft Consulting Services für Visual Basic

Veralteter Haftungsausschluss für KB-Inhalte

Dieser Artikel wurde für Produkte geschrieben, für die Microsoft keinen Support mehr anbietet. Deshalb wird dieser Artikel im vorliegenden Zustand bereitgestellt und nicht mehr aktualisiert.

Dieser Artikel ist eine Übersetzung des folgenden englischsprachigen Artikels der Microsoft Knowledge Base:
110264 INFO: Microsoft Consulting Services Naming Conventions for Visual Basic

Zusammenfassung

Es ist sinnvoll, Namenskonventionen für Visual Basic-Code festzulegen. Dieser Artikel enthält die Namenskonventionen, die von Microsoft Consulting Services (MCS) verwendet werden.


Dieses Dokument stellt eine Obermenge der Visual Basic-Codierungskonventionen dar, die im Visual Basic-Programmierhandbuch beschrieben werden.


Hinweis: Die in diesem Artikel erwähnten Steuerelemente werden von Lieferanten hergestellt, die von Microsoft unabhängig sind; Microsoft gewährt keine implizite oder sonstige Garantie in Bezug auf die Leistung oder Zuverlässigkeit dieser Produkte.

Weitere Informationen

Namenskonventionen unterstützen Visual Basic-Programmierer dabei,


  • die Struktur, den Codingstil und die Logik einer Anwendung zu standardisieren
  • präzisen, lesbaren und eindeutigen Quellcode zu erstellen
  • die Konsistenz mit anderen Sprachkonventionen zu gewährleisten (insbesondere mit dem Visual Basic-Programmierhandbuch und der ungarischen Standardnotation in Windows C).
  • hinsichtlich der Größe von Zeichenfolgen und des Aufwands effizient vorzugehen und so mehr Spielraum für längere und vollständige Objektnamen zu lassen
  • die Mindestanforderungen hierfür festzulegen

Festlegen von Umgebungsoptionen

Verwenden Sie "Option Explicit". Deklarieren Sie alle Variablen. Dadurch können Sie Programmierzeit sparen, da Sie die Anzahl der durch Tippfehler verursachten Fehler reduzieren (z. B. "aUserNameTmp" oder "sUserNameTmp" oder "sUserNameTemp"). Stellen Sie im Dialogfeld Umgebungsoptionen die Option Variablendeklaration erforderlich auf Ja ein. Die Anweisung "Option Explicit" erfordert, dass Sie alle Variablen in Ihrem Visual Basic-Programm deklarieren. Sichern Sie Dateien als ASCII-Text. Sichern Sie Formulardateien (.FRM) und Moduldateien (.BAS) als ASCII-Text, um die Verwendung von Versionssteuerungssystemen zu erleichtern und den Schaden zu minimieren, der durch beschädigte Datenträger verursacht werden kann. Außerdem können Sie


  • Ihren eigenen Editor verwenden
  • automatisierte Tools wie z. B. "grep" verwenden
  • Codegenerierungstools oder CASE-Tools für Visual Basic erstellen
  • externe Analysen Ihres Visual Basic-Codes durchführen
Damit Dateien von Visual Basic immer als ASCII-Text gesichert werden, stellen Sie im Dialogfeld Umgebungsoptionen die Option Standardformat für Speichern unter auf Text ein.

Namenskonventionen für Standardobjekte

Die folgenden Tabellen legen die Präfixe für MCS-Standardobjektnamen fest. Diese Präfixe stimmen mit den im Visual Basic-Programmierhandbuch dokumentierten Präfixen überein.

Präfix Objekttyp Beispiel
-------------------------------------------------------
ani Animationsschaltfläche aniMailBox
bed Stift BEdit bedFirstName
cbo Komb.-Feld, Dropdown-Listenfeld cboEnglish
chk Kontrollkästchen chkReadOnly
clp Bildausschnitt clpToolbar
cmd (3d) Befehlsschaltfläche (3D) cmdOk (cmd3dOk)
com Kommunikation comFax
ctr Steuerelem. (wenn spez.Typ unbekannt) ctrCurrent
dat Daten-Steuerelement datBiblio
dir Verzeichnislistenfeld dirSource
dlg Standarddialogfeld dlgFileOpen
drv Laufwerklistenfeld drvTarget
fil Dateilistenfeld filSource
frm Formular frmEntry
fra (3d) Rahmen (3d) fraStyle (fra3dStyle)
gau Messgerät gauStatus
gpb Gruppenschaltfläche gpbChannel
gra Diagramm graRevenue
grd Raster grdPrices
hed Stift HEdit hedSignature
hsb Horizontale Bildlaufleiste hsbVolume
img Anzeige imgIcon
ink Stift-Ink inkMap
key Tastenstatus keyCaps
lbl Bezeichnungsfeld lblHelpMessage
lin Linie linVertical
lst Listenfeld lstPolicyCodes
mdi Untergeordnetes MDI-Formular mdiNote
mpm MAPI-Nachricht mpmSentMessage
mps MAPI-Sitzung mpsSession
mci MCI mciVideo
mnu Menü mnuFileOpen
opt (3d) Optionsschaltfläche (3d) optRed (opt3dRed)
ole OLE-Steuerelement oleWorksheet
out Gliederung outOrgChart
pic Bild picVGA
pnl3d 3d-Grundfläche pnl3d
rpt Bericht rptQtr1Earnings
shp Form shpCircle
spn Drehfeld spnPages
txt Textfeld txtLastName
tmr Zeitgeber tmrAlarm
vsb Vertikale Bildlaufleiste vsbRate

Namenskonventionen für Datenbankobjekte


Präfix Objekttyp Beispiel
------------------------------------------
db ODBC-Datenbank dbAccounts
ds ODBC-Dynaset-Objekt dsSalesByRegion
fdc Feldsammlung fdcCustomer
fd Feldobjekt fdAddress
ix Indexobjekt ixAge
ixc Indexsammlung ixcNewAge
qd QueryDef-Objekt qdSalesByRegion
qry (suffix) Abfrage (s.Hinweis) SalesByRegionQry
ss Snapshot-Objekt ssForecast
tb Tabellenobjekt tbCustomer
td TableDef-Objekt tdCustomers

Hinweis: Wenn ein Suffix für Abfragen verwendet wird, können die einzelnen Abfragen mit ihrer zugehörigen Tabelle in Microsoft Access-Dialogen (Tabelle hinzufügen, Tabellen-Snapshot) sortiert werden.

Namenskonventionen für Menüs

Anwendungen verwenden häufig sehr viele Menü-Steuerelemente. Deshalb benötigen Sie eine andere Gruppe von Namenskonventionen für diese Steuerelemente. Präfixe für Menü-Steuerelemente sollten nach dem Präfix "mnu" um ein zusätzliches Präfix für jede Verschachtelungsebene erweitert werden, wobei die Beschriftung für das letzte Menü am Ende der Zeichenfolge stehen sollte. Beispiel:

Sequenz Menübeschrift. Name des Menühandlers
Help.Contents mnuHelpContents
File.Open mnuFileOpen
Format.Character mnuFormatCharacter
File.Send.Fax mnuFileSendFax
File.Send.Email mnuFileSendEmail
Wenn diese Namenskonvention angewendet wird, werden alle zu einer bestimmten Menügruppe gehörenden Menü-Steuerelemente nebeneinander in den Objekt-Dropdown-Listenfeldern (im Codefenster und im Eigenschaftenfenster) angezeigt. Außerdem machen die Namen der Menü-Steuerelemente die Menüelemente gut kenntlich, denen sie zugeordnet sind.

Namenskonventionen für andere Steuerelemente

Für Steuerelemente, die oben nicht aufgeführt sind, sollten Sie ein eindeutiges, aus drei Zeichen bestehendes Präfix festlegen. Es ist jedoch wichtiger, Unklarheiten zu vermeiden, als sich an die drei Zeichen zu halten.


Erweitern Sie für abgeleitete Steuerelemente wie z. B. ein erweitertes Listenfeld die oben genannten Präfixe so, dass klar ist, welches Steuerelement tatsächlich verwendet wird. Auch eine Abkürzung in Kleinbuchstaben für den Hersteller würde in der Regel zum Präfix hinzugefügt. Für ein Steuerelement, das aus dem 3D-Rahmen-Steuerelement aus Visual Basic Professional erstellt wurde, könnten Sie z. B. den Präfix "fra3d" verwenden, damit klar ist, welches Steuerelement verwendet wird. Für eine Befehlsschaltfläche aus MicroHelp könnten Sie "cmdm" verwenden, um sie von der Standard-Befehlsschaltfläche (cmd) zu unterscheiden.

Steuerelemente von Fremdanbietern

Jedes in einer Anwendung verwendete Steuerelement eines Fremdanbieters sollte im Übersichts-Kommentarabschnitt der Anwendung aufgeführt werden, und zwar mit dem für das Steuerelement verwendeten Präfix, dem vollständigen Namen des Steuerelements und dem Namen des Softwareanbieters:

Präfix Steuerelementtyp Anbieter
cmdm Befehlsschaltfläche MicroHelp

Namenskonventionen für Variablen und Routinen

Variablen und Funktionsnamen haben folgende Struktur: <Präfix><Rumpf><Qualifizierer><Suffix>

Teil Beschreibung Beispiel
--------------------------------------------------------------------------
<Präfix> Beschreibt Verwend./Gült.-Ber. der Variable iGetRecordNext
<Rumpf> Beschreibt die Variable iGetNameFirst
<Qualifizierer> Bezeichnet eine Ableitung der Variable iGetNameLast
<Suffix> Optionales Zeichen (Visual Basic-Typ) iGetRecordNext%
Präfixe:


Die folgenden Tabellen legen Präfixe für Variablen und Funktionsnamen fest, die auf der ungarischen C-Notation für Windows basieren. Diese Präfixe sollten bei allen Variablen- und Funktionsnamen verwendet werden. Von der Verwendung alter Basic-Suffixe (z. B. %, &, # usw.) ist abzuraten.


Präfixe für Variablen- und Funktionsnamen:


Präfix Zusammengef. Verwendung Datentyp Suffix
--------------------------------------------------------------------------
b bln Boolescher Wert Integer %
c cur Währung - 64 Bits Currency @
d dbl Doppelt - 64-Bit- Double #
Menge mit Vorzeichen
dt dat Datum und Uhrzeit Variant
e err Fehler
f sng Float/Single - 32 Single !
Bit mit Vorzeichen
Gleitkomma
h Handle Integer %
i Index Integer %
l lng Long - 32-Bit- Long &
Menge mit Vorzeichen
n int Zahl/Zähler Integer %
s str Zeichenfolge String $
u Ohne Vorz. - 16-Bit Long &
Menge ohne Vorzeichen
udt Benutzerdef. Typ
vnt vnt Variante Variant
a Array
Hinweis: Die Werte in der Spalte "Zusammengef." stellen den Versuch dar, die Namenskonventionen für Visual Basic, Visual Basic für Applikationen und Access Basic zusammenzuführen. Es ist wahrscheinlich, dass diese Präfixe in naher Zukunft zum Microsoft-Standard werden.


Präfixe für Gültigkeitsbereich und Verwendung:

Präfix Beschreibung
g Global
m Lokal in Modul oder Formular
st Statische Variable
(kein Präfix) Nicht statische Variable, Präfix lokal in Prozedur
v Variable von Wert übergeben (lokal in Routine)
r Variable von Verweis übergeben (lokal in Routine)
Die ungarische Notation ist in Visual Basic ebenso nützlich wie in C. Suffixe des Typs, wie sie in Visual Basic verwendet werden, geben zwar den Datentyp einer Variable an, erklären jedoch nicht, wofür eine Variable oder Funktion verwendet wird, oder wie auf sie zugegriffen werden kann. Einige Beispiele:
iSend - Anzahl der gesendeten Nachrichten
bSend - Boolean-Attribut, das den Erfolg der letzten Sendeoperation definiert

hSend - Handle für die Comm-Schnittstelle
Jeder dieser Variablennamen teilt dem Programmierer etwas ganz Anderes mit. Diese Informationen gehen verloren, wenn der Name der Variable auf "Send%" reduziert wird. Präfixe für den Gültigkeitsbereich wie z. B. "g" und "m" tragen ebenfalls dazu bei, Probleme mit Namenskonflikten zu reduzieren, insbesondere in Projekten, an denen mehrere Entwickler beteiligt sind.


Auch wird die ungarische Notation von Windows C-Programmierern viel genutzt, und in der Microsoft-Produktdokumentation und in Programmierhandbüchern der Branche wird ständig auf sie verwiesen. Darüber hinaus wird die Verbindung zwischen C-Programmierern und Programmierern, die Visual Basic verwenden, mit zunehmendem Einsatz des Visual C++-Entwicklungssystems immer stärker werden. Dieser Übergang wird dazu führen, dass viele Visual Basic-Programmierer erstmalig auf C umsteigen und viele Programmierer häufig zwischen beiden Umgebungen wechseln.

Rumpf von Namen für Variablen und Routinen

Für den Rumpf des Namens von Variablen oder Routinen sollte die Groß-/Kleinschreibung verwendet werden. Die Namen sollten so lang wie nötig sein, um den Zweck der Variable oder Routine zu beschreiben. Außerdem sollten Funktionsnamen mit einem Verb beginnen, z. B. "InitNameArray" oder "CloseDialog".


Für häufig verwendete oder lange Namen sind Standardabkürzungen zu empfehlen, um die Länge der Namen in Grenzen zu halten. Im Allgemeinen sind Variablennamen, die mehr als 32 Zeichen haben, auf VGA-Bildschirmen schwierig zu lesen.


Wenn Sie Abkürzungen verwenden, sollten diese in der gesamten Anwendung konsistent sein. Wenn Sie z. B. innerhalb eines Projekts beliebig zwischen "Cnt" und "Count" hin und her wechseln, entsteht unnötige Verwirrung.

Qualifizierer für Namen von Variablen und Routinen

Zusammengehörige Variablen und Routinen werden häufig dazu verwendet, ein allgemeines Objekt zu verwalten und zu manipulieren. Verwenden Sie in diesen Fällen Standardqualifizierer, um die abgeleiteten Variablen und Routinen zu bezeichnen. Zwar scheint es etwas ungeschickt, den Qualifizierer an den Rumpf des Namens anzuschließen (wie bei sGetNameFirst, sGetNameLast anstelle von sGetFirstName, sGetLastName). Jedoch trägt diese Vorgehensweise dazu bei, diese Namen in den Routinenlisten des Visual Basic-Editors zusammen anzuordnen und so die Logik und Struktur der Anwendung leichter verständlich zu machen. Die folgende Tabelle legt allgemeine Qualifizierer und die Standardbedeutung dieser Qualifizierer fest:

Qualifizierer Beschreibung (folgt auf Rumpf)
--------------------------------------------------------------------------
First Erstes Element eines Sets
Last Letztes Element eines Sets
Next Nächstes Element in einem Set
Prev Vorheriges Element in einem Set
Cur Aktuelles Element in einem Set
Min Minimalwert in einem Set
Max Maximalwert in einem Set
Save Wird dazu verwendet, eine andere Variable zu erhalten, die später zurückgesetzt werden muss
Tmp "Scratch"-Variable, deren Gültigkeitsbereich im Code stark lokalisiert
ist. Der Wert einer Tmp-Variable gilt in der Regel nur über
eine Menge zusammenhängender Anweisungen innerhalb einer einzigen Prozedur.
Src Quelle. Wird häufig in Vergleichs- und Übertragungsroutinen verwendet.
Dst Ziel. Wird häufig in Verbindung mit "Quelle" verwendet.

Benutzerdefinierte Typen

Deklarieren Sie benutzerdefinierte Typen in Großbuchstaben, und hängen Sie _TYPE an das Ende des Symbolnamens an. Beispiel:
Type CUSTOMER_TYPE
sName As String
sState As String * 2
lID as Long
End Type
Fügen Sie beim Deklarieren einer Instanzvariablen eines benutzerdefinierten Typs ein Präfix zum Variablennamen hinzu, um auf den Typ zu verweisen. Beispiel:
   Dim custNew as CUSTOMER_TYPE

Benennung von Konstanten

Der Rumpf von Konstantennamen sollten in Großbuchstaben mit Unterstrichen (_) zwischen den einzelnen Wörtern geschrieben werden. Zwar enthalten Visual Basic-Standardkonstanten keine ungarischen Informationen, jedoch können Präfixe wie i, s, g und m zum Verständnis des Wertes und Gültigkeitsbereichs einer Konstante sehr hilfreich sein. Beachten Sie bei Konstantennamen dieselben Regeln wie bei Variablen. Beispiel:
<mnUSER_LIST_MAX   ' Max entry limit for User list (integer value,
' local to module)
gsNEW_LINE ' New Line character string (global to entire
' application)

Variant-Datentyp

Wenn Sie wissen, dass in einer Variable immer Daten eines bestimmten Typs gespeichert werden, kann Visual Basic diese Daten effizienter verarbeiten, wenn Sie eine Variable dieses Typs deklarieren.


Der Variant-Datentyp kann jedoch bei der Arbeit mit Datenbanken, Nachrichten, DDE oder OLE äußerst nützlich sein. Viele Datenbanken lassen NULL als gültigen Wert für ein Feld zu. Ihr Code muss zwischen NULL, 0 (Null) und "" (leere Zeichenfolge) unterscheiden. Häufig können diese Typen von Operationen eine allgemeine Serviceroutine verwenden, die den Typ der Daten, die sie empfängt, nicht kennen muss, um sie verarbeiten oder weitergeben zu können. Beispiel:

   Sub ConvertNulls(rvntOrg As Variant, rvntSub As Variant)
' If rvntOrg = Null, replace the Null with rvntSub
If IsNull(rvntOrg) Then rvntOrg = rvntSub
End Sub
Die Verwendung von Varianten hat jedoch einige Nachteile. Codeanweisungen, die Varianten verwenden, können für den Programmierer mitunter unklar sein. Beispiel:
   vnt1 = "10.01" : vnt2 = 11 : vnt3 = "11" : vnt4 = "x4"
vntResult = vnt1 + vnt2 ' Does vntResult = 21.01 or 10.0111?
vntResult = vnt2 + vnt1 ' Does vntResult = 21.01 or 1110.01?
vntResult = vnt1 + vnt3 ' Does vntResult = 21.01 or 10.0111?
vntResult = vnt3 + vnt1 ' Does vntResult = 21.01 or 1110.01?
vntResult = vnt2 + vnt4 ' Does vntResult = 11x4 or ERROR?
vntResult = vnt3 + vnt4 ' Does vntResult = 11x4 or ERROR?
Die obigen Beispiele wären weniger unklar und einfacher zu lesen, zu debuggen und zu pflegen, wenn stattdessen die Visual Basic-Routinen für die Typkonvertierung verwendet würden. Beispiel:
   iVar1 = 5 + val(sVar2)   ' use this (explicit conversion)
vntVar1 = 5 + vntVar2 ' not this (implicit conversion)

Kommentare im Code

Alle Prozeduren und Funktionen sollten mit einem kurzen Kommentar beginnen, der die Funktionsmerkmale der Routine (ihre Aufgabe) beschreibt. Einzelheiten der Implementierung (d. h. wie die Routine funktioniert) sollten hier nicht beschrieben werden, da diese sich häufig mit der Zeit ändern und so unnötigen Pflegeaufwand für die Kommentare oder - schlimmer noch - fehlerhafte Kommentare zur Folge haben können. Die Implementierung wird durch den Code selbst und etwaige notwendige Inline-Kommentare oder lokale Kommentare beschrieben.


Die an eine Routine übergebenen Parameter sollten beschrieben werden, wenn ihre Funktionen nicht offensichtlich sind und die Routine erwartet, dass die Parameter in einem bestimmten Bereich liegen. Funktionsrückgabewerte und globale Variablen, die von der Routine geändert werden (insbesondere über Referenzparameter) müssen ebenfalls zu Beginn jeder Routine beschrieben werden.


Kommentarblöcke im Header von Routinen sollten folgendermaßen aussehen (ein Beispiel finden Sie im nächsten Abschnitt "Formatieren von Code"):

Abschnitt Beschreibung des Kommentars
--------------------------------------------------------------------------
Zweck Was die Routine tut (nicht, wie sie es tut).
Eingaben Jeder nicht offensichtliche Parameter in einer eigenen Zeile
mit Inline-Kommentaren.
Annahmen Liste mit allen nicht offensichtlichen externen Variablen, Steuerelementen,
offenen Dateien usw.
Rückgabewerte Erklärung der von den Funktionen zurückgegebenen Werte.
Auswirkg. Liste mit allen betroffenen externen Variablen, Steuerelementen, Dateien
usw. sowie deren Auswirkungen (nur, falls dies nicht offensichtlich ist).
Jede wichtige Variablendeklaration sollte einen Inline-Kommentar enthalten, der die Verwendung der deklarierten Variable beschreibt.


Variablen, Steuerelemente und Routinen sollten so klar benannt werden, dass Inline-Kommentare nur für komplexe oder nicht intuitiv verständliche Implementierungsdetails erforderlich sind.


Zu Beginn des .BAS-Moduls, das die allgemeinen Visual Basic-Konstantendeklarationen des Projekts enthält, sollten Sie eine Beschreibung mit einem Überblick über die Anwendung einfügen, in dem Sie primäre Datenobjekte, Routinen, Algorithmen, Dialogfelder, Datenbank- und Dateisystemabhängigkeiten usw. auflisten.


Hinweis: Das Projektfenster beschreibt die Liste der Dateien in einem Projekt schon an sich, d. h. dieser Übersichtsabschnitt muss lediglich Informationen zu den wichtigsten Dateien und Modulen liefern, oder zu den Dateien, die im Projektfenster nicht aufgeführt werden, z. B. Initialisierungsdateien (.INI) oder Datenbankdateien.

Formatieren von Code

Da viele Programmierer immer noch VGA-Bildschirme verwenden, sollten Sie beim Formatieren des Codes möglichst platzsparend arbeiten, wobei logische Struktur und Verschachtelung des Codes trotzdem klar erkennbar sein sollten.


Verschachtelte Standardblöcke, die mit Tabulatoren formatiert sind, sollten um zwei bis vier Leerzeichen eingerückt werden. Die Verwendung von mehr als vier Leerzeichen ist unnötig und kann dazu führen, dass Anweisungen versteckt oder versehentlich abgeschnitten werden. Bei Verwendung von weniger als zwei Leerzeichen wird die logische Verschachtelung nicht klar genug erkennbar. In der Microsoft Knowledge Base wird eine Einrückung um drei Leerzeichen verwendet. Sie können die Standard-Tab-Schrittweite über das Dialogfeld Umgebungsoptionen einstellen.


Der Kommentar, der einen Überblick über die Funktionen einer Routine vermittelt, sollte um ein Leerzeichen eingerückt werden. Die Anweisungen auf höchster Ebene, die auf den Kommentar mit dem Überblick über die Funktionen folgen, sollten um einen Tabulatorschritt eingerückt werden, alle verschachtelten Blöcke um einen weiteren Tabulatorschritt. Beispiel:
**************************************************************************
'Purpose: Locate first occurrence of a specified user in UserList array.
'Inputs: rasUserList(): the list of users to be searched
' rsTargetUser: the name of the user to search for
'Returns: the index of the first occurrence of the rsTargetUser
' in the rasUserList array. If target user not found, return -1.
'**************************************************************************

'VB3Line: Enter the following lines as one line
Function iFindUser (rasUserList() As String, rsTargetUser as String) _
As Integer
Dim i As Integer ' loop counter
Dim bFound As Integer ' target found flag
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
Variablen und nicht allgemeine Konstanten sollten nach ihren Funktionen gruppiert und nicht in separate Bereiche oder spezielle Dateien aufgeteilt werden. Allgemeine Visual Basic-Konstanten wie z. B. HOURGLASS sollten in einem einzigen Modul (VB_STD.BAS) gruppiert werden, um sie von anwendungsspezifischen Deklarationen abzugrenzen.

Operatoren

Verwenden Sie bei der Verkettung von Zeichenfolgen immer ein kaufmännisches UND (&) und bei der Arbeit mit numerischen Werten das Pluszeichen (+). Die Verwendung eines Pluszeichens (+) bei nicht numerischen Werten kann Probleme verursachen, wenn Sie mit zwei Varianten arbeiten. Beispiel:

   vntVar1 = "10.01"
vntVar2 = 11
vntResult = vntVar1 + vntVar2 ' vntResult = 21.01
vntResult = vntVar1 & vntVar2 ' vntResult = 10.0111

Gültigkeitsbereich

Variablen sollten immer mit dem kleinstmöglichen Gültigkeitsbereich definiert werden. Bei Verwendung von globalen Variablen können äußerst komplexe Zustandsmaschinen entstehen, die die Logik einer Anwendung sehr schwer verständlich machen. Zudem erschweren globale Variablen die Wiederverwendung und Pflege des Codes beträchtlich. Variablen in Visual Basic können den folgenden Gültigkeitsbereich haben:

Gült.-Bereich Variable deklariert in: Sichtbarkeit
--------------------------------------------------------------------------
Prozedurebene Ereignisprozedur, Sub- oder Sichtbar in der
Function-Prozedur Prozedur, in der
sie deklariert ist
Formularebene, Dekl.-Abschnitt eines Formular- Sichtbar in jeder
Modulebene oder Codemoduls (.FRM, .BAS) Prozedur im Formular-
oder Code-
modul
Global Deklarationsabschnitt eines Immer sichtbar
Codemoduls (.BAS, mit
Schlüsselwort Global)
In einer Visual Basic-Anwendung sollten globale Variablen nur dann verwendet werden, wenn es keine andere Möglichkeit gibt, Daten in mehreren Formularen zu nutzen. Sie können in Erwägung ziehen, Informationen in der Eigenschaft "Tag" eines Steuerelements zu speichern, auf die global über die Syntax "form.object.property" zugegriffen werden kann.


Wenn es unumgänglich ist, globale Variablen einzusetzen, ist es sinnvoll, alle in einem einzigen Modul zu deklarieren und nach Funktion zu gruppieren. Geben Sie dem Modul einen aussagekräftigen Namen, der seinen Zweck angibt, z. B.GLOBAL.BAS.


Mit Ausnahme von globalen Variablen, die nicht übergeben werden sollten, sollten Prozeduren und Funktionen nur mit Objekten arbeiten, die an sie übergeben werden. Globale Variablen, die in Routinen verwendet werden, sollten im allgemeinen Kommentarbereich am Anfang der Prozedur beschrieben werden. Außerdem sollten Sie Argumente unter Verwendung von "ByVal" an Sub- und Function-Prozeduren übergeben, es sei denn, Sie möchten den Wert des übergebenen Arguments explizit ändern.


Schreiben Sie modularen Code, wo immer dies möglich ist. Wenn in Ihrer Anwendung z. B. ein Dialogfeld angezeigt wird, sollten Sie alle Steuerelemente und den Code für die Ausführung der Dialogfeldfunktionen in einem einzigen Formular definieren. Dies trägt dazu bei, den Code in zweckdienlichen Komponenten zu organisieren, und der Verwaltungsaufwand zur Laufzeit wird minimiert.

Steuerelemente von Fremdanbietern

Hinweis: Die in diesem Artikel erwähnten Fremdanbieterprodukte werden von Lieferanten hergestellt, die von Microsoft unabhängig sind; Microsoft gewährt keine implizite oder sonstige Garantie in bezug auf die Leistung oder Zuverlässigkeit dieser Produkte.



Die folgende Tabelle listet Standard-Präfixzeichen für Namen von Fremdanbietern auf, die bei Präfixen für Steuerelemente zu verwenden sind:

Anbieter Abk.
-------------------------

MicroHelp (VBTools) m
Pioneer Software p
Crescent Software c
Sheridan Software s
Sonstige o
Die folgende Tabelle enthält Standardpräfixe für Steuerelemente von Fremdanbietern:

Steuerelement- Steuerel.- Abk. Anbieter Beispiel VBX-Datei-
Typ Name Name
--------------------------------------------------------------------------
Alarm Alarm almm MicroHelp almmAlarm MHTI200.VBX
Animieren Animate anim MicroHelp animAnimate MHTI200.VBX
Rückruf Callback calm MicroHelp calmCallback MHAD200.VBX
Kombinat.-Feld DB_Combo cbop Pioneer cbopComboBox QEVBDBF.VBX
Kombinat.-Feld SSCombo cbos Sheridan cbosComboBox SS3D2.VBX
Kontr.-Kästchen DB_Check chkp Pioneer chkpCheckBox QEVBDBF.VBX
Diagramm Chart chtm MicroHelp chtmChart MHGR200.VBX
Uhr Clock clkm MicroHelp clkmClock MHTI200.VBX
Schaltfläche Command cmdm MicroHelp cmdmCommandButton MHEN200.VBX
Button
Schaltfläche DB_Command cmdp Pioneer cmdpCommandButton QEVBDBF.VBX
Schaltfl.(Grp.) Command cmgm MicroHelp cmgmBtton MHGR200.VBX
Button
(multiple)
Schaltfläche Command cmim MicroHelp cmimCommandButton MHEN200.VBX
Button
(icon)
Kartenstapel CardDeck crdm MicroHelp crdmCard MHGR200.VBX
Würfel Dice dicm MicroHelp dicmDice MHGR200.VBX
List.-F. (Verz) SSDir dirs Sheridan dirsDirList SS3D2.VBX
List-F. (Laufw) SSDrive drvs Sheridan drvsDriveList SS3D2.VBX
List.-F.(Datei) File List film MicroHelp filmFileList MHEN200.VBX
List.-F.(Datei) SSFile fils Sheridan filsFileList SS3D2.VBX
Kippen Flip flpm MicroHelp flpmButton MHEN200.VBX
Bildlaufleiste Form Scroll fsrm MicroHelp fsrmFormScroll ???
Messgerät Gauge gagm MicroHelp gagmGauge MHGR200.VBX
Diagramm Graph gpho Other gphoGraph XYGRAPH.VBX
Raster Q_Grid grdp Pioneer grdpGrid QEVBDBF.VBX
Bildlaufleiste Horizontal hsbm MicroHelp hsbmScroll MHEN200.VBX
Scroll Bar
Bildlaufleiste DB_HScroll hsbp Pioneer hsbpScroll QEVBDBF.VBX
Diagramm Histo hstm MicroHelp hstmHistograph MHGR200.VBX
Unsichtbar Invisible invm MicroHelp invmInvisible MHGR200.VBX
Listenfeld Icon Tag itgm MicroHelp itgmListBox MHAD200.VBX
Schlüsselstatus Key State kstm MicroHelp kstmKeyState MHTI200.VBX
Bezeichner Label (3d) lblm MicroHelp lblmLabel MHEN200.VBX
Linie Line linm MicroHelp linmLine MHGR200.VBX
Listenfeld DB_List lstp Pioneer lstpListBox QEVBDBF.VBX
Listenfeld SSList lsts Sheridan lstsListBox SS3D2.VBX
MDI untergeord. MDI Control mdcm MicroHelp mdcmMDIChild ???
Menü SSMenu mnus Sheridan mnusMenu SS3D3.VBX
Laufschrift Marque mrqm MicroHelp mrqmMarque MHTI200.VB
Bild OddPic odpm MicroHelp odpmPicture MHGR200.VBX
Bild Picture picm MicroHelp picmPicture MHGR200.VBX
Bild DB_Picture picp Pioneer picpPicture QEVBDBF.VBX
Eigensch.-Vwr Property pvrm MicroHelp pvrmPropertyViewer MHPR200.VBX
Viewer
Option (Gruppe) DB_RadioGroup radp Pioneer radqRadioGroup QEVBDBF.VBX
Schieberegler Slider sldm MicroHelp sldmSlider MHGR200.VBX
Schaltfl.(Spin) Spinner spnm MicroHelp spnmSpinner MHEN200.VBX
Spreadsheet Spreadsheet sprm MicroHelp sprmSpreadsheet MHAD200.VBX
Bild Stretcher strm MicroHelp strmStretcher MHAD200.VBX
BS-Schoner Screen Saver svrm MicroHelp svrmSaver MHTI200.VBX
Switcher Switcher swtm MicroHelp swtmSwitcher ???
Listenfeld Tag tagm MicroHelp tagmListBox MHEN200.VBX
Zeitgeber Timer tmrm MicroHelp tmrmTimer MHTI200.VBX
Symbolleiste ToolBar tolm MicroHelp tolmToolBar MHAD200.VBX
Listenfeld Tree trem MicroHelp tremTree MHEN200.VBX
Eingabefeld Input (Text) txtm MicroHelp inpmText MHEN200.VBX
Eingabefeld DB_Text txtp Pioneer txtpText QEVBDBF.VBX
Bildlaufleiste Vertical vsbm MicroHelp vsbmScroll MHEN200.VBX
Scroll Bar
Bildlaufleiste DB_VScroll vsbp Pioneer vsbpScroll QEVBDBF.VBX
Bitte beachten Sie: Bei diesem Artikel handelt es sich um eine Übersetzung aus dem Englischen. Es ist möglich, dass nachträgliche Änderungen bzw. Ergänzungen im englischen Originalartikel in dieser Übersetzung nicht berücksichtigt sind. Die in diesem Artikel enthaltenen Informationen basieren auf der/den englischsprachigen Produktversion(en). Die Richtigkeit dieser Informationen in Zusammenhang mit anderssprachigen Produktversionen wurde im Rahmen dieser Übersetzung nicht getestet. Microsoft stellt diese Informationen ohne Gewähr für Richtigkeit bzw. Funktionalität zur Verfügung und übernimmt auch keine Gewährleistung bezüglich der Vollständigkeit oder Richtigkeit der Übersetzung.
Eigenschaften

Artikelnummer: 110264 – Letzte Überarbeitung: 24.03.2006 – Revision: 1

Feedback