Альтернатива IEnumerable.Пропустить(1).Возьмите(1).Одиночный()

Я думаю, вы хотите этого:

    public void sortAlphabet() {
        using (var enu = getAlphabet().GetEnumerator()) {
            while (enu.MoveNext()) {
                switch (enu.Current) {
                    case 'A':
                        enu.MoveNext();
                        _nextChar = enu.Current;
                        break;
                }
            }
        }
    }

Обратите внимание, что это потребляет следующий элемент, именно то, что вы хотите, если я правильно прочитал Ваш вопрос.

Как было указано в другом ответе, существует метод, и у вас есть доступ к нему для всех перечисляемых объектов через интерфейс IEnumerator<T>, возвращаемый вызовом IEnumerable<T>.GetEnumerator(). Однако работа с MoveNext() и Current может ощущаться несколько "низкоуровневой".

Если вы предпочитаете цикл foreach для обработки вашей коллекции getAlphabet(), вы можете написать метод расширения, который возвращает элементы из любого перечисляемого в парах из двух:

public static IEnumerable<T[]> InPairsOfTwo<T>(this IEnumerable<T> enumerable)
{
    if (enumerable.Count() < 2) throw new ArgumentException("...");

    T lastItem = default(T);
    bool isNotFirstIteration = false;

    foreach (T item in enumerable)
    {
        if (isNotFirstIteration)
        {
            yield return new T[] { lastItem, item };
        }
        else
        {
            isNotFirstIteration = true;
        }
        lastItem = item;
    }
}

Вы бы использовали его следующим образом:

foreach (char[] letterPair in getAlphabet().InPairsOfTwo())
{
    char currentLetter = letterPair[0],
         nextLetter    = letterPair[1];        

    Console.WriteLine("#  {0}, {1}", currentLetter, nextLetter);
}

И ты бы ... получим следующий результат:

#  A, B
#  B, C

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

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

enum State
{
    Scan,
    SaveAndExit
};

public void SortAlphabet()
{
    State state = State.Scan; // initialize

    foreach(char c in getAlphabet())
    {
        switch (state):
        {
            case State.Scan:
                if (c == 'A' ||
                    c == 'B')
                    state = State.SaveAndExit;
                break;
            case State.SaveAndExit:
                return (c);
                break;
        }
    }
}

Ваш код будет возвращать 'B' каждый раз, потому что вы вызываете getAlphabet(), который возвращает новый IEnumerable каждый раз.

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

Если вы используете .NET 4.0, то то, что вы пытаетесь достичь, очень просто:

var alphabet = getAlphabet();
var offByOneAlphabet = alphabet.Skip(1);

foreach (var pair in alphabet.Zip(offByOneAlphabet, (a, b) => Tuple.Create(a, b)))
    Console.WriteLine("Letter: {0}, Next: {1}", pair.Item1, pair.Item2);

// prints:
//    Letter: A, Next: B
//    Letter: B, Next: C

Если вы используете что-то меньшее, чем .NET 4.0, его все еще очень легко определить свою собственную функцию Zip и класс кортежа.