Qual è lo scopo di nascondere (usando il "nuovo" modificatore) una dichiarazione del metodo di interfaccia?

Question

è possibile contrassegnare una dichiarazione di metodo in un'interfaccia come "new" ma ha un senso "tecnico" o è solo un modo per dichiarare esplicitamente che la dichiarazione non può sovrascrivere quella precedente?

Ad esempio:

interface II1 
{ 
    new void F(); 
} 

interface II2 : II1 
{ 
    new void F(); 
} 

è valido (il compilatore C# 4.0 non si lamenta), ma non sembra essere diverso da:

interface II1 
{ 
    void F(); 
} 

interface II2 : II1 
{ 
    void F(); 
} 

Grazie in anticipo per qualsiasi informazione.

MODIFICA: sai uno scenario in cui nascondere in un'interfaccia sarebbe utile?

EDIT: Secondo questo link: Is method hiding ever a good idea (grazie Scott), lo scenario più comune sembra essere l'emulazione di tipo restituito covariante.

Answer 1

Il secondo esempio emette il seguente avviso del compilatore:

'II2.F()' nasconde ereditato membro 'II1.F()'. Utilizzare la nuova parola chiave se era inteso il nascondimento .

Direi che la differenza nell'utilizzo della parola chiave new è esattamente questa: mostrare l'intenzione.

Answer 2

I due sono molto diversi. Usando 'nuovo' stai creando una nuova catena di ereditarietà. Ciò significa che qualsiasi implementazione di II2 dovrà realizzare entrambe le versioni di F() e quella effettiva che si finisce per chiamare dipenderà dal tipo di riferimento.

considerare i seguenti tre realizzazioni:

class A1 : II1 
    { 
     public void F() 
     { 
      // realizes II1.F() 
     } 
    } 

    class A2 : II2 
    { 
     void II1.F() 
     { 
      // realizes II1.F() 
     } 

     void II2.F() 
     { 
      // realizes II2.F() 
     } 
    } 

    class A3 : II2 
    { 
     public void F() 
     { 
      // realizes II1.F() 
     } 

     void II2.F() 
     { 
      // realizes II2.F() 
     } 
    } 

Se si dispone di un riferimento a A2, non sarà in grado di chiamare entrambe le versioni di F() senza prima casting per II1 o II2.

A2 a2 = new A2(); 
a2.F(); // invalid as both are explicitly implemented 
((II1) a2).F(); // calls the II1 implementation 
((II2) a2).F(); // calls the II2 implementation 

Se si dispone di un riferimento a A3, si sarà in grado di chiamare direttamente la versione II1 in quanto è un implentation implicita:

A3 a3 = new A3(); 
a3.F(); // calls the II1 implementation 
((II2) a3).F(); // calls the II2 implementation 

Answer 3

So di un buon uso per questo: voi avere per fare ciò per dichiarare un'interfaccia COM derivata da un'altra interfaccia COM. È toccato in questo magazine article.

Fwiw, l'autore identifica erroneamente la fonte del problema, non ha nulla a che fare con una "tassa di successione". COM semplicemente sfrutta il modo in cui un tipico compilatore C++ implementa l'ereditarietà multipla. C'è una tabella v per ogni classe base, solo ciò di cui COM ha bisogno. Il CLR non lo fa, non supporta l'MI e c'è sempre un solo v-table. I metodi di interfaccia sono uniti nella v-table della classe base.

Answer 4

Il nuovo modificatore è molto semplice, sopprime solo l'avviso del compilatore che viene creato quando un metodo è nascosto. Se utilizzato su un metodo che non nasconde un altro metodo, viene generato un avviso.

Da The C# Language Specification 3.0

10.3.4 Il nuovo modificatore di Una classe-membro-dichiarazione è permesso di dichiarare un membro con lo stesso nome o la firma come membro ereditato. Quando ciò accade, si dice che il membro della classe derivata nasconda il membro della classe base. Nascondere un membro ereditato non è considerato un errore, ma fa sì che il compilatore emetta un avviso. Per sopprimere l'avviso, la dichiarazione del membro della classe derivata può includere un nuovo modificatore per indicare che il membro derivato è destinato a nascondere il membro di base. Questo argomento è discusso ulteriormente in §3.7.1.2. Se un nuovo modificatore è incluso in una dichiarazione che non nasconde un membro ereditato, viene emesso un avviso a tale effetto. Questo avvertimento è soppresso rimuovendo il nuovo modificatore.

Answer 5

Un esempio che segue la risposta di Fredrik. Voglio avere un'interfaccia che rappresenti un metodo per ottenere un'entità tramite id. Quindi desidero sia un servizio WCF che un altro repository standard in grado di essere utilizzato come tale interfaccia. Per giocare con WCF, ho bisogno di decorare la mia interfaccia con gli attributi. Da un punto di vista intenzionale, non voglio decorare la mia interfaccia con le cose WCF quando non verrà utilizzata solo con WCF, quindi ho bisogno di usarne di nuove. Ecco il codice:

public class Dog 
{ 
    public int Id { get; set; } 
} 

public interface IGetById<TEntity> 
{ 
    TEntity GetById(int id); 
} 

public interface IDogRepository : IGetById<Dog> { } 

public class DogRepository : IDogRepository 
{ 
    public Dog GetById(int id) 
    { 
     throw new NotImplementedException(); 
    } 
} 

[ServiceContract] 
public interface IWcfService : IGetById<Dog> 
{ 
    [OperationContract(Name="GetDogById")] 
    new Dog GetById(int id); 
} 

Answer 6

Lo uso quasi in ogni mia interfaccia. Guarda qui:

interface ICreature 
{ 
    /// <summary> 
    ///  Creature's age 
    /// </summary> 
    /// <returns> 
    ///  From 0 to int.Max 
    /// </returns> 
    int GetAge(); 
} 

interface IHuman : ICreature 
{ 
    /// <summary> 
    ///  Human's age 
    /// </summary> 
    /// <returns> 
    ///  From 0 to 999 
    /// </returns> 
    new int GetAge(); 
} 

È assolutamente normale avere un membro ereditato con requisiti minori ma obblighi maggiori. LSP non è violato. Ma se sì, dove documentare il nuovo contratto?