Condividi tramite

Procedura: Nascondere una variabile con lo stesso nome della variabile (Visual Basic)

È possibile nascondere una variabile nascondendola, ovvero definendola con una variabile con lo stesso nome. È possibile nascondere la variabile che si vuole nascondere in due modi:

  • Ombreggiatura attraverso l'ambito di visibilità. È possibile occultarla nel suo scope ridefinendola all'interno di una sottozona della regione che contiene la variabile che si desidera nascondere.

  • Sovrascrittura attraverso l'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 sovrapponendola a un'altra nello stesso ambito

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

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

    Una routine all'interno della classe

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

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

  3. All'interno della sottoregione, scrivere una Dichiarazione Dim che dichiara la variabile ombreggiante.

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

    L'esempio seguente illustra il nascondimento attraverso l'ambito, nonché un riferimento che ignora il nascondimento.

    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 procedura show). La variabile locale num oscura la variabile a livello di modulo num all'interno di show, quindi la variabile locale è impostata su 2. Tuttavia, non esiste alcuna variabile locale da nascondere num nella useModuleLevelNum procedura. Pertanto, useModuleLevelNum imposta il valore della variabile a livello di modulo su 1.

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

Per nascondere una variabile nascondendola tramite l'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 nascondere l'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.

    Nell'esempio seguente viene illustrata l'ombreggiatura tramite ereditarietà. Fa due riferimenti, uno che accede alla variabile di ombreggiatura e uno che ignora l'ombreggiatura.

    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 che la nasconde nella classe derivata. La routine showStrings nella classe derivata visualizza la versione shadowing della stringa quando il nome shadowString non è qualificato. Viene quindi visualizzata la versione ombreggiata quando shadowString è qualificata con la MyBase parola chiave .

Programmazione affidabile

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

Vedere anche