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

SPRACHE AUSWÄHLEN SPRACHE AUSWÄHLEN
Artikel-ID: 110264 - Produkte anzeigen, auf die sich dieser Artikel bezieht
Dieser Artikel ist eine Übersetzung des folgenden englischsprachigen Artikels der Microsoft Knowledge Base:
110264 INFO: Microsoft Consulting Services Naming Conventions for Visual Basic
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.
Alles erweitern | Alles schließen

Auf dieser Seite

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
				

Eigenschaften

Artikel-ID: 110264 - Geändert am: Freitag, 24. März 2006 - Version: 1.1
Die Informationen in diesem Artikel beziehen sich auf:
  • Microsoft Visual Basic 4.0 Standard Edition
  • Microsoft Visual Basic 4.0 Professional Edition
  • Microsoft Visual Basic 4.0 Professional Edition
  • Microsoft Visual Basic 4.0 16-Bit Enterprise Edition
  • Microsoft Visual Basic 4.0 32-Bit Enterprise Edition
  • Microsoft Visual Basic 2.0 Standard Edition
  • Microsoft Visual Basic 3.0 Professional Edition
  • Microsoft Visual Basic 2.0 Professional Edition
  • Microsoft Visual Basic 3.0 Professional Edition
Keywords: 
kb3rdparty kbdocs kbinfo kbprogramming kbref kbtophit KB110264
Microsoft stellt Ihnen die in der Knowledge Base angebotenen Artikel und Informationen als Service-Leistung zur Verfügung. Microsoft übernimmt keinerlei Gewährleistung dafür, dass die angebotenen Artikel und Informationen auch in Ihrer Einsatzumgebung die erwünschten Ergebnisse erzielen. Die Entscheidung darüber, ob und in welcher Form Sie die angebotenen Artikel und Informationen nutzen, liegt daher allein bei Ihnen. Mit Ausnahme der gesetzlichen Haftung für Vorsatz ist jede Haftung von Microsoft im Zusammenhang mit Ihrer Nutzung dieser Artikel oder Informationen ausgeschlossen.
Disclaimer zu nicht mehr gepflegten KB-Inhalten
Dieser Artikel wurde für Produkte verfasst, für die Microsoft keinen Support mehr anbietet. Der Artikel wird deshalb in der vorliegenden Form bereitgestellt und nicht mehr weiter aktualisiert.

Ihr Feedback an uns

 

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