Verweise auf deklarierte Elemente (Visual Basic)

  • Artikel

Wenn Ihr Code auf ein deklariertes Element verweist, gleicht der Visual Basic-Compiler den Namen in Ihrem Verweis mit der entsprechende Deklaration dieses Namens ab. Wenn mehrere Elemente mit demselben Namen deklariert wurden, können Sie durch Qualifizieren des Namens steuern, auf welches dieser Elemente verwiesen werden soll.

Der Compiler versucht, einen Namensverweis mit einer Namensdeklaration im engstmöglichen Bereich abzugleichen. Das bedeutet, dass er mit dem Code beginnt, der den Verweis enthält, und sich durch aufeinander folgende Ebenen von enthaltenden Elementen nach außen durcharbeitet.

Das folgende Beispiel zeigt Verweise auf zwei Variablen mit demselben Namen. Das Beispiel deklariert zwei Variablen, die beide totalCount heißen, auf unterschiedlichen Bereichsebenen im Modul container. Wenn der showCount-Prozedurwert totalCount ohne Qualifizierung anzeigt, löst der Visual Basic-Compiler den Verweis auf die Deklaration mit dem engstmöglichen Bereich auf, nämlich auf die lokale Deklaration in showCount. Wenn totalCount mit dem enthaltenden Modul container qualifiziert wird, löst der Compiler den Verweis auf die Deklaration mit dem weiteren Bereich auf.

' Assume these two modules are both in the same assembly.  
Module container  
    Public totalCount As Integer = 1  
    Public Sub showCount()  
        Dim totalCount As Integer = 6000  
        ' The following statement displays the local totalCount (6000).  
        MsgBox("Unqualified totalCount is " & CStr(totalCount))  
        ' The following statement displays the module's totalCount (1).  
        MsgBox("container.totalCount is " & CStr(container.totalCount))  
    End Sub  
End Module  
Module callingModule  
    Public Sub displayCount()  
        container.showCount()  
        ' The following statement displays the containing module's totalCount (1).  
        MsgBox("container.totalCount is " & CStr(container.totalCount))  
    End Sub  
End Module

Qualifizieren eines Elementnamens

Wenn Sie diesen Suchvorgang außer Kraft setzen und einen in einem weiteren Bereich deklarierten Namen angeben möchten, müssen Sie den Namen mit dem enthaltenden Element des weiteren Bereichs qualifizieren. In einigen Fällen müssen Sie möglicherweise auch das enthaltende Element qualifizieren.

Das Qualifizieren eines Namens bedeutet, dass dem Namen in Ihrer Quellanweisung Informationen vorangestellt sind, die angeben, wo das Zielelement definiert ist. Diese Informationen werden als Qualifizierungszeichenfolge bezeichnet. Zu diesen Informationen können ein oder mehrere Namespaces sowie ein Modul, eine Klasse oder eine Struktur gehören.

Die Qualifizierungszeichenfolge sollte das Modul, die Klasse oder die Struktur, das bzw. die das Zielelement enthält, eindeutig spezifizieren. Der Container kann sich wiederum in einem anderen enthaltenden Element befinden, in der Regel in einem Namespace. Möglicherweise müssen Sie mehrere enthaltende Elemente in die Qualifizierungszeichenfolge einschließen.

Zugriff auf ein deklariertes Element durch Qualifizieren des Namens

  1. Bestimmen Sie die Position, an der das Element definiert wurde. Dies kann ein Namespace oder sogar eine Namespacehierarchie sein. Im Namespace auf der untersten Ebene muss das Element in einem Modul, einer Klasse oder einer Struktur enthalten sein.

    ' Assume the following hierarchy exists outside your code.  
Namespace outerSpace  
    Namespace innerSpace  
        Module holdsTotals  
            Public Structure totals  
                Public thisTotal As Integer  
                Public Shared grandTotal As Long  
            End Structure  
        End Module  
    End Namespace  
