Можно ли написать несколько итераторов для типа на С#?

Просто сделайте так, чтобы CoolCollection<T> явно реализовывал IEnumerable<CoolNode<T>>, а также IEnumerable<T>. (Я предполагаю, что это действительно CoolNode<T>, но если нет, просто уберите лишние <T> везде.)

Это позволит вам повторять оба способа, хотя вам понадобится приведение.

Для этого вам понадобится что-то вроде:

class CoolCollection<T> : ICollection<T>, IEnumerable<CoolNode<T>>
{
    IEnumerator<CoolNode<T>> IEnumerable<CoolNode<T>>.GetEnumerator()
    {
        ///...Do work here...
    }

    IEnumerator<T> GetEnumerator()
    {
        ///...Do work here...
    }
}

Использование этого будет выглядеть так:

foreach (T item in coolCollection)
{
    ...
}


foreach (CoolNode<T> node in (IEnumerable<CoolNode<T>>)coolCollection)
{
    ...
}

Другим вариантом было бы открыть свойство для «узлов», чтобы вы могли сделать:

foreach(var nodes in coolCollection.Nodes)
{ ... }

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

class CoolCollection<T> : ICollection<T>
{
    private List<CoolNode<T>> nodes;

    IEnumerable<CoolNode<T>> Nodes
    {
        get 
        {
             foreach(var node in this.nodes) { yield return node; }
        }
    }
}

Если я правильно понял вопрос...

Вы можете сделать это аналогично тому, как это делают некоторые другие объекты коллекции:

Например:

foreach (int key in IDictionary.Keys)
{

}

foreach (object value in IDictionary.Values)
{

}

Но я не думаю, что есть способ сделать именно так, как вы написали...

Нет, ты не можешь этого сделать. Вы не можете перегружать свой итератор по умолчанию.

Представьте, если бы вы могли перегрузить свой итератор по умолчанию.

Что бы это сделало? foreach (object o in foo) не было бы логического способа выбрать правильный итератор.

Что вы можете сделать, так это иметь второй метод с именем ForEach2, который перебирает вашу коллекцию другим способом. Или вы можете явно реализовать интерфейс. Или вы можете использовать композицию Linq для такого рода вещей.

С точки зрения дизайна класса:

interface IBar {
   IEnumerator<string> GetEnumerator();
}

class Foo : IBar, IEnumerable<int> {

    // Very bad, risky code. Enumerator implementations, should 
    // line up in your class design. 
    public IEnumerator<int> GetEnumerator()
    {
        yield return 1;
        yield return 2;
        yield return 3;
        yield return 4;
    }

    IEnumerator<string> IBar.GetEnumerator()
    {
        yield return "hello";
    }

    // must be IEnumerable if you want to support foreach 
    public IEnumerable<string> AnotherIterator
    { 
        get {
           yield return "hello2";
        }
    }


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

}

Расширения LINQ для EachPair

struct Pair<T> { 
    public T First;
    public T Second;
}

static class LinqExtension {
    public static IEnumerable<Pair<T>> EachPair<T>(this IEnumerable<T> input) {
        T first = default(T);
        bool gotFirst = false;
        foreach (var item in input)
        {
            if (!gotFirst)
            {
                first = item;
                gotFirst = true;
            }
            else {
                yield return new Pair<T>() { First = first, Second = item };
                gotFirst = false;
            }
        } 
    }
}

Тестовый код:

class Program
{
    static void Main(string[] args)
    {
        var foo = new Foo(); 

        foreach (int number in foo)
        {
            Console.WriteLine(number);
        }

        // LINQ composition - a good trick where you want
        //  another way to iterate through the same data 
        foreach (var pair in foo.EachPair())
        {
            Console.WriteLine("got pair {0} {1}", pair.First, pair.Second);
        }

        // This is a bad and dangerous practice. 
        // All default enumerators should be the same, otherwise
        // people will get confused.
        foreach (string str in (IBar)foo)
        {
            Console.WriteLine(str);
        }

        // Another possible way, which can be used to iterate through
        //   a portion of your collection eg. Dictionary.Keys 
        foreach (string str in foo.AnotherIterator)
        {
            Console.WriteLine(str);
        }
    }

Если CoolCollection реализует IEnumerable, вы можете написать:

foreach (var item in coolCollection)
{
    ...
}

или если T является CoolNode

foreach (CoolNode node in coolCollection)
{
    ...
}

Если вам нужно каким-то образом преобразовать каждый элемент в свой тип, вы можете использовать оператор Linq Select:

foreach (CoolNode node in coolCollection.Select(item => ConvertToNode(item))
{
    ...
}

Взгляните на фрагмент iterindex. В своем классе введите iterindex и нажмите [TAB]. Это поможет вам реализовать шаблон «Именованный итератор и индексатор».

Результат можно использовать следующим образом:

foreach (var e in myTree.DepthFirstView) // supports iteration
{
    if (e == myTree.DepthFirstView[2]) // supports indexing
    {
        // ...
    }
}

(Я написал этот фрагмент, но подозреваю, что он так и не был использован с пользой. Никогда.)