Références aux éléments déclarés (Visual Basic)

  • Article

Lorsque votre code fait référence à un élément déclaré, le compilateur Visual Basic correspond au nom dans votre référence à la déclaration appropriée de ce nom. Si plusieurs éléments sont déclarés avec le même nom, vous pouvez contrôler lequel de ces éléments doit être référencé en qualifiant son nom.

Le compilateur tente de faire correspondre une référence de nom à une déclaration de nom avec l’étendue la plus étroite. Cela signifie qu’il commence par le code qui fait référence et va vers l’extérieur en passant par des niveaux successifs d’éléments de contenu.

L’exemple suivant montre des références à deux variables portant le même nom. L’exemple déclare deux variables, chacune nommée totalCount, à différents niveaux d’étendue dans le module container. Lorsque la procédure showCount s’affiche totalCount sans qualification, le compilateur Visual Basic résout la référence à la déclaration avec la portée la plus étroite, à savoir la déclaration locale à l’intérieur de showCount. Lorsqu’il qualifie totalCount avec le module conteneur container, le compilateur résout la référence à la déclaration avec l’étendue plus large.

' 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

Qualification d’un nom d’élément

Si vous souhaitez remplacer ce processus de recherche et spécifier un nom déclaré dans une étendue plus large, vous devez qualifier le nom avec l’élément conteneur de l’étendue plus large. Dans certains cas, vous devrez peut-être également qualifier l’élément conteneur.

La qualification d’un nom signifie qu’elle précède dans votre instruction source avec des informations qui identifient où l’élément cible est défini. Ces informations sont appelées chaîne de qualification. Elles peuvent inclure un ou plusieurs espaces de noms et un module, une classe ou une structure.

La chaîne de qualification doit spécifier sans ambiguïté le module, la classe ou la structure contenant l’élément cible. Le conteneur peut à son tour se trouver dans un autre élément contenant, généralement, un espace de noms. Vous devrez peut-être inclure plusieurs éléments conteneurs dans la chaîne de qualification.

Accéder à un élément déclaré en qualifiant son nom

  1. Déterminez l’emplacement dans lequel l’élément a été défini. Cela peut inclure un espace de noms, voire une hiérarchie d’espaces de noms. Dans l’espace de noms de niveau le plus bas, l’élément doit être contenu dans un module, une classe ou une structure.

    ' 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. Déterminez un chemin de qualification en fonction de l’emplacement de l’élément cible. Commencez par l’espace de noms de niveau le plus élevé, passez à l’espace de noms de niveau le plus bas et terminez par le module, la classe ou la structure contenant l’élément cible. Chaque élément du chemin d’accès doit contenir l’élément qui le suit.

    outerSpace → innerSpace → holdsTotals → totals

  3. Préparez la chaîne de qualification de l’élément cible. Placez un point (.) après chaque élément du chemin d’accès. Votre application doit avoir accès à chaque élément de votre chaîne de qualification.

    outerSpace.innerSpace.holdsTotals.totals.

  4. Écrivez l’expression ou l’instruction d’assignation faisant référence à l’élément cible de la manière normale.

    grandTotal = 9000

  5. Précédez le nom de l’élément cible avec la chaîne de qualification. Le nom doit suivre immédiatement le point (.) qui suit le module, la classe ou la structure qui contient l’élément.

    ' 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. Le compilateur utilise la chaîne de qualification pour trouver une déclaration claire et non ambiguë à laquelle il peut associer la référence de l’élément cible.

Vous devrez peut-être également qualifier une référence de nom si votre application a accès à plusieurs éléments de programmation portant le même nom. Par exemple, les espaces de noms System.Windows.Forms et System.Web.UI.WebControls contiennent tous deux une classe Label (System.Windows.Forms.Label et System.Web.UI.WebControls.Label). Si votre application utilise les deux, ou si elle définit sa propre classe Label, vous devez distinguer les différents objets Label. Incluez l’espace de noms ou l’alias d’importation dans la déclaration de variable. L’exemple suivant utilise l’alias d’importation.

' 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()

Membres d’autres éléments conteneur

Lorsque vous utilisez un membre non partagé d’une autre classe ou structure, vous devez d’abord qualifier le nom du membre avec une variable ou une expression qui pointe vers une instance de la classe ou de la structure. Dans l’exemple suivant, demoClass est une instance d’une classe nommée class1.

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

