¿Cuál es la diferencia entre la anulación y las nuevas palabras clave en C#?

Question

¿Cuál es la diferencia entre las palabras clave override y new en C# cuando se definen métodos en jerarquías de clase?

Answer 1

La siguiente página resume muy bien su pregunta.

Knowing When to Use Override and New Keywords

Resumen

Override: Cuando un método de una clase base se reemplaza en una clase derivada, se utiliza la versión en la clase derivada, incluso si el código de llamada didn' t "saber" que el objeto era una instancia de la clase derivada.

Nuevo: Si usa la palabra clave new en lugar de anular, el método en la clase derivada no anula el método en la clase base, simplemente lo oculta.

Si no especifica ni nuevas ni anulaciones, el resultado resultante es el mismo que si especificara nuevo, pero también recibirá una advertencia del compilador (ya que puede no ser consciente de que está ocultando un método en el método de la clase base, o de hecho es posible que haya querido anularlo, y simplemente se olvidó de incluir la palabra clave).

Anulación: se utiliza con el tipo virtual/Abstract/anulación del método en la clase base

Nueva: cuando la clase base no ha declarado método virtual/Abstract/anular

Answer 2

override le permite anulación un método virtual en una clase base para que pueda poner una implementación diferente en. new ocultará un método no virtual en una clase base.

Answer 3

new sombreará el método con un método completamente nuevo (que puede o no tener la misma firma) en lugar de anularlo (en cuyo caso el nuevo método debe tener la misma firma), lo que significa que el polimorfismo no funcionará . Por ejemplo, tienes estas clases:

class A { 
    public virtual int Hello() { 
     return 1; 
    } 
} 

class B : A { 
    new public int Hello(object newParam) { 
     return 2; 
    } 
} 

class C : A { 
    public override int Hello() { 
     return 3; 
    } 
} 

Si hace esto:

A objectA; 
B objectB = new B(); 
C objectC = new C(); 

Console.WriteLine(objectB.Hello(null)); // 2 
Console.WriteLine(objectC.Hello()); // 3 

objectA = objectB; 

Console.WriteLine(objectA.Hello()); // 1 

objectA = objectC; 

Console.WriteLine(objectA.Hello()); // 3 

Ya que se puede definir nuevas firmas de los métodos con new, es imposible que el compilador sabe que la instancia de A es en realidad una instancia de B y el nuevo método B define debería estar disponible. new se puede usar cuando el método, la propiedad, el campo o el evento del objeto primario no se declara con virtual, y debido a la falta de virtual, el compilador no "buscará" el método heredado. Con virtual y override, sin embargo, funciona.

Recomiendo encarecidamente que evite new; en el mejor de los casos, es confuso, porque está definiendo un método con un nombre que podría reconocerse como otra cosa, y en el peor, puede ocultar errores, introducir errores aparentemente imposibles y dificultar la ampliación de la funcionalidad.

Answer 4

se parece a una vieja pregunta, vamos a tratar una respuesta diferente:

1. new: como su nombre lo dice, es un nuevo miembro en la familia de jerarquía de herencia y esto va a ser utilizado como elemento de base para más abajo en la cadena (si está marcado como virtual).

2. override: Significa que no acepto la implementación de miembros de mi clase primaria y lo haré de manera diferente.

Answer 5

Consideremos el siguiente jerarquía de clases:

using System; 

namespace ConsoleApp 
{  
    public static class Program 
    { 
      public static void Main(string[] args) 
      {  
       Overrider overrider = new Overrider(); 
       Base base1 = overrider; 
       overrider.Foo(); 
       base1.Foo(); 

       Hider hider = new Hider(); 
       Base base2 = hider; 
       hider.Foo(); 
       base2.Foo(); 
      } 
    } 

    public class Base 
    { 
     public virtual void Foo() 
     { 
      Console.WriteLine("Base  => Foo"); 
     } 
    } 

    public class Overrider : Base 
    { 
     public override void Foo() 
     { 
      Console.WriteLine("Overrider => Foo"); 
     } 
    } 

    public class Hider : Base 
    { 
     public new void Foo() 
     { 
      Console.WriteLine("Hider  => Foo"); 
     } 
    } 
}  

salida de códigos anteriores debe ser:

Overrider => Foo 
Overrider => Foo 

Hider  => Foo 
Base  => Foo 

• Una subclase overrides un método virtual mediante la aplicación de la override modifier:
• Si desea hide un miembro deliberadamente, en cuyo caso puede aplicar el new modifier al miembro en la subclase. The new modifier does nothing more than suppress the compiler warning that would otherwise result