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

Question

J'ai souvent à mettre en œuvre des 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 à la fois GetEnumerator () méthodes, ils peuvent impossiblement 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 étant la surcharge de l'autre, parce que les diffère du type de retour.

Lors de cette opération, je parviens à mettre l'accesseur GetEnumerator1() à private. De cette façon, le compilateur ne plainte de ne pas mettre en œuvre l'élément d'interface, et je simplement jeter un NotImplementedException dans le corps de la méthode.

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

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 de GetEnumerator() sont explicitement mises en œuvre, et la compilation leur refuser d'avoir le même nom. Pourquoi?

Answer 1

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

mappages d'interface sont définies par le Implements déclaration de sorte que vous pouvez nommer vos méthodes de mise en œuvre de l'interface que vous voulez. (Contrairement à C #, où les infère du compilateur quelles méthodes mettre en œuvre des interfaces en faisant correspondre leurs noms et signatures.)

Modification du nom de la méthode et de la visibilité (selon le cas) est une pratique courante dans VB. Voir Interfaces de mise en œuvre en VB.NET pour une bonne vue d'ensemble.

Answer 2

Vous pouvez utiliser implémentation d'interface explicite :

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

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

Answer 3

Vous devriez pouvoir utiliser Implémentations d'interface explicite pour créer les deux méthodes qui ont la même signature. En fonction de ce que vous énumérez, je passe simplement ces appels vers 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 les deux méthodes pour avoir le même nom, et permet la version non générique à mettre en œuvre en termes de générique. Le long des lignes de:

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

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