Visual Basic 2012 Voorbeelden
   

visual basic 2012 broncode voorbeelden

Blijf op de hoogte van de recente aanpassingen op vbvoorbeelden!

Microsoft Visual Studio 2012Microsoft Developers Network - Visual BasicMicrosoft .NET Framework

11.4. Redefinition - Invariance, Covariance en Contravariance

Print Email Deel op Twitter Deel op Facebook

Dit artikel is gepubliceerd op maandag 15 oktober 2012 op vbvoorbeelden, bezoek de website voor een recente versie van dit artikel of andere artikels.

11.4.1. Geen Contravariant Parametertype Toegestaan

Bij het herdefiniëren van Method1 in DerivedClass (1) zou je gezien Liskovs Substitution Principle (LSP) verwachten dat je het argumenttype het basistype zou mogen zijn van Apple, namelijk Fruit.  Dit is wat men contravariance noemt, of op zijn minst een contravariant parametertype (basistype als parametertype).
Visual Basic 2012 Broncode - Codevoorbeeld 310
Class Fruit
    Public Function MethodA() As String
    End Function
End Class
Class Apple : Inherits Fruit
    Public Function MethodB() As String
    End Function
End Class
Class GrannySmith : Inherits Apple
    Public Function MethodC() As String
    End Function
End Class
Class JonaGold : Inherits Apple
    Public Function MethodD() As String
    End Function
End Class

Class BaseClass
    Public Overridable Sub Method1(ByVal argument As Apple)                ' (3)
    End Sub
End Class
Class DerivedClass : Inherits BaseClass
    ' invariance (unchanged parametertype) : possible
    Public Overrides Sub Method1(ByVal argument As Apple)                  ' (6)
    End Sub
    ' contravariant (supertype) parametertype : expected, but not possible
    Public Overrides Sub Method1(ByVal argument As Fruit)                  ' (1)
        Console.WriteLine(argument.MethodA())                              ' (4)
    End Sub
    ' covariant (subtype) parametertype : as expected not possible
    'Public Overrides Sub Method1(ByVal argument As GrannySmith)           ' (7)
    'End Sub
End Class

Class ExpectedContraVariance
    Public Shared Sub Main()
        Dim grannySmith1 As GrannySmith = New GrannySmith
        Dim jonaGold1 As JonaGold = New JonaGold
        '
        Dim object1 As BaseClass = New DerivedClass                        ' (5)
        '
        object1.Method1(grannySmith1)                                      ' (2)
        'object1.Method1(jonaGold1)                                        ' (8)
    End Sub
End Class
Bij de call naar Method1 op object1 (2) kunnen we enkel een Apple, en dus geen Fruit doorgeven.  De signatuur van Method1 in BaseClass (3) definieert immers een argument van type Apple te verwachten.
De implementatie van Method1 in DerivedClass (4) kan, gezien zijn signatuur (1), enkel werken op een variable van statisch type Fruit.
Het dynamisch type van object1 mag dan nog wel DerivedClass zijn, het wordt gebonden aan een implementatie (4) die er niets meer mee zal doen dan wat met een Fruit kan doen, bijvoorbeeld aanroepen van MethodA, wat ook met een Apple kan.

Dit mag dan al te verwachten zijn, toch is dit niet mogelijk.  Bij redefinition mag men het parametertype niet veranderen (6), dit is wat men ook wel invariance noemt.

Dat een covariant parametertype (een afgeleid parametertype) niet mogelijk is, is gezien LSP logisch.  De call naar Method1 op object1 verwacht een argument van type Apple, het statisch type van object1 is immers BaseClass, dat Method1 heeft gedefinieert als een procedure die een Apple verwacht.
Als we in de herdefinitie (7) opeens een subtype als parametertype nemen, dan loopt de call op regel (8) fout.  De doorgegeven JonaGold is immers geen GrannySmith.

11.4.2. Geen Covariant Returntype Toegestaan

Ook het returntype mag bij een herdefinitie niet veranderen.  Toch zou men op zijn minst de mogelijkheid verwachten, gezien LSP, om een covariant returntype te kunnen kiezen.
Op de expressie van type Apple die de object1.Method2() call vormt, kan je MethodB aanroepen.  Dat de call naar MethodB wordt gebonden aan de implementatie van een GrannySmith, die Method2 van DerivedClass oplevert, is dan ook geen enkel probleem.

Toch is dit niet toegestaan.  Het returntype mag in een herdefinitie niet veranderen.

Dat men in de herdefinitie geen basistype als returntype mag gebruiken is gezien LSP logisch.  Stel dat Method2 een Fruit object oplevert, zoals implementatie (1), dan zou men MethodB die daarop wordt aangeroepen, niet kunnen binden aan een implementatie.  Een Fruit heeft immers geen MethodB.
Visual Basic 2012 Broncode - Codevoorbeeld 311
Partial Class BaseClass
    Public Overridable Function Method2() As Apple
        Method2 = New Apple
    End Function
End Class
Partial Class DerivedClass : Inherits BaseClass
    ' invariance (unchanged returntype) : possible
    Public Overrides Function Method2() As Apple
        Method2 = New Apple
    End Function
    ' covariant (subtype) returntype : expected, but not possible
    Public Overrides Function Method2() As GrannySmith
        Method2 = New GrannySmith
    End Function
    ' contravariant (supertype) returntype : as expected not possible
    'Public Overrides Function Method2() As Fruit
    '    Method2 = New Fruit                                               ' (1)
    'End Function
End Class

Class ExpectedCoVariance
    Public Shared Sub Main()
        Dim grannySmith1 As GrannySmith = New GrannySmith
        Dim jonaGold1 As JonaGold = New JonaGold
        '
        Dim object1 As BaseClass = New DerivedClass                        ' (5)
        '
        Console.WriteLine(object1.Method2().MethodB())
    End Sub
End Class

Dit artikel is gepubliceerd op maandag 15 oktober 2012 op vbvoorbeelden, bezoek de website voor een recente versie van dit artikel of andere artikels.