Condividi tramite

Procedura: nascondere una variabile con lo stesso nome di un'altra variabile (Visual Basic)

  • Articolo

È possibile nascondere una variabile ridefinendola con una variabile con lo stesso nome. È possibile nascondere la variabile in due modi:

  • Nascondere la variabile tramite ambito. È possibile ridichiarare la variabile da nascondere all'interno di un'area secondaria della relativa area.

  • Nascondere la variabile tramite ereditarietà. Se la variabile da nascondere è definita a livello di classe, è possibile nasconderla tramite ereditarietà ripetendola con la parola chiave Shadows in una classe derivata.

Due modi per nascondere una variabile

Per nascondere una variabile tramite ambito

  1. Determinare l'area che definisce la variabile da nascondere e un'area secondaria in cui ridefinirla con la variabile.

    Area della variabile Area secondaria consentita per la ridefinizione
    Modulo Classe all'interno del modulo
    Classe Sottoclasse all'interno della classe

    Routine all'interno della classe

    Non è possibile ridefinire una variabile di routine in un blocco all'interno di tale routine, ad esempio in un costrutto If...End If o in un ciclo For.

  2. Creare l'area secondaria se non esiste già.

  3. All'interno dell'area secondaria scrivere un'istruzione Dim che dichiara la variabile da nascondere.

    Quando il codice all'interno dell'area secondaria fa riferimento al nome della variabile, il compilatore risolve il riferimento alla variabile da nascondere.

    L'esempio seguente illustra come nascondere tramite ambito, oltre a un riferimento che ignora l'azione di nascondere.

    Module shadowByScope
    ' The following statement declares num as a module-level variable.
    Public num As Integer
    Sub show()
        ' The following statement declares num as a local variable.
        Dim num As Integer
        ' The following statement sets the value of the local variable.
        num = 2
        ' The following statement displays the module-level variable.
        MsgBox(CStr(shadowByScope.num))
    End Sub
    Sub useModuleLevelNum()
        ' The following statement sets the value of the module-level variable.
        num = 1
        show()
    End Sub
End Module

    L'esempio precedente dichiara la variabile num sia a livello di modulo che a livello di routine (nella routine show). La variabile locale num nasconde la variabile a livello di modulo num all'interno di show, quindi la variabile locale è impostata su 2. Tuttavia, non esiste alcuna variabile locale per nascondere num nella routine useModuleLevelNum. Pertanto, useModuleLevelNum imposta il valore della variabile a livello di modulo su 1.

    La chiamata MsgBox all'interno di show ignora il meccanismo per nascondere qualificando num con il nome del modulo. Pertanto, visualizza la variabile a livello di modulo anziché la variabile locale.

Per nascondere una variabile tramite ereditarietà

  1. Assicurarsi che la variabile da nascondere sia dichiarata in una classe e a livello di classe (all'esterno di qualsiasi routine). In caso contrario, non è possibile nasconderla tramite ereditarietà.

  2. Definire una classe derivata dalla classe della variabile, se non ne esiste già una.

  3. All'interno della classe derivata scrivere un'istruzione Dim che dichiara la variabile. Includere la parola chiave Shadows nella dichiarazione.

    Quando il codice nella classe derivata fa riferimento al nome della variabile, il compilatore risolve il riferimento alla variabile.

    L'esempio seguente illustra come nascondere tramite ereditarietà. Vengono creati due riferimenti, uno che accede alla variabile da nascondere e l'altro che ignora l'azione di nascondere.

    Public Class shadowBaseClass
    Public shadowString As String = "This is the base class string."
End Class
Public Class shadowDerivedClass
    Inherits shadowBaseClass
    Public Shadows shadowString As String = "This is the derived class string."
    Public Sub showStrings()
        Dim s As String = "Unqualified shadowString: " & shadowString &
             vbCrLf & "MyBase.shadowString: " & MyBase.shadowString
        MsgBox(s)
    End Sub
End Class

    L'esempio precedente dichiara la variabile shadowString nella classe di base e la nasconde nella classe derivata. La routine showStrings nella classe derivata visualizza la versione da nascondere della stringa quando il nome shadowString non è qualificato. Visualizza quindi la versione nascosta quando shadowString è qualificato con la parola chiave MyBase.

Programmazione efficiente

Nascondendo la variabile ne vengono introdotte più versioni con lo stesso nome. Quando un'istruzione di codice fa riferimento al nome della variabile, la versione con cui il compilatore risolve il riferimento dipende da fattori come la posizione dell'istruzione di codice e la presenza di una stringa qualificata. Ciò può aumentare il rischio di fare riferimento a una versione non intenzionale di una variabile nascosta. È possibile ridurre il rischio qualificando completamente tutti i riferimenti a una variabile nascosta.

Vedi anche