Qual è il caso d'uso di questa idiosincrasia ereditaria?

Question

Quando ereditare una classe ereditata, il comportamento nuova/esclusione non è quello che ci si aspetterebbe:

$ cat Program.cs 
using System; 

class A { 
    public virtual void SayHi() { 
     Console.WriteLine("From A"); 
    } 
} 
class B : A { 
    public new virtual void SayHi() { 
     Console.WriteLine("From B"); 
    } 
} 
class C : B { 
    public override void SayHi() { 
     Console.WriteLine("From C"); 
    } 
} 

public class Program { 
    public static void Main() { 
     A p = new C(); 
     p.SayHi(); 
    } 
} 

$ ./Program.exe 
From A 

come Classe C ridefinisce il metodo sayHi() mi aspetterei l'uscita di essere From C. Perché il modificatore new della classe B ha la precedenza qui? Qual è il caso d'uso per questo? Soprattutto perché rompe l'ovvio caso d'uso di avere C davvero prioritario A.

Si noti che il codice sopra è stato eseguito su Mono 2.10 in esecuzione su una distro derivata da Debian. Ma ho confermato lo stesso comportamento usando il compilatore C# in MS Visual Studio.

Answer 1

Il new modifier causa l'occultamento del membro, che interrompe la relazione polimorfica nella gerarchia di classi. Il metodo SayHi di B viene considerato come distinto (non un override) da A's (quindi la scelta della parola "nuovo" come parola chiave). Il metodo C sostituisce quindi lo B e non lo A (che rimane nascosto).

Pertanto, quando si chiama SayHi in un'istanza C attraverso un riferimento A, il runtime risolverebbe contro il tipo A, non il tipo C (entro cui SayHi è un metodo “nuovo” ereditato da B).

Se, d'altra parte, si dovesse eseguire:

B p = new C(); 
p.SayHi(); 

... si otterrebbe il risultato polimorfico atteso:

From C 

Edit: Poiché è stata richiesta un caso d'uso ecco uno. Prima dell'introduzione dei generici in .NET Framework 2.0, l'occultamento dei membri veniva talvolta usato come mezzo per alterare i tipi di ritorno dei metodi ereditati nelle classi derivate (cosa che non è possibile fare quando si esegue l'override) per restituire tipi più specifici. Per esempio:

class ObjectContainer 
{ 
    private object item; 

    public object Item 
    { 
     get { return item; } 
     set { item = value; } 
    } 
} 

class StringContainer : ObjectContainer 
{ 
    public new virtual string Item 
    { 
     get { return base.Item as string; } 
     set { base.Item = value as string; } 
    } 
} 

class QuotedStringContainer : StringContainer 
{ 
    public override string Item 
    { 
     get { return "\"" + base.Item + "\""; } 
    } 
} 

La Item proprietà della classe ObjectContainer restituisce una pianura object. Tuttavia, in StringContainer, questa proprietà ereditata è nascosta per restituire invece string. Così:

ObjectContainer oc = new StringContainer(); 
object o = oc.Item; // Valid, since ObjectContainer.Item is resolved 
string s1 = oc.Item; // Not valid, since ObjectContainer.Item is still resolved 
string s2 = ((StringContainer)oc).Item; 
         // Valid, since StringContainer.Item is now resolved 

La classe QuotedStringContainer ignora la proprietà di StringContainer, ereditando il suo tipo di ritorno stringItem; tuttavia, è ancora nascosto dallo object -ritorno a Item proprietà di ObjectContainer. Se non fosse così, non ci sarebbe modo di conciliare i loro tipi restituiti disparati ...

ObjectContainer oc = new QuotedStringContainer(); 
object o = oc.Item; // Valid, since ObjectContainer.Item is resolved 
string s1 = oc.Item; // Not valid, since ObjectContainer.Item is still resolved 
string s2 = ((StringContainer)oc).Item; 
         // Valid, since QuotedStringContainer.Item is now resolved 
         // (polymorphism!) 
string s3 = ((QuotedStringContainer)oc).Item; 
         // Valid, since QuotedStringContainer.Item is now resolved 

Answer 2

C è prevalente la versione shadowed del metodo (che è l'essere shadowed in B) e non sovrascrivendo quello in A .

Come risultato, quando si utilizza una variabile di tipo A, il SayHi definito A è chiamato, come si non viene sovrascritta in C.

Answer 3

C esegue l'override del metodo B, quindi quando lo trasmetti a A, si termina chiamando il virtuale definito in A.

Vedere ECMA 334: C# Language Specification in 17.5.3 è il vostro esempio (pagina 294).

Answer 4

Poiché la classe C non sovrascrive il metodo SayHi nella classe A, sovrascrive il metodo "nuovo" in B. Poiché il cast è su A, il compilatore lo risolve come una chiamata a A.SayHi() piuttosto che C.SayHi()

Answer 5

L'ultimo example da questa pagina di msdn spiega da vicino cosa sta succedendo qui.

Fondamentalmente il nuovo modificatore fa in modo che il metodo in A sia nascosto da C, e poiché è pubblico quando C esegue l'override sovrascrive il metodo da B (che è trattato come un metodo distinto).

Se si imposta il metodo in B a privati, C sarebbe ancora una volta l'override del metodo in A.

class B : A 
{ 
    private new void SayHi() 
    { 
     Console.WriteLine("From B"); 
    } 
} 

risultati in: From C