Share via

Typhöjning (Visual Basic)

  • Artikel

När du deklarerar ett programmeringselement i en modul höjer Visual Basic upp dess omfång till det namnområde som innehåller modulen. Detta kallas för typhöjning.

I följande exempel visas en skelettdefinition av en modul och två medlemmar i modulen.

Namespace projNamespace
    Module projModule
        Public Enum basicEnum As Integer
            one = 1
            two = 2
        End Enum
        Public Class innerClass
            Shared Sub numberSub(ByVal firstArg As Integer)
            End Sub
        End Class
    End Module
End Namespace

Inom projModulebefordras programmeringselement som deklarerats på modulnivå till projNamespace. I föregående exempel basicEnum befordras och innerClass , men numberSub inte, eftersom det inte deklareras på modulnivå.

Effekt av typhöjning

Effekten av typhöjning är att en kvalificeringssträng inte behöver inkludera modulnamnet. I följande exempel görs två anrop till proceduren i föregående exempel.

Sub usePromotion()
    projNamespace.projModule.innerClass.numberSub(projNamespace.projModule.basicEnum.one)
    projNamespace.innerClass.numberSub(projNamespace.basicEnum.two)
End Sub

I föregående exempel använder det första anropet fullständiga kvalificeringssträngar. Detta är dock inte nödvändigt på grund av typhöjning. Det andra anropet kommer också åt modulens medlemmar utan att inkludera projModule i kvalifikationssträngarna.

Befordring av typnederlag

Om namnområdet redan har en medlem med samma namn som en modulmedlem, så besegras typhöjningen för modulmedlemmen. I följande exempel visas en skelettdefinition av en uppräkning och en modul inom samma namnområde.

Namespace thisNamespace
    Public Enum abc
        first = 1
        second
    End Enum
    Module thisModule
        Public Class abc
            Public Sub abcSub()
            End Sub
        End Class
        Public Class xyz
            Public Sub xyzSub()
            End Sub
        End Class
    End Module
End Namespace

I föregående exempel kan Visual Basic inte höja upp klassen abc till thisNameSpace eftersom det redan finns en uppräkning med samma namn på namnområdesnivå. För att få åtkomst abcSubmåste du använda den fullständiga kvalificeringssträngen thisNamespace.thisModule.abc.abcSub. Klassen xyz har dock fortfarande befordrats och du kan komma åt xyzSub med den kortare kvalifikationssträngen thisNamespace.xyz.xyzSub.

Förlust av typhöjning för partiella typer

Om en klass eller struktur i en modul använder nyckelordet Partial (Partiell) besegras typhöjningen automatiskt för den klassen eller strukturen, oavsett om namnområdet har en medlem med samma namn eller inte. Andra element i modulen är fortfarande berättigade till typhöjning.

Konsekvenser. Överflyttning av typ av en partiell definition kan orsaka oväntade resultat och till och med kompilatorfel. I följande exempel visas partiella definitioner av en klass, varav en finns i en modul.

Namespace sampleNamespace
    Partial Public Class sampleClass
        Public Sub sub1()
        End Sub
    End Class
    Module sampleModule
        Partial Public Class sampleClass
            Public Sub sub2()
            End Sub
        End Class
    End Module
End Namespace

I föregående exempel kan utvecklaren förvänta sig att kompilatorn sammanfogar de två partiella definitionerna av sampleClass. Kompilatorn överväger dock inte befordran för den partiella definitionen i sampleModule. Därför försöker den kompilera två separata och distinkta klasser, båda namngivna sampleClass men med olika kvalificeringsvägar.

Kompilatorn sammanfogar endast partiella definitioner när deras fullständigt kvalificerade sökvägar är identiska.

Rekommendationer

Följande rekommendationer representerar god programmeringspraxis.

  • Unika namn. När du har fullständig kontroll över namngivning av programmeringselement är det alltid en bra idé att använda unika namn överallt. Identiska namn kräver extra kvalificering och kan göra koden svårare att läsa. De kan också leda till subtila fel och oväntade resultat.

  • Fullständig kvalificering. När du arbetar med moduler och andra element i samma namnområde är den säkraste metoden att alltid använda fullständig kvalificering för alla programmeringselement. Om typhöjningen har besegrats för en modulmedlem och du inte kvalificerar den medlemmen fullt ut kan du oavsiktligt komma åt ett annat programmeringselement.

Se även