Freigeben über

Verweise auf deklarierte Elemente (Visual Basic)

Wenn ihr Code auf ein deklariertes Element verweist, entspricht der Visual Basic-Compiler dem Namen in Ihrem Verweis auf die entsprechende Deklaration dieses Namens. Wenn mehrere Elemente mit demselben Namen deklariert werden, können Sie steuern, auf welche dieser Elemente verwiesen werden soll, indem Sie ihren Namen qualifizieren .

Der Compiler versucht, einen Namensverweis mit der Namensdeklaration im engsten Geltungsbereich 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. Im Beispiel werden zwei Variablen deklariert, die jeweils benannt totalCountwerden, 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 breiteren Bereich deklarierten Namen angeben möchten, müssen Sie den Namen mit dem enthaltenden Element des breiteren 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 Qualifikationszeichenfolge bezeichnet. Sie kann einen oder mehrere Namespaces und ein Modul, eine Klasse oder eine Struktur enthalten.

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

So greifen Sie auf ein deklariertes Element zu, indem Sie seinen Namen qualifizieren

  1. Bestimmen Sie die Position, an der das Element definiert wurde. Dies kann einen Namespace oder sogar eine Hierarchie von Namespaces umfassen. Innerhalb des Namespace der niedrigsten 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 einen Qualifizierungspfad basierend auf der Position des Zielelements. Beginnen Sie mit dem Namespace der höchsten Ebene, fahren Sie mit dem Namespace der niedrigsten Ebene fort, und enden Sie mit dem Modul, der Klasse oder der Struktur, die das Zielelement enthält. Jedes Element im Pfad muss das darauf folgende Element enthalten.

    outerSpace innerSpace → → → holdsTotalstotals

  3. Bereiten Sie die Qualifizierungszeichenfolge für das Zielelement vor. Platzieren Sie einen Punkt (.) nach jedem Element im Pfad. Ihre Anwendung muss Zugriff auf jedes Element in Ihrer Qualifikationszeichenfolge 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 Qualifikationszeichenfolge 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 Qualifikationszeichenfolge, um eine klare, eindeutige Deklaration zu finden, zu der er die Zielelementreferenz zuordnen kann.

Möglicherweise müssen Sie auch einen Namensverweis qualifizieren, wenn Ihre Anwendung Zugriff auf mehrere Programmierelemente hat, die denselben Namen haben. Zum Beispiel enthalten sowohl die System.Windows.Forms- als auch die System.Web.UI.WebControls-Namespaces eine Label-Klasse (System.Windows.Forms.Label und System.Web.UI.WebControls.Label). Wenn Ihre Anwendung beides verwendet oder eine eigene Label Klasse definiert, müssen Sie die verschiedenen Label Objekte unterscheiden. Schließen Sie den Namespace oder den Importalias in die Variablendeklaration ein. Im folgenden Beispiel wird der Importalias verwendet.

' 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 ein nicht gemeinsam genutztes Element einer anderen Klasse oder Struktur verwenden, müssen Sie zuerst den Membernamen mit einer Variablen oder einem Ausdruck qualifizieren, die auf eine Instanz der Klasse oder Struktur verweist. Im folgenden Beispiel demoClass ist eine Instanz einer Klasse mit dem Namen class1.

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

Sie können den Klassennamen nicht selbst verwenden, um ein Element zu qualifizieren, das nicht freigegeben ist. Sie müssen zuerst eine Instanz in einer Objektvariablen (in diesem Fall demoClass) erstellen und dann anhand des Variablennamens darauf verweisen.

Wenn eine Klasse oder Struktur über ein Shared Element verfügt, können Sie dieses Element entweder mit dem Klassen- oder Strukturnamen oder mit einer Variablen oder einem Ausdruck qualifizieren, 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, beide benannt perform, in verschiedenen Modulen in einem Projekt. Jeder kann ohne Qualifikation innerhalb eines eigenen Moduls angegeben werden, muss aber qualifiziert werden, wenn von überall aus 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 öffentliche Elemente zu verwenden, die in einem anderen Projekt definiert sind, müssen Sie zuerst einen Verweis auf die Assembly oder Typbibliothek dieses Projekts festlegen. Wenn Sie einen Verweis festlegen möchten, klicken Sie im Menü "Projekt hinzufügen" auf "Verweis hinzufügen", oder verwenden Sie die Befehlszeilencompileroption -reference (Visual Basic).

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

' 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 zu qualifizieren. Im folgenden Beispiel wird das vorherige Beispiel neu geschrieben, um den System.Xml Namespace 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 Import-Alias für jeden importierten Namespace definieren. Dadurch kann der Quellcode kürzer und einfacher zu lesen sein. Im folgenden Beispiel wird das vorherige Beispiel so umgeschrieben, dass xD als Alias für den System.Xml-Namespace verwendet wird.

' 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 stellt keine Elemente aus anderen Projekten Ihrer Anwendung zur Verfügung. Sie ersetzt also nicht das Festlegen eines Verweises. Durch das Importieren eines Namespaces wird lediglich die Anforderung entfernt, die in diesem Namespace definierten Namen zu qualifizieren.

Sie können die Imports Anweisung auch 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.

Benennungsrichtlinien

Wenn Sie zwei oder mehr Programmierelemente definieren, die denselben Namen haben, kann ein Name mehrdeutig sein, 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 "Qualifiziertes Referenzbeispiel" auf dieser Hilfeseite.

Sie können Die Namensdeutigkeit vermeiden, indem Sie alle Ihre Elemente eindeutigen Namen geben. Anschließend können Sie auf jedes Element verweisen, ohne seinen Namen mit einem Namespace, Modul oder einer Klasse qualifizieren zu müssen. Sie reduzieren auch die Wahrscheinlichkeit, versehentlich auf das falsche Element zu verweisen.

Beschattung

Wenn zwei Programmierelemente denselben Namen aufweisen, kann eines davon die andere ausblenden oder schatten. Ein abgeschattetes Element steht nicht zur Referenz zur Verfügung. Wenn ihr Code stattdessen den Namen des abgeschatteten Elements verwendet, löst der Visual Basic-Compiler ihn in das Schattenelement auf. Eine ausführlichere Erläuterung mit Beispielen finden Sie unter Schatten in Visual Basic.

Siehe auch