Comment implémenter une interface qui nécessite des noms de membre en double?

Question

Je dois souvent implémenter certaines interfaces telles que IEnumerable<T> dans mon code.

A chaque fois, la mise en œuvre automatiquement, je rencontre ce qui suit:

public IEnumerator<T> GetEnumerator() { 
    // Code here... 
} 

public IEnumerator GetEnumerator1() { 
    // Code here... 
} 

Bien que je dois mettre en œuvre les deux GetEnumerator() méthodes, ils impossiblement peuvent avoir le même nom, même si nous comprenons qu'ils font la même chose, en quelque sorte. Le compilateur ne peut pas les traiter comme l'un étant la surcharge de l'autre, car seul le type de retour diffère. Dans ce cas, je parviens à définir l'accesseur GetEnumerator1() sur private. De cette façon, le compilateur ne se plaint pas de ne pas implémenter le membre d'interface, et je jette simplement un NotImplementedException dans le corps de la méthode.

Cependant, je me demande si c'est une bonne pratique, ou si je vais procéder différemment, comme peut-être un alias de méthode ou quelque chose comme ça.

Quelle est la meilleure approche en mettant en œuvre une interface telle que IEnumerable<T> qui nécessite la mise en œuvre de deux méthodes différentes avec le même nom?

EDIT # 1

Est-ce que VB.NET réagit différemment de C# en mettant en œuvre des interfaces, car en VB.NET il est explicitement mis en œuvre, forçant ainsi le GetEnumerator1(). Voici le code:

Public Function GetEnumerator() As System.Collections.Generic.IEnumerator(Of T) Implements System.Collections.Generic.IEnumerable(Of T).GetEnumerator 
    // Code here... 
End Function 

Public Function GetEnumerator1() As System.Collections.Generic.IEnumerator Implements System.Collections.Generic.IEnumerable.GetEnumerator 
    // Code here... 
End Function 

Les deux méthodes GetEnumerator() sont explicitement mises en œuvre, et la compilation leur refuser d'avoir le même nom. Pourquoi?

Answer 1

En Visual Basic, toutes les implémentations d'interface sont explicites.

Les mappages d'interface sont définis par l'instruction Implements afin que vous puissiez nommer vos méthodes d'implémentation de l'interface comme vous le souhaitez. (Contrairement à C#, où le compilateur déduit quelles méthodes implémentent les interfaces en faisant correspondre leurs noms et leurs signatures.)

La modification du nom et de la visibilité de la méthode (selon le cas) est une pratique standard dans VB. Voir Implementing Interfaces in VB.NET pour un bon aperçu.

Answer 2

Vous pouvez utiliser explicit interface implementation:

IEnumerator IEnumerable.GetEnumerator() 
{ 
    return GetEnumerator(); 
} 

public IEnumerator<T> GetEnumerator() 
{ 
    ... 
} 

Answer 3

Vous devriez pouvoir utiliser Explicit Interface Implementations pour créer les deux méthodes qui ont la même signature. En fonction de ce que vous énumérez, je passerais simplement ces appels à un IEnumerable<T> interne comme une liste ou un tableau.

Answer 4

La mise en œuvre de l'interface non générique permet explicitement aux deux méthodes d'avoir le même nom, et permet à la version non générique d'être implémentée en termes génériques. Le long de:

public class TestEnumerable : IEnumerable<int> 
{ 
    public IEnumerator<int> GetEnumerator() 
    { 
     // Type-safe implementation here. 
    } 

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() 
    { 
     return GetEnumerator(); 
    } 
}