Override ReadOnly proprietà in una sottoclasse per renderlo lettura / scrittura (VB.NET o C #)

Question

Questa non sembra possibile in VB.NET con proprietà dal momento che la dichiarazione immobiliare devono descrivere se è ReadOnly oppure no.

Nel mio esempio qui di seguito, non fatemi fare la compilazione ReadWriteChild. Credo che avrei potuto fare il genitore di lettura / scrittura, e quindi avere setter del ReadOnlyChild non fare nulla, ma che sembra una sorta di hacky. L'alternativa migliore sembra essere l'abbandono immobili a favore dei metodi getter / setter in questo caso.

Public MustInherit Class Parent

    Public MustOverride ReadOnly Property Foo() As String

End Class

Public Class ReadOnlyChild
    Inherits Parent

    Public Overrides ReadOnly Property Foo() As String
        Get
            ' Get the Property
        End Get
    End Property

End Class

Public Class ReadWriteChild
    Inherits Parent

    Public Overrides Property Foo() As String
        Get
            ' Get the property.
        End Get
        Set(ByVal value As String)
           ' Set the property.
        End Set
    End Property

End Class

Answer 1

Dato quello che stai cercando di realizzare, e con il codice di esempio che hai postato, VB.NET non ti consente di fare questo.

In genere, è possibile dichiarare una proprietà in VB.NET in questo modo:

Public Class qwqwqw
  Public Property xyz() As String
      Get
          Return ""
      End Get
      Private Set(ByVal value As String)
          '
      End Set
  End Property
End Class

marcatura Fondamentalmente la struttura generale come pubblico, ma dando una portata più restrittiva al setter (o getter).

Il problema principale nel tuo caso è la MustInherit (cioè astratto) classe di base. Dal momento che la proprietà si sta definendo in là è contrassegnato come MustOverride, non è possibile fornire un'implementazione di default (cioè, troppo, è astratta), e questo include il "Get" e "Set" contorni, di conseguenza, a seconda di quale "nel complesso "scope si dà a questa dichiarazione di proprietà astratta, VB.NET vi costringerà a utilizzare questo spazio per sia i getter e setter all'interno classi derivate.

Avere la qualificazione ReadOnly sulla proprietà della classe base, costringerà tutte le classi derivate e le implementazioni di questa proprietà di essere anche ReadOnly. Lasciando fuori il qualificatore ReadOnly ancora non funziona, dal momento che qualunque ambito si dà alla proprietà astratta sarà il campo di applicazione è necessario applicare sia ai setter e getter all'interno di implementazioni derivate.

Ad esempio:

Public MustInherit Class Parent
  Public MustOverride Property Foo() As String
End Class

Public Class ReadOnlyChild
  Inherits Parent

  Public Overrides Property Foo() As String
    Get
        '
    End Get
    Private Set(ByVal value As String)
        '
    End Set
  End Property
End Class

(Si noti la scoping privato sul setter). Questo non funzionerà come VB.NET è insistendo sul fatto che dato che si sta ignorando la proprietà classi di base, tutta la tua proprietà deve avere la stessa portata della proprietà che stai sovrascrivendo (in questo caso, pubblico).

Il tentativo di rendere proprietà astratta della classe base protetta non funzionerà neanche, dal momento che si sarebbe poi richiesto di implementare la proprietà allo stesso livello di scoping come è dichiarato nella classe base (cioè protetti). Di solito, quando non sovrascrivendo definizione astratta di una classe base con un livello di scoping specifico, è possibile dare un getter o setter un più livello di scoping restrittivo, ma non si può dare un meno livello di scoping restrittiva.

Quindi:

Public MustInherit Class Parent
  Protected MustOverride Property Foo() As String       
End Class

Public Class ReadOnlyChild
  Inherits Parent

  Protected Overrides Property Foo() As String
      Public Get
          '
      End Get
      Set(ByVal value As String)
          '
      End Set
  End Property
End Class

(Si noti la scoping pubblico sul getter). Non funziona nemmeno a causa della portata del pubblico meno restrittiva di quella della portata complessiva di proprietà di protezione, e per di più, non dello stesso livello di scoping come definito sulla dichiarazione di proprietà astratta della classe base.

Se il disegno delle classi è come si parla nella sua domanda, io personalmente, vorrei andare con un getter "java-style" e setter Metodi in quanto possono quindi essere dichiarati separatamente con la propria scoping livelli.

Answer 2

Potrebbe essere un longshot ... dato che la mia conoscenza di VB.NET è minimo ...

In C # è possibile specificare la visibilità di una funzione di accesso di proprietà indipendente della proprietà:

public virtual string Name
{
    get { ... }
    protected set { ... }
}

In questo esempio, classi figlie possono accedere al settor, ma altre classi non possono.

Si noti inoltre che le sostituzioni possono avere una maggiore visibilità di quello che hanno la priorità - in modo da poter fare questo:

public overide string Name
{
    get { ... }
    public set { ... }
}

Puoi fare qualcosa di simile in VB.NET?

Answer 3

Confermare che MrEdmuno è corretta in quanto è possibile utilizzare ombra. Tuttavia sembra non è possibile ombra direttamente qualcosa che è contrassegnata MustInherit, quindi è necessario per ereditare in una classe (Parent 2) ... poi nella vostra sola lettura (in realtà a pensarci probabilmente non c'è bisogno di utilizzare le ombre, se si ereditare in una classe)

Credo che il mio commento questione si ferma, perché stai avendo bisogno di fare questo? Se essi sono le proprie classi sareste meglio modificare quelle, o implementare come interfaccia?

Public MustInherit Class Parent

    Public MustOverride ReadOnly Property Foo() As String

End Class

Public Class ReadOnlyChild
    Inherits Parent

    Public Overrides ReadOnly Property Foo() As String
        Get
            'Get the Property
            Return "Return"
        End Get
    End Property

End Class

Public Class Parent2
    Inherits Parent

    Public Overrides ReadOnly Property Foo() As String
        Get
            Return "Return 2"
        End Get
    End Property
End Class

Public Class ReadWriteChild
    Inherits Parent2

    Public Shadows Property Foo() As String
        Get
            '// Get the property.
            Return "2"
        End Get
        Set(ByVal value As String)
            '** Set something
        End Set
    End Property

Answer 4

Purtroppo non ho Visual Studio qui quindi non posso confermare.

Hai guardato con ombre, questo è effettivamente lo stesso che dire "nuovo" in C # dichiarazione di proprietà.

Answer 5

Non cercare di sostituire la proprietà in quanto non è virtuale. Sovrascrivere i metodi OnReadOnlyChanged e gestire il vostro business là. Buona fortuna

Answer 6

Per far fronte a ciò che Bevan ha suggerito, in VB.NET è possibile dichiarare una proprietà come avere un getter pubblico e un setter protetto, come segue:

Private _ExpectedTotalRoyalties As Decimal

Public Property ExpectedTotalRoyalties() As Decimal
    Get
        Return _ExpectedTotalRoyalties
    End Get
    Protected Set(ByVal value As Decimal)
        If Not _ExpectedTotalRoyalties.Equals(value) Then
            _ExpectedTotalRoyalties = value
            SendPropertyChanged("ExpectedTotalRoyalties")
        End If
    End Set
End Property

Answer 7

È necessario aggiungere un altro livello di gerarchia; purtroppo, l'unico modo per davvero le cose correttamente portata è quello di utilizzare le classi nidificate:

Public Class IntermediateClassForPrivateInheritanceOnly
  Inherits Parent
  Public Overrides ReadOnly Property Foo() As String
  ' etc.
  Private Sub New(whatever)
    MyBase.New(whatever)
  End Sub

  ' Most other stuff for the class goes here.

  Public Class ReadWriteChild
    Inherits IntermediateClassForPrivateInheritanceOnly
    Shadows Property Foo()
    ' etc.
    Public Sub New(whatever)
      MyBase.New(whatever)
    End Sub
  End Class
End Class

Public Class ReadWriteChild  ' Would use an alias, if such things existed
  Inherits IntermediateClassForPrivateInheritanceOnly
  Public Sub New(whatever)
    MyBase.New(whatever)
  End Sub
End Class