Posso eseguire l’override di una proprietà in c #? Come?

Ho questa class base:

abstract class Base { public int x { get { throw new NotImplementedException(); } } } 

E il seguente discendente:

 class Derived : Base { public int x { get { //Actual Implementaion } } } 

Quando compilo, ricevo questo avviso dicendo che la definizione di x della class derivata nasconderà la versione di Base di esso. È ansible sovrascrivere le proprietà nei metodi c # like?

Devi usare virtual parola chiave virtual

 abstract class Base { // use virtual keyword public virtual int x { get { throw new NotImplementedException(); } } } 

o definire una proprietà astratta:

 abstract class Base { // use abstract keyword public abstract int x { get; } } 

e utilizzare la parola chiave override quando nel bambino:

 abstract class Derived : Base { // use override keyword public override int x { get { ... } } } 

Se NON si intende sovrascrivere, è ansible utilizzare la new parola chiave sul metodo per hide la definizione del genitore.

 abstract class Derived : Base { // use override keyword public new int x { get { ... } } } 

Rendere astratta la proprietà di base e sovrascrivere o utilizzare la nuova parola chiave nella class derivata.

 abstract class Base { public abstract int x { get; } } class Derived : Base { public override int x { get { //Actual Implementaion } } } 

O

 abstract class Base { public int x { get; } } class Derived : Base { public new int x { get { //Actual Implementaion } } } 

Modifica la firma della proprietà come mostrato di seguito:

Classe base

 public virtual int x { get { /* throw here*/ } } 

Classe derivata

 public override int x { get { /*overriden logic*/ } } 

Se non hai bisogno di alcuna implementazione nella class Base usa solo proprietà astratte.

Base:

 public abstract int x { get; } 

derivato:

 public override int x { ... } 

Ti suggerirei di usare la proprietà abstract piuttosto che trimmare l’eccezione NotImplemented in getter, il modificatore abstact forzerà tutte le classi derivate ad implementare questa proprietà in modo da finire con una soluzione sicura in fase di compilazione.

 abstract class Base { // use abstract keyword public virtual int x { get { throw new NotImplementedException(); } } } 
 abstract class Base { public virtual int x { get { throw new NotImplementedException(); } } } 

o

 abstract class Base { // use abstract keyword public abstract int x { get; } } 

In entrambi i casi devi scrivere nella class derivata

 public override int x { get { your code here... } } 

la differenza tra i due è che con l’astrazione costringi la class derivata a implementare qualcosa, e con virtaul puoi fornire un comportamento predefinito che il deriver può usare così com’è o cambiare.