Зачем реализовывать IEnumerable (T), если я могу просто определить один GetEnumerator?

обновление: я ценю все комментарии, которые, по существу, состоит единодушной оппозиции. Хотя каждое высказанное возражение было обоснованным, я чувствую, что последний гвоздь в гробу был Ани, что, в конечном счете, даже один незначительныйсобственные шаблонный код.

так что да, считайте меня убежденным: это была бы плохая идея.

прежде чем вы отвергнете этот вопрос как абсурдный, я прошу Вас рассмотреть следующий:

1. IEnumerable<T> наследует от* IEnumerable, что означает, что любой тип, реализующий IEnumerable<T> вообще должен реализовать и IEnumerable<T>.GetEnumerator и (явно) IEnumerable.GetEnumerator. Это в основном сводится к шаблонному коду.
2. вы можете foreach над любым типом, который имеет GetEnumerator метод, если этот метод возвращает объект некоторого типа с MoveNext способ и Current собственность. Поэтому, если ваш тип определяет один метод с подписью public IEnumerator<T> GetEnumerator(), законно перечислять его с помощью foreach.
3. очевидно, что существует много кода, который требует IEnumerable<T> interface -- например, в основном все методы расширения LINQ. К счастью, перейти от типа, который вы можете foreach на IEnumerable<T> тривиально, используя автоматическую генерацию итератора, которую C# поставляет через yield ключевое слово.

Итак, собирая все это вместе, у меня было это сумасшедшая идея: что, если я просто определю свой собственный интерфейс, который выглядит так:

public interface IForEachable<T>
{
    IEnumerator<T> GetEnumerator();
}

затем всякий раз, когда я определяю тип, который я хочу быть перечисляемым, я реализую этой интерфейс вместо IEnumerable<T>, устраняя необходимость реализации двух GetEnumerator методы (явных). Например:

class NaturalNumbers : IForEachable<int>
{
   public IEnumerator<int> GetEnumerator()
   {
       int i = 1;
       while (i < int.MaxValue)
       {
           yield return (i++);
       }
   }

   // Notice how I don't have to define a method like
   // IEnumerator IEnumerable.GetEnumerator().
}

наконец-то, чтобы сделать этот тип совместимым с кодом, который тут ждать IEnumerable<T> интерфейс, I можно просто определить метод расширения, чтобы перейти от любого IForEachable<T> до IEnumerable<T> вот так:

public static class ForEachableExtensions
{
    public static IEnumerable<T> AsEnumerable<T>(this IForEachable<T> source)
    {
        foreach (T item in source)
        {
            yield return item;
        }
    }
}

мне кажется, что это позволяет мне разрабатывать типы, которые можно использовать во всех отношениях как реализации IEnumerable<T>, но без этого досадного явные IEnumerable.GetEnumerator реализация в каждом из них.

например:

var numbers = new NaturalNumbers();

// I can foreach myself...
foreach (int x in numbers)
{
    if (x > 100)
        break;

    if (x % 2 != 0)
        continue;

    Console.WriteLine(x);
}

// Or I can treat this object as an IEnumerable<T> implementation
// if I want to...
var evenNumbers = from x in numbers.AsEnumerable()
                  where x % 2 == 0
                  select x;

foreach (int x in evenNumbers.TakeWhile(i => i <= 100))
{
    Console.WriteLine(x);
}

что вы думаете об этой идее? Я упускаю какую-то причину, почему это было бы ошибкой?

я понимаю это, вероятно кажется, слишком сложное решение того, что не так уж важно для начала (я сомневаюсь, что кто-нибудь действительно заботится о том, чтобы явно определить IEnumerable интерфейс); но он просто выскочил в моей голове, и я не вижу никаких очевидных проблем, которые этот подход будет представлять.

в общем, если я могу написать умеренное количество кода после чтобы избавить себя от необходимости писать небольшое количество кода много раз для меня это дорогого стоит.

_{*это правильная терминология для использования? Я всегда не решаюсь сказать, что один интерфейс "наследует" от другого, поскольку это, похоже, не правильно отражает отношения между ними. Но, может быть, это правильно.}