Perché il metodo Static nasconde il mio metodo di istanza?

Question

Il seguente codice dovrebbe dare un avvertimento?

class Foo { public void Do() { /*...*/ } /*...*/ } 
class Bar : Foo { public static void Do() { /*...*/ } /*...*/ } 

Dà:

"Attenzione CS0108:.. 'Bar.Do()' nasconde membro ereditato 'Foo.Do()' Utilizzare la nuova parola chiave se si nasconde è stato destinato"

Se faccio una modifica al codice:

class Foo { public static void Do() { /*...*/ } /*...*/ } 
class Bar : Foo { public void Do() { /*...*/ } /*...*/ } 

ottengo lo stesso avvertimento.

Se apporto la seguente modifica, tuttavia, l'avviso scompare.

class Foo { public void Do() { /*...*/ } /*...*/ } 
class Bar : Foo { new public static void Do() { /*...*/ } /*...*/ } 

Permettetemi di fare un ulteriore cambiamento:

class Foo { public void Do() { /*...*/ } /*...*/ } 
class Bar : Foo { 
    new public static void Do() 
    { new Bar().Do();/*...*/ } /*...*/ 
} 

Questo non può essere compilato:

"CS0176 Errore: Gli 'Bar.Do()' non è possibile accedere con un'istanza riferimento, qualificarlo con un nome tipo invece. "

Quindi, perdo l'accesso al metodo ereditato tramite un riferimento di istanza da un metodo statico!

Quale sarebbe la logica dietro? O ho fatto un refuso da qualche parte?

Mi sono imbattuto in questo quando stavo cercando di definire un metodo statico 'Mostra' per il mio modulo derivato da 'Form'.

Answer 1

Dove pensi che sia l'errore? Il fatto che ci sia un avvertimento è assolutamente giusto. Dal spec C# 3.0, sezione 10.3.4:

Una classe-membro-dichiarazione è consentito di dichiarare un membro con lo stesso nome o firma come ereditato membro.Quando si verifica ciò, si dice che il membro di classe derivato nasconda il membro di classe di base. Nascondere un membro ereditato non è considerato un errore, ma fa sì che il compilatore emetta un avviso . Per sopprimere l'avviso, la dichiarazione della classe derivata può includere un nuovo modificatore su indicare che il membro derivato è destinato a nascondere il membro di base.

Il fatto che il metodo di invocazione non è più sottile, ma è fondamentalmente perché l'algoritmo di ricerca membro sceglie il metodo statico, e quindi viene utilizzata questa parte della sezione 7.5.5.1:

validazione finale del il metodo migliore scelto viene eseguita:

il metodo è convalidato nel contesto del gruppo metodo : Se il metodo migliore è un metodo statico , il gruppo metodo deve avere derivava da un nome semplice o da un accesso membro attraverso un tipo. Se il metodo migliore è un metodo di istanza, il gruppo di metodi deve essere il risultato di un nome semplice , un accesso membro tramite una variabile o un valore o un accesso di base. Se nessuno di questi requisiti è true, si verifica un errore in fase di compilazione.

Answer 2

No, questo ha perfettamente senso. Questo funziona come previsto:

using System; 
using System.Collections.Generic; 

class Foo { public void Do() { /*...*/ } /*...*/ } 
class Bar : Foo { 
    new public static void Do() 
    { ((Foo)new Bar()).Do();/*...*/ } /*...*/ 
} 

Questo perché il compilatore presuppone che si dispone di un tipo di bar, e poi trova il membro statico. Lasciandolo su Foo (che viene fornito gratuitamente), lo fai apparire nei metadati di Foo() e tutto va bene.

Answer 3

Prova questo:

 new public static void Do() 
     { 
      ((Foo)new Bar()).Do(); 
     } 

Answer 4

Nel tuo esempio di codice finale, la nuova parola chiave sulla dichiarazione di Bar.Do() significa che si intende nascondere Foo.Do().

Answer 5

Per curiosità, perché vuoi farlo? Sembra che probabilmente stai seguendo la tua soluzione nel modo sbagliato.

Il codice sopra sembra funzionare come dovrebbe e i messaggi del compilatore indicano quali sono i problemi.

Answer 6

si dovrebbe essere in grado di chiamare facendo chiamando base.Do() invece di Bar() Do()