End Namespace

  2. Bestimmen Sie basierend auf der Position des Zielelements einen Qualifizierungspfad. Der Pfad beginnt mit dem Namespace auf der höchsten Ebene, setzt sich bis zum Namespace auf der untersten Ebene fort und endet mit dem Modul, der Klasse oder der Struktur, das/die das Zielelement enthält. Jedes Element im Pfad muss das darauf folgende Element enthalten.

    outerSpace → innerSpace → holdsTotals → totals

  3. Bereiten Sie die Qualifizierungszeichenfolge für das Zielelement vor. Setzen Sie nach jedem Element im Pfad einen Punkt (.). Ihre Anwendung muss Zugriff auf jedes Element in Ihrer Qualifizierungszeichenfolge haben.

    outerSpace.innerSpace.holdsTotals.totals.

  4. Schreiben Sie den Ausdruck oder die Zuordnungsanweisung, der/die auf das Zielelement verweist, auf ganz normale Weise.

    grandTotal = 9000

  5. Stellen Sie dem Namen des Zielelements die Qualifizierungszeichenfolge voran. Der Name muss unmittelbar auf den Punkt (.) hinter dem Modul, der Klasse oder der Struktur folgen, das/die das Element enthält.

    ' Assume the following module is part of your code.  
Module accessGrandTotal  
    Public Sub setGrandTotal()  
        outerSpace.innerSpace.holdsTotals.totals.grandTotal = 9000  
    End Sub  
End Module

  6. Der Compiler verwendet die Qualifizierungszeichenfolge, um eine klare und eindeutige Deklaration zu finden, mit der er den Zielelementverweis abgleichen kann.

Möglicherweise müssen Sie auch einen Namensverweis qualifizieren, wenn Ihre Anwendung Zugriff auf mehrere Programmierelemente mit demselben Namen hat. Beispielsweise enthalten die beiden Namespaces System.Windows.Forms und System.Web.UI.WebControls eine Label-Klasse (System.Windows.Forms.Label und System.Web.UI.WebControls.Label). Wenn Ihre Anwendung beide verwendet oder eine eigene Label-Klasse definiert, müssen Sie die verschiedenen Label-Objekte kennzeichnen. Schließen Sie den Namespace oder den Importalias in die Variablendeklaration ein. Das folgende Beispiel verwendet den Importalias.

' The following statement must precede all your declarations.  
Imports win = System.Windows.Forms, web = System.Web.UI.WebControls  
' The following statement references the Windows.Forms.Label class.  
Dim winLabel As New win.Label()

Member anderer enthaltender Elemente

Wenn Sie einen nicht gemeinsam verwendeten Member einer anderen Klasse oder Struktur verwenden, müssen Sie zuerst den Membernamen mit einer Variablen oder einem Ausdruck qualifizieren, die bzw. der auf eine Instanz der Klasse oder Struktur verweist. Im folgenden Beispiel ist demoClass eine Instanz einer Klasse namens class1.

Dim demoClass As class1 = New class1()  
demoClass.someSub[(argumentlist)]

Sie können zum Qualifizieren eines nicht gemeinsam verwendeten Members nicht den Klassennamen selbst verwenden. Sie müssen zuerst eine Instanz in einer Objektvariable (in diesem Fall demoClass) erstellen und dann anhand des Variablennamens darauf verweisen.

Wenn eine Klasse oder Struktur einen Shared-Member enthält, können Sie diesen Member entweder mit dem Klassen- oder Strukturnamen oder mit einer Variablen oder einem Ausdruck qualifizieren, die/der auf eine Instanz verweist.

Ein Modul verfügt nicht über separate Instanzen, und alle Member sind standardmäßig Shared. Daher qualifizieren Sie einen Modulmember anhand des Modulnamens.

Das folgende Beispiel zeigt qualifizierte Verweise auf Modulmemberprozeduren. Das Beispiel deklariert zwei Sub-Prozeduren, die beide performheißen, in verschiedenen Modulen in einem Projekt. Jede kann innerhalb eines eigenen Moduls ohne Qualifizierung angegeben werden, muss aber qualifiziert werden, wenn von außerhalb darauf verwiesen wird. Da der letzte Verweis in module3 keine Qualifizierung für perform enthält, kann der Compiler diesen Verweis nicht auflösen.

' Assume these three modules are all in the same assembly.  
Module module1  
    Public Sub perform()  
        MsgBox("module1.perform() now returning")  
    End Sub  
End Module  
Module module2  
    Public Sub perform()  
        MsgBox("module2.perform() now returning")  
    End Sub  
    Public Sub doSomething()  
        ' The following statement calls perform in module2, the active module.  
        perform()  
        ' The following statement calls perform in module1.  
        module1.perform()  
    End Sub  
End Module  
Module module3  
    Public Sub callPerform()  
        ' The following statement calls perform in module1.  
        module1.perform()  
        ' The following statement makes an unresolvable name reference  
        ' and therefore generates a COMPILER ERROR.  
        perform() ' INVALID statement  
    End Sub  
