Qual è la differenza tra l’override e le nuove parole chiave in C #?

Qual è la differenza tra l’ override e le new parole chiave in C # quando si definiscono i metodi nelle gerarchie di classi?

La pagina seguente riassume molto bene la tua domanda.

Sapere quando utilizzare l’override e le nuove parole chiave

Sommario

Override : quando un metodo di una class base viene sovrascritto in una class derivata, viene utilizzata la versione nella class derivata, anche se il codice chiamante non “sapeva” che l’object era un’istanza della class derivata.

Novità : se si utilizza la nuova parola chiave anziché eseguire l’override, il metodo nella class derivata non sovrascrive il metodo nella class base, ma semplicemente lo nasconde.

Se non si specifica né la nuova né la sovrascrittura, l’output risultante è lo stesso di quello che si è specificato nuovo, ma si otterrà anche un avviso del compilatore (poiché potrebbe non essere consapevole del fatto che si nasconde un metodo nella class base metodo, o in effetti si potrebbe aver voluto sovrascriverlo, e semplicemente dimenticato di includere la parola chiave).

Override : usato con il tipo di metodo virtual / abstract / override nella class base

Novità : quando la class base non ha dichiarato il metodo come virtuale / abstract / override

new ombreggia il metodo con un metodo completamente nuovo (che può avere o meno la stessa firma) invece di sovrascriverlo (nel qual caso il nuovo metodo deve avere la stessa firma), il che significa che il polimorfismo non funzionerà. Ad esempio, hai queste classi:

 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; } } 

Se lo fai:

 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 

Poiché è ansible definire nuove firme di metodo con new , è imansible per il compilatore sapere che l’istanza di A è in realtà un’istanza di B e che il nuovo metodo B deve essere disponibile. new può essere usato quando il metodo, la proprietà, il campo o l’evento dell’object genitore non è dichiarato con virtual , e a causa della mancanza di virtual il compilatore non “cercherà” il metodo ereditato. Con virtual e override , tuttavia, funziona.

Consiglio vivamente di evitare di new ; nella migliore delle ipotesi, è confuso, perché stai definendo un metodo con un nome che potrebbe essere riconosciuto come qualcos’altro, e nel peggiore dei casi può hide errori, introdurre errori apparentemente impossibili e rendere difficile estendere le funzionalità.

Sembra una vecchia domanda, lasciami provare una risposta diversa:

  1. new : come dice il nome, è un nuovo membro della famiglia della gerarchia dell’ereditarietà e questo sarà usato come membro di base per più lungo la catena (se contrassegnato come virtuale).

  2. override : Significa che non accetto l’implementazione dei membri della mia class genitore e farò diversamente.

Considera la seguente gerarchia di classi:

 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"); } } } 

L’output dei codici precedenti deve essere:

 Overrider => Foo Overrider => Foo Hider => Foo Base => Foo 
  • Una sottoclass overrides un metodo virtuale applicando il override modifier :
  • Se si desidera hide un membro deliberatamente, nel qual caso è ansible applicare il new modifier al membro nella sottoclass. The new modifier does nothing more than suppress the compiler warning that would otherwise result

override ti consente di sovrascrivere un metodo virtuale in una class base in modo da poter inserire un’implementazione diversa in. new nasconde un metodo non virtuale in una class base.