Puis-je remplacer une propriété en c #? Comment?

Question

J'ai cette classe de base:

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

Et le descendant suivant:

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

Lorsque je compile, j'obtiens l'avertissement suivant: la définition de x classe Derived va masquer la version de Base de celui-ci. Est-il possible de remplacer des propriétés dans des méthodes similaires à c #?

Answer 1

Vous devez utiliser les mots clés virtual

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

ou définir une méthode abstraite:

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

et utilisez override mot clé en tant qu'enfant:

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

Si vous n'allez PAS remplacer, vous pouvez utiliser le mot clé new de la méthode pour masquer la définition du parent.

Answer 2

Faites en sorte que la propriété de base soit abstraite et remplacez ou utilisez le nouveau mot-clé dans la classe dérivée.

 abstract class Base
{
  public abstract int x { get; }
}

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

Ou

 abstract class Base
{
  public int x { get; }
}

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

Answer 3

Changer la propriété de la signature comme indiqué ci-dessous:

Classe de Base

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

La classe dérivée

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

Si vous n'avez pas besoin d'aucune mise en œuvre dans la classe de Base suffit d'utiliser résumé de la propriété.

Base:

public abstract int x { get; }

Dérivés:

public override int x { ... }

Je vous suggère d'utiliser abstract propriété plutôt que de trhowing NotImplemented exception dans les getter, abstact modificateur de force toutes les classes dérivées pour mettre en œuvre cette propriété de sorte que vous aurez au moment de la compilation solution sûre.

Answer 4

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

Answer 5

 abstract class Base
{

  public virtual int x
  {
    get { throw new NotImplementedException(); }
  }
}
 

ou

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

Dans les deux cas, vous devez écrire dans la classe dérivée

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

La différence entre les deux est que, avec abstract, vous forcez la classe dérivée à implémenter quelque chose, et avec virtaul, vous pouvez fournir un comportement par défaut que le dérivateur peut utiliser tel quel ou modifier.