End Module

Verweise auf Projekte

Um Public-Elemente zu verwenden, die in einem anderen Projekt definiert sind, müssen Sie zuerst einen Verweis auf die Assembly oder Typbibliothek dieses Projekts festlegen. Zum Festlegen eines Verweises klicken Sie im Menü Projekt auf Verweis hinzufügen oder verwenden die Befehlszeilencompileroption -reference (Visual Basic).

Sie können z. B. das XML-Objektmodell von .NET Framework verwenden. Wenn Sie einen Verweis auf den Namespace System.Xml festlegen, können Sie alle Klassen deklarieren und verwenden, z. B. XmlDocument. Im folgenden Beispiel wird XmlDocument verwendet.

' Assume this project has a reference to System.Xml  
' The following statement creates xDoc as an XML document object.  
Dim xDoc As System.Xml.XmlDocument

Importieren von enthaltenden Elementen

Sie können die Imports-Anweisung (.NET-Namespace und -Typ) verwenden, um die Namespaces zu importieren, die die Module oder Klassen enthalten, die Sie verwenden möchten. Auf diese Weise können Sie auf die in einem importierten Namespace definierten Elemente verweisen, ohne ihre Namen vollständig qualifizieren zu müssen. Das folgende Beispiel schreibt das vorherige Beispiel neu, um den Namespace System.Xml zu importieren.

' Assume this project has a reference to System.Xml  
' The following statement must precede all your declarations.  
Imports System.Xml  
' The following statement creates xDoc as an XML document object.  
Dim xDoc As XmlDocument

Darüber hinaus kann die Imports-Anweisung einen Importalias für jeden importierten Namespace definieren. Das kann dafür sorgen, dass der Quellcode kürzer und einfacher zu lesen ist. Das folgende Beispiel schreibt das vorherige Beispiel neu, um xD als Alias für den Namespace System.Xml zu verwenden.

' Assume this project has a reference to System.Xml  
' The following statement must precede all your declarations.  
Imports xD = System.Xml  
' The following statement creates xDoc as an XML document object.  
Dim xDoc As xD.XmlDocument

Die Imports-Anweisung macht keine Elemente aus anderen Projekten für Ihre Anwendung verfügbar. Sie ersetzt also nicht das Festlegen eines Verweises. Das Importieren eines Namespaces beseitigt lediglich die Anforderung, die in diesem Namespace definierten Namen zu qualifizieren.

Sie können auch die Imports-Anweisung verwenden, um Module, Klassen, Strukturen und Enumerationen zu importieren. Anschließend können Sie die Member dieser importierten Elemente ohne Qualifizierung verwenden. Sie müssen jedoch nicht gemeinsam verwendete Member von Klassen und Strukturen immer mit einer Variablen oder einem Ausdruck qualifizieren, die bzw. der zu einer Instanz der Klasse oder Struktur ausgewertet wird.

Richtlinien für die Benennung

Wenn Sie zwei oder mehr Programmierelemente mit demselben Namen definieren, kann eine Namensmehrdeutigkeit entstehen, wenn der Compiler versucht, einen Verweis auf diesen Namen aufzulösen. Wenn sich keine oder mehr als eine Definition im Bereich befindet, kann der Verweis nicht aufgelöst werden. Ein Beispiel finden Sie unter „Beispiel für qualifizierte Verweise“ auf dieser Hilfeseite.

Sie können eine Mehrdeutigkeit von Namen vermeiden, indem Sie für alle Elemente eindeutige Namen verwenden. Dann können Sie auf jedes beliebige Element verweisen, ohne den Namen des Elements mit einem Namespace, einem Modul oder einer Klasse qualifizieren zu müssen. Damit reduzieren Sie auch die Wahrscheinlichkeit, dass versehentlich auf das falsche Element verwiesen wird.

Shadowing

Wenn zwei Programmierelemente denselben Namen aufweisen, kann eins davon das andere durch so genanntes Shadowing verbergen. Ein Element, für das ein solches Shadowing durchgeführt wurde, ist nicht für Verweise verfügbar. Wenn Ihr Code den Namen dieses Elements verwendet, löst der Visual Basic-Compiler den Namen stattdessen in das Element auf, das das Shadowing durchführt. Eine ausführlichere Erläuterung mit Beispielen finden Sie unter Shadowing in Visual Basic.

Siehe auch