IEnumerable<t> Interface (System.Collections.Generic)

Type Parameters

This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics .
Derived
Microsoft.Extensions.Configuration.Memory.MemoryConfigurationProvider
Examples

The following example demonstrates how to implement the IEnumerable<T> interface and how to use that implementation to create a LINQ query. When you implement IEnumerable<T> , you must also implement IEnumerator<T> or, for C# only, you can use the yield keyword. Implementing IEnumerator<T> also requires IDisposable to be implemented, which you will see in this example.

   using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
public class App
    // Exercise the Iterator and show that it's more
    // performant.
    public static void Main()
        TestStreamReaderEnumerable();
        Console.WriteLine("---");
        TestReadingFile();
    public static void TestStreamReaderEnumerable()
        // Check the memory before the iterator is used.
        long memoryBefore = GC.GetTotalMemory(true);
      IEnumerable<String> stringsFound;
        // Open a file with the StreamReaderEnumerable and check for a string.
      try {
         stringsFound =
               from line in new StreamReaderEnumerable(@"c:\temp\tempFile.txt")
               where line.Contains("string to search for")
               select line;
         Console.WriteLine("Found: " + stringsFound.Count());
      catch (FileNotFoundException) {
         Console.WriteLine(@"This example requires a file named C:\temp\tempFile.txt.");
         return;
        // Check the memory after the iterator and output it to the console.
        long memoryAfter = GC.GetTotalMemory(false);
        Console.WriteLine("Memory Used With Iterator = \t"
            + string.Format(((memoryAfter - memoryBefore) / 1000).ToString(), "n") + "kb");
    public static void TestReadingFile()
        long memoryBefore = GC.GetTotalMemory(true);
      StreamReader sr;
      try {
         sr = File.OpenText("c:\\temp\\tempFile.txt");
      catch (FileNotFoundException) {
         Console.WriteLine(@"This example requires a file named C:\temp\tempFile.txt.");
         return;
        // Add the file contents to a generic list of strings.
        List<string> fileContents = new List<string>();
        while (!sr.EndOfStream) {
            fileContents.Add(sr.ReadLine());
        // Check for the string.
        var stringsFound =
            from line in fileContents
            where line.Contains("string to search for")
            select line;
        sr.Close();
        Console.WriteLine("Found: " + stringsFound.Count());
        // Check the memory after when the iterator is not used, and output it to the console.
        long memoryAfter = GC.GetTotalMemory(false);
        Console.WriteLine("Memory Used Without Iterator = \t" +
            string.Format(((memoryAfter - memoryBefore) / 1000).ToString(), "n") + "kb");
// A custom class that implements IEnumerable(T). When you implement IEnumerable(T),
// you must also implement IEnumerable and IEnumerator(T).
public class StreamReaderEnumerable : IEnumerable<string>
    private string _filePath;
    public StreamReaderEnumerable(string filePath)
        _filePath = filePath;
    // Must implement GetEnumerator, which returns a new StreamReaderEnumerator.
    public IEnumerator<string> GetEnumerator()
        return new StreamReaderEnumerator(_filePath);
    // Must also implement IEnumerable.GetEnumerator, but implement as a private method.
    private IEnumerator GetEnumerator1()
        return this.GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator()
        return GetEnumerator1();
// When you implement IEnumerable(T), you must also implement IEnumerator(T),
// which will walk through the contents of the file one line at a time.
// Implementing IEnumerator(T) requires that you implement IEnumerator and IDisposable.
public class StreamReaderEnumerator : IEnumerator<string>
    private StreamReader _sr;
    public StreamReaderEnumerator(string filePath)
        _sr = new StreamReader(filePath);
    private string _current;
    // Implement the IEnumerator(T).Current publicly, but implement
    // IEnumerator.Current, which is also required, privately.
    public string Current
            if (_sr == null || _current == null)
                throw new InvalidOperationException();
            return _current;
    private object Current1
        get { return this.Current; }
    object IEnumerator.Current
        get { return Current1; }
    // Implement MoveNext and Reset, which are required by IEnumerator.
    public bool MoveNext()
        _current = _sr.ReadLine();
        if (_current == null)
            return false;
        return true;
    public void Reset()
        _sr.DiscardBufferedData();
        _sr.BaseStream.Seek(0, SeekOrigin.Begin);
        _current = null;
    // Implement IDisposable, which is also implemented by IEnumerator(T).
    private bool disposedValue = false;
    public void Dispose()
        Dispose(disposing: true);
        GC.SuppressFinalize(this);
    protected virtual void Dispose(bool disposing)
        if (!this.disposedValue)
            if (disposing)
                // Dispose of managed resources.
            _current = null;
            if (_sr != null) {
               _sr.Close();
               _sr.Dispose();
        this.disposedValue = true;
     ~StreamReaderEnumerator()
        Dispose(disposing: false);
// This example displays output similar to the following:
//       Found: 2
//       Memory Used With Iterator =     33kb
//       ---
//       Found: 2
//       Memory Used Without Iterator =  206kb
   
    Imports System.IO
Imports System.Collections
Imports System.Collections.Generic
Imports System.Linq
Public Module App
   ' Excercise the Iterator and show that it's more performant.
   Public Sub Main()
      TestStreamReaderEnumerable()
      Console.WriteLine("---")
      TestReadingFile()
   End Sub
   Public Sub TestStreamReaderEnumerable()
        ' Check the memory before the iterator is used.
        Dim memoryBefore As Long = GC.GetTotalMemory(true)
      Dim stringsFound As IEnumerable(Of String)
        ' Open a file with the StreamReaderEnumerable and check for a string.
         stringsFound =
               from line in new StreamReaderEnumerable("c:\temp\tempFile.txt")
               where line.Contains("string to search for")
               select line
         Console.WriteLine("Found: {0}", stringsFound.Count())
      Catch e As FileNotFoundException
         Console.WriteLine("This example requires a file named C:\temp\tempFile.txt.")
         Return
      End Try
        ' Check the memory after the iterator and output it to the console.
        Dim memoryAfter As Long = GC.GetTotalMemory(false)
        Console.WriteLine("Memory Used with Iterator = {1}{0} kb",
                        (memoryAfter - memoryBefore)\1000, vbTab)
   End Sub
   Public Sub TestReadingFile()
        Dim memoryBefore As Long = GC.GetTotalMemory(true)
      Dim sr As StreamReader
         sr = File.OpenText("c:\temp\tempFile.txt")
      Catch e As FileNotFoundException
         Console.WriteLine("This example requires a file named C:\temp\tempFile.txt.")
         Return
      End Try
        ' Add the file contents to a generic list of strings.
        Dim fileContents As New List(Of String)()
        Do While Not sr.EndOfStream
            fileContents.Add(sr.ReadLine())
        ' Check for the string.
        Dim stringsFound =
            from line in fileContents
            where line.Contains("string to search for")
            select line
      sr.Close()
      Console.WriteLine("Found: {0}", stringsFound.Count())
        ' Check the memory after when the iterator is not used, and output it to the console.
        Dim memoryAfter As Long = GC.GetTotalMemory(False)
        Console.WriteLine("Memory Used without Iterator = {1}{0} kb",
                        (memoryAfter - memoryBefore)\1000, vbTab)
   End Sub
End Module
' A custom class that implements IEnumerable(T). When you implement IEnumerable(T),
' you must also implement IEnumerable and IEnumerator(T).
Public Class StreamReaderEnumerable : Implements IEnumerable(Of String)
    Private _filePath As String
    Public Sub New(filePath As String)
        _filePath = filePath
    End Sub
    ' Must implement GetEnumerator, which returns a new StreamReaderEnumerator.
    Public Function GetEnumerator() As IEnumerator(Of String) _
          Implements IEnumerable(Of String).GetEnumerator
        Return New StreamReaderEnumerator(_filePath)
    End Function
    ' Must also implement IEnumerable.GetEnumerator, but implement as a private method.
    Private Function GetEnumerator1() As IEnumerator _
          Implements IEnumerable.GetEnumerator
        Return Me.GetEnumerator()
    End Function
End Class
' When you implement IEnumerable(T), you must also implement IEnumerator(T),
' which will walk through the contents of the file one line at a time.
' Implementing IEnumerator(T) requires that you implement IEnumerator and IDisposable.
Public Class StreamReaderEnumerator : Implements IEnumerator(Of String)
    Private _sr As StreamReader
    Public Sub New(filePath As String)
        _sr = New StreamReader(filePath)
    End Sub
    Private _current As String
    ' Implement the IEnumerator(T).Current Publicly, but implement
    ' IEnumerator.Current, which is also required, privately.
    Public ReadOnly Property Current As String _
          Implements IEnumerator(Of String).Current
            If _sr Is Nothing OrElse _current Is Nothing
                Throw New InvalidOperationException()
            End If
            Return _current
        End Get
    End Property
    Private ReadOnly Property Current1 As Object _
          Implements IEnumerator.Current
           Return Me.Current
        End Get
    End Property
    ' Implement MoveNext and Reset, which are required by IEnumerator.
    Public Function MoveNext() As Boolean _
          Implements IEnumerator.MoveNext
        _current = _sr.ReadLine()
        if _current Is Nothing Then Return False
        Return True
    End Function
    Public Sub Reset() _
          Implements IEnumerator.Reset
        _sr.DiscardBufferedData()
        _sr.BaseStream.Seek(0, SeekOrigin.Begin)
        _current = Nothing
    End Sub
    ' Implement IDisposable, which is also implemented by IEnumerator(T).
    Private disposedValue As Boolean = False
    Public Sub Dispose() _
          Implements IDisposable.Dispose
        Dispose(disposing:=True)
        GC.SuppressFinalize(Me)
    End Sub
    Protected Overridable Sub Dispose(disposing As Boolean)
        If Not Me.disposedValue Then
            If disposing Then
                ' Dispose of managed resources.
            End If
            _current = Nothing
            If _sr IsNot Nothing Then
               _sr.Close()
               _sr.Dispose()
            End If
        End If
        Me.disposedValue = True
    End Sub
    Protected Overrides Sub Finalize()
        Dispose(disposing:=False)
    End Sub
End Class
' This example displays output similar to the following:
'       Found: 2
'       Memory Used With Iterator =     33kb
'       ---
'       Found: 2
'       Memory Used Without Iterator =  206kb
    
     Remarks
    
    
     
      IEnumerable<T>
     
     is the base interface for collections in the
     
      System.Collections.Generic
     
     namespace such as
     
      List<T>
     
     ,
     
      Dictionary<TKey,TValue>
     
     , and
     
      Stack<T>
     
     and other generic collections such as
     
      ObservableCollection<T>
     
     and
     
      ConcurrentStack<T>
     
     . Collections that implement
     
      IEnumerable<T>
     
     can be enumerated by using the
     
      foreach
     
     statement.
    
    
     For the non-generic version of this interface, see
     
      System.Collections.IEnumerable
     
     .
    
    
     
      IEnumerable<T>
     
     contains a single method that you must implement when implementing this interface;
     
      GetEnumerator
     
     , which returns an
     
      IEnumerator<T>
     
     object. The returned
     
      IEnumerator<T>
     
     provides the ability to iterate through the collection by exposing a
     
      Current
     
     property.
    
    
     Notes to Implementers
    
    
     To remain compatible with methods that iterate non-generic collections,
     
      IEnumerable<T>
     
     implements
     
      IEnumerable
     
     . This allows a generic collection to be passed to a method that expects an
     
      IEnumerable
     
     object.
    
    
     ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>,
 Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>,
 IEqualityComparer<TValue>)
    
    
     Enumerates and transforms a sequence, and produces an immutable dictionary of its contents by using the specified key and value comparers.
    
    
     GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,
TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,
TResult>, IEqualityComparer<TKey>)
    
    
     Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Key values are compared by using a specified comparer, and the elements of each group are projected by using a specified function.
    
    
     GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>,
 Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,
TResult>)
    
    
     Correlates the elements of two sequences based on equality of keys and groups the results. The default equality comparer is used to compare keys.
    
    
     GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>,
 Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,
TResult>, IEqualityComparer<TKey>)
    
    
     Correlates the elements of two sequences based on key equality and groups the results. A specified
     
      IEqualityComparer<T>
     
     is used to compare keys.
    
    
     Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>,
 Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>,
 IEqualityComparer<TKey>)
    
    
     Correlates the elements of two sequences based on matching keys. A specified
     
      IEqualityComparer<T>
     
     is used to compare keys.
    
    
     
      IEnumerator<T>
     
    
    
     
      System.Collections
     
    
    
     
      Walkthrough: Implementing IEnumerable(Of T) in Visual Basic
     
    
    
     
      Iterators (C#)
     
    
    
     
      Iterators (Visual Basic)