Czy mogę wziąć pierwsze n elementów z wyliczenia, a następnie użyć reszty wyliczenia?

Question

Załóżmy, że mam IEnumerable<T> i chcę wziąć pierwszy element i przekazać pozostałe elementy do innego kodu. Mogę uzyskać pierwsze elementy z wykorzystaniem , używając Take(n), ale jak mogę uzyskać dostęp do pozostałych elementów bez powodowania ponownego uruchomienia wyliczenia?

Załóżmy na przykład, że mam metodę ReadRecords, która akceptuje rekordy w pliku CSV jako IEnumerable<string>. Załóżmy teraz, że w tej metodzie chcę odczytać pierwszy rekord (nagłówki), a następnie przekazać pozostałe rekordy do metody ReadDataRecords, która również zajmuje IEnumerable<string>. Tak:

void ReadCsv(IEnumerable<string> records) 
{ 
    var headerRecord = records.Take(1); 
    var dataRecords = ??? 

    ReadDataRecords(dataRecords); 
} 

void ReadDataRecords(IEnumerable<string> records) 
{ 
    // ... 
} 

Gdybym był gotów ponownie rozpocząć wyliczanie, wtedy będę mógł używać dataRecords = records.Skip(1). Nie chcę jednak ponownie go uruchamiać - w rzeczywistości może on nie zostać ponownie uruchomiony.

Czy istnieje sposób na pobranie pierwszych rekordów, a następnie pozostałych rekordów (innych niż poprzez odczyt wszystkich wartości do nowej kolekcji i ponowne ich wyliczenie)?

Answer 1

To jest ciekawe pytanie, myślę, że można użyć obejście takiego, zamiast korzystania LINQ uzyskać wyliczający i używać go:

private void ReadCsv(IEnumerable<string> records) 
{ 
    var enumerator = records.GetEnumerator(); 
    enumerator.MoveNext(); 
    var headerRecord = enumerator.Current; 
    var dataRecords = GetRemainingRecords(enumerator); 
} 

public IEnumerable<string> GetRemainingRecords(IEnumerator<string> enumerator) 
{ 
    while (enumerator.MoveNext()) 
    { 
     if (enumerator.Current != null) 
      yield return enumerator.Current; 
    } 
} 

Aktualizacja: Zgodnie z Twojego komentarza tutaj jest bardziej rozszerzona sposób to zrobić:

public static class CustomEnumerator 
{ 
    private static int _counter = 0; 
    private static IEnumerator enumerator; 
    public static IEnumerable<T> GetRecords<T>(this IEnumerable<T> source) 
    { 
     if (enumerator == null) enumerator = source.GetEnumerator(); 

     if (_counter == 0) 
     { 
      enumerator.MoveNext(); 
      _counter++; 
      yield return (T)enumerator.Current; 
     } 
     else 
     { 
      while (enumerator.MoveNext()) 
      { 
       yield return (T)enumerator.Current; 
      } 
      _counter = 0; 
      enumerator = null; 
     } 
    } 
} 

Zastosowanie:

private static void ReadCsv(IEnumerable<string> records) 
{ 
    var headerRecord = records.GetRecords(); 
    var dataRecords = records.GetRecords(); 
} 

Answer 2

Tak, użyj IEnumerator z IEnumerable i możesz zachować pozycję poprzez wywołania metod;

Prosty przykład;

public class Program 
{ 
    static void Main(string[] args) 
    { 
     int[] arr = new [] {1, 2, 3}; 
     IEnumerator enumerator = arr.GetEnumerator(); 
     enumerator.MoveNext(); 
     Console.WriteLine(enumerator.Current); 
     DoRest(enumerator); 
    } 

    static void DoRest(IEnumerator enumerator) 
    { 
     while (enumerator.MoveNext()) 
      Console.WriteLine(enumerator.Current); 
    } 
}