Vous ne pouvez pas utiliser le nom de la classe proprement dit pour qualifier un membre qui n’est pas Partagé. Vous devez d’abord créer une instance dans une variable objet (dans ce cas demoClass) puis la référencer par le nom de la variable.

Si une classe ou une structure a un membre Shared, vous pouvez qualifier ce membre avec le nom de la classe ou de la structure ou avec une variable ou une expression qui pointe vers une instance.

Un module n’a pas d’instances distinctes et tous ses membres sont Shared par défaut. Par conséquent, vous qualifiez un membre de module avec le nom du module.

L’exemple suivant montre des références qualifiées aux procédures membres du module. L’exemple déclare deux procédures Sub, toutes deux nommées perform, dans différents modules d’un projet. Chacun d’eux peut être spécifié sans qualification dans son propre module, mais doit être qualifié s’il est référencé n’importe où ailleurs. Étant donné que la référence finale dans module3 ne qualifie pas perform, le compilateur ne peut pas résoudre cette référence.

' 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

Références aux projets

Pour utiliser des éléments Publics définis dans un autre projet, vous devez d’abord définir une référence à l’assembly ou à la bibliothèque de types de ce projet. Pour définir une référence, cliquez sur Ajouter une référence dans le menu Projet ou utilisez l’option du compilateur de ligne de commande -reference (Visual Basic).

Par exemple, vous pouvez utiliser le modèle objet XML du .NET Framework. Si vous définissez une référence à l’espace de noms System.Xml, vous pouvez déclarer et utiliser l’une de ses classes, par exemple XmlDocument. L'exemple suivant utilise XmlDocument.

' 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

Importation d’éléments conteneurs

Vous pouvez utiliser l’instruction Imports (espace de noms et type.NET) pour importer les espaces de noms qui contiennent les modules ou classes que vous souhaitez utiliser. Cela vous permet de faire référence aux éléments définis dans un espace de noms importé sans qualifier pleinement leurs noms. L’exemple suivant réécrit l’exemple précédent pour importer l’espace de noms System.Xml.

' 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

En outre, l’instruction Imports peut définir un alias d’importation pour chaque espace de noms importé. Cela peut rendre le code source plus court et plus facile à lire. L’exemple suivant réécrit l’exemple précédent pour utiliser xD comme alias pour l’espace de noms System.Xml.

' 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

L’instruction Imports ne rend pas les éléments d’autres projets disponibles pour votre application. C’est-à-dire qu’il ne prend pas la place de la définition d’une référence. L’importation d’un espace de noms supprime simplement l’exigence de qualifier les noms définis dans cet espace de noms.

Vous pouvez également utiliser l’instruction Imports pour importer des modules, des classes, des structures et des énumérations. Vous pouvez ensuite utiliser les membres de ces éléments importés sans qualification. Toutefois, vous devez toujours qualifier des membres non partagés de classes et de structures avec une variable ou une expression qui prend la valeur d’une instance de la classe ou de la structure.

Indications concernant l'attribution d'un nom

Lorsque vous définissez deux éléments de programmation ou plus portant le même nom, une ambiguïté de nom peut se produire lorsque le compilateur tente de résoudre une référence à ce nom. Si plusieurs définitions sont dans l’étendue ou si aucune définition n’est dans l’étendue, la référence est irrésolue. Pour obtenir un exemple, consultez « Exemple de référence qualifié » dans cette page d’aide.

Vous pouvez éviter toute ambiguïté de nom en donnant à tous vos éléments des noms uniques. Vous pouvez ensuite faire référence à n’importe quel élément sans avoir à qualifier son nom avec un espace de noms, un module ou une classe. Vous réduisez également les chances de faire référence accidentellement à l’élément incorrect.

Copie shadow

Lorsque deux éléments de programmation partagent le même nom, l’un d’entre eux peut masquer ou mettre l’autre en mémoire fantôme. Un élément mis en mémoire fantôme n’est pas disponible pour référence ; au lieu de cela, lorsque votre code utilise le nom de l’élément mis en mémoire fantôme, le compilateur Visual Basic le résout en élément mis en mémoire fantôme. Pour obtenir une explication plus détaillée avec des exemples, consultez Mise en mémoire fantôme Visual Basic.

Voir aussi