2012-03-30 1 views
1

Ich habe Klassen wie folgt strukturiert:Eigenschaftsmodifikatoren

Public MustInherit Class A 
    ' several properties 
End Class 

Public Class B 
    Inherits A 
    ' several properties 
End Class 

Public MustInherit Class C 
    Protected _X As A 
    Public ReadOnly Property X As A 
    Get 
     Return _X 
    End Get 
    End Property 
End Class 

Public Class D 
    Inherits C 
    Private _X As B 
    Public ReadOnly Property X As B 
    Get 
     Return _X 
    End Get 
    End Property 
    Sub New 
    _X = New B 
    End Sub 
End Class 

Gibt es einen Modifikator ich auf Eigenschaft X in der Klasse D verwenden kann, die X von einem als B von einer Instanz von D und A wurde zurück verursacht Instanz von D, die als C bewertet wird?

heißt

Dim d As New D 
Response.Write((d.X Is Nothing) & "<br>") 
Dim c As C = d 
Response.Write(c.X Is Nothing) 

In beiden Fällen I X will nicht Nichts

Mir ist klar sein, ich D ändern könnte wie folgt aussehen:

Public Class D 
    Inherits C 
    Private __X As B 
    Public ReadOnly Property X As B 
    Get 
     Return __X 
    End Get 
    End Property 
    Sub New 
    __X = New B 
    _X = __X 
    End Sub 
End Class 

Gibt es eine saubere Lösung?

+0

ich es mir selbst nicht versucht haben, aber ich glaube, wenn Sie diesen Code tatsächlich kompilieren Sie gesagt werde 'Shadows' angeben oder Sie brauchen 'C' des 'X' auf' Overridable ändern '. Ich habe nicht überprüft, aber ich _think_ 'Shadows' wird tun, was Sie wollen. –

+0

Sie haben Recht mit dem Compiler - es heißt 'Overloads' zu verwenden, aber es ist auch mit' Shadows' zufrieden. Leider löst keiner das Problem. – ic3b3rg

Antwort

0

Sie sollten neuen Code vermeiden Shadows verwenden, aber wenn Sie wirklich dieses Konstrukt brauchen, erhalte ich die Ergebnisse, die Sie nur mit dem Zusatz von MyBase._X=_X-D ‚s erwartet New (Option 1), die auch getan werden könnte, durch ein New in C, dass ruft, dann tut die umgekehrte Zuordnung (Option 2).

Natürlich eine weitere Option, je nach Ihrer tatsächlichen Absicht ist es, die Private _X As B in D fallen zu lassen und werfen Sie einfach die _X zu B in Ihrem X beschattet. (Option 3)

Hier ist mein Code mit Optionen 1 und 2 kommentiert und zur Zeit der Durchführung Option 3.

Public MustInherit Class C 
    Protected _X As A 
    ''Option 2: 
    'Protected Sub New(X As A) 
    ' _X = X 
    'End Sub 
    Public Overridable ReadOnly Property X As A 
     Get 
      Return _X 
     End Get 
    End Property 
End Class 

Public Class D 
    Inherits C 
    'Commented out for option 3: 
    'Private Shadows _X As B 
    Public Shadows ReadOnly Property X As B 
     Get 
      'Commented out for option 3: 
      'Return _X 
      Return DirectCast(_X, B) 
     End Get 
    End Property 
    Sub New() 
     ''Option 1,3: (Comment out for option 2) 
     _X = New B 
     ''Option 1: 
     'MyBase._X = _X 
     ''Option 2: 
     'MyBase.New(New B) 
     '_X = DirectCast(MyBase._X, B) 
    End Sub 
End Class 
+0

Ich habe nicht alle Optionen getestet, aber ich denke, nur Option 2 wird funktionieren. Wenn ich ein B als ein A speichern und es dann zu einem B umwandeln würde, würde ich im Prinzip alle B-Eigenschaften verlieren. Option 2 ist sauberer als das, was ich mir ausgedacht habe - danke! – ic3b3rg

+0

@ ic3b3rg Sie sagen "Wenn ich ein' B' als 'A' speichere und es dann in ein' B' umforme, würde ich alle 'B' Eigenschaften verlieren": Es ist nur eine Besetzung, das Objekt ist es immer noch wirklich ein 'B'; seine Eigenschaften sind immer noch da. Es ist nur eine Eigenschaft von 'Shadows' (und' Overrides', wenn verfügbar), und was Ihre Hauptfrage war, erlaubt Variationen in dem, was Sie durch die 'A' Klasse zu einem' B' Objekt sehen. –