Est-il possible de marquer une méthode surchargée comme finale ?

Question

En C#, est-il possible de marquer une méthode virtuelle surchargée comme finale afin que les implémenteurs ne puissent pas la surcharger ? Comment faire ?

Un exemple peut faciliter la compréhension :

class A
{
   abstract void DoAction();
}
class B : A
{
   override void DoAction()
   {
       // Implements action in a way that it doesn't make
       // sense for children to override, e.g. by setting private state
       // later operations depend on  
   }
}
class C: B
{
   // This would be a bug
   override void DoAction() { }
}

Existe-t-il un moyen de modifier B afin d'empêcher d'autres enfants C de surcharger DoAction, que ce soit à la compilation ou à l'exécution ?

Answer 1

Oui, avec "scellé" :

class A
{
   abstract void DoAction();
}
class B : A
{
   sealed override void DoAction()
   {
       // Implements action in a way that it doesn't make
       // sense for children to override, e.g. by setting private state
       // later operations depend on  
   }
}
class C: B
{
   override void DoAction() { } // will not compile
}

Answer 2

Vous pouvez marquer la méthode comme sealed .

http://msdn.microsoft.com/en-us/library/aa645769(VS.71).aspx

class A
{
   public virtual void F() { }
}
class B : A
{
   public sealed override void F() { }
}
class C : B
{
   public override void F() { } // Compilation error - 'C.F()': cannot override 
                                // inherited member 'B.F()' because it is sealed
}

Answer 3

Vous avez besoin de "scellé".

Answer 4

Les méthodes individuelles peuvent être marquées comme scellées, ce qui équivaut en gros à marquer une méthode comme finale en Java. Ainsi, dans votre exemple, vous auriez :

class B : A
{
  override sealed void DoAction()
  {
    // implementation
  }
}