{"id":927,"date":"2023-03-13T16:20:14","date_gmt":"2023-03-13T09:20:14","guid":{"rendered":"https:\/\/csharptutorial.net\/?page_id=927"},"modified":"2023-06-26T14:49:07","modified_gmt":"2023-06-26T07:49:07","slug":"csharp-ienumerable","status":"publish","type":"page","link":"https:\/\/www.csharptutorial.net\/csharp-linq\/csharp-ienumerable\/","title":{"rendered":"C# IEnumerable"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn about C# IEnumerable<T><\/code> interface which is the key to LINQ.<\/p>\n\n\n\n

Introduction to the C# IEnumerable<T> interface<\/h2>\n\n\n\n

The IEnumerable<T><\/code> is an interface that represents a sequence<\/strong> of objects that can be enumerated.<\/p>\n\n\n\n

The IEnumerable<T><\/code> has a single method GetEnumerator()<\/code> that returns an IEnumerator<T><\/code> which can be used to iterate through a sequence of objects.<\/p>\n\n\n\n

The IEnumerator<T><\/code> interface has the following important members:<\/p>\n\n\n\n

    \n
  • Current<\/code> – returns the current element in the sequence.<\/li>\n\n\n\n
  • MoveNext()<\/code> – moves the iterator to the next element in the sequence.<\/li>\n<\/ul>\n\n\n\n

    The following example defines a method Square()<\/code> that accepts an integer argument called max<\/code> and returns a sequence of square numbers of numbers from 0 to max<\/code>:<\/p>\n\n\n

    using<\/span> static<\/span> System.Console;\n\nIEnumerable<int<\/span>> Square<\/span>(int<\/span> max<\/span>)<\/span>\n{\n    var<\/span> results = new<\/span> List<int<\/span>>();\n    for<\/span> (int<\/span> i = 0<\/span>; i < max; i++)\n    {\n        results.Add(i * i);\n    }\n    return<\/span> results;\n}\n\n\nforeach<\/span> (var<\/span> n in<\/span> Square<\/span>(5<\/span><\/span>))<\/span>\n{\n    WriteLine(n);\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    Output:<\/p>\n\n\n
    0<\/span>\n1<\/span>\n4<\/span>\n9<\/span>\n16<\/span><\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this example, the Square()<\/code> method adds the square numbers of all the numbers from 0<\/code> to max<\/code> to a collection List<int><\/code>.<\/p>\n\n\n\n
    In case you want to construct a big list of square numbers, the implementation of the Square()<\/code> method is not memory optimized<\/strong> because it creates a huge list of square numbers in the memory upfront.<\/p>\n\n\n\n
    It would be better if the Square()<\/code> method returns a square number at a time based on the caller’s request.<\/p>\n\n\n\n
    The following Square()<\/code> method uses the yield<\/code> keyword to create a sequence of square numbers one at a time as requested by the caller:<\/p>\n\n\n
    using<\/span> static<\/span> System.Console;\n\nIEnumerable<int<\/span>> Square<\/span>(int<\/span> max<\/span>)<\/span>\n{\n    for<\/span> (int<\/span> i = 0<\/span>; i < max; i++)\n    {\n        yield<\/span> return<\/span> i * i;\n    }\n}\n\nvar<\/span> squares = Square(5<\/span>);\n\nforeach<\/span> (var<\/span> n in<\/span> squares)\n{\n    WriteLine(n);\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this example, the Square()<\/code> method will not be executed until its result (squares) is enumerated. One way to enumerate the sequence is to use it in a foreach<\/code> loop.<\/p>\n\n\n\n
    So the following line doesn’t execute the Square()<\/code> method immediately:<\/p>\n\n\n
    var<\/span> squares = Square(5<\/span>);<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    Instead, it’ll wait until the squares sequence is enumerated. This is called a lazy evaluation<\/em>.<\/p>\n\n\n\n
    When the foreach<\/code> loop statement enumerates the element of the squares<\/code> sequence, the Square()<\/code> method is executed that yields a square number one at a time in each iteration:<\/p>\n\n\n
    foreach<\/span> (var<\/span> n in<\/span> squares)\n{\n    WriteLine(n);\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    IEnumerable<T> and LINQ<\/h2>\n\n\n\n
    LINQ queries rely heavily on lazy evaluation. In LINQ, lazy evaluation is often referred to as deferred query execution<\/em> or deferred query evaluation<\/em>.<\/p>\n\n\n\n
    Deferred query evaluation is important because it allows you to define a query at one point and use it later, exactly when you want to, as many times as needed. For example:<\/p>\n\n\n
    using<\/span> static<\/span> System.Console;\n\nvar<\/span> numbers = new<\/span> List<int<\/span>> { 1<\/span>, 5<\/span>, 2<\/span>, 8<\/span>, 9<\/span> };\n\nvar<\/span> oddNumbers = numbers\n                    .Where(number => number % 2<\/span> != 0<\/span>)\n                    .Select(number => number);\n\nforeach<\/span> (var<\/span> number in<\/span> oddNumbers)\n{\n    WriteLine(number);\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this example, the oddNumbers<\/code> variable has the type of IEnumerable<int><\/code>. Due to the deferred query evaluation, the query does not execute until the foreach<\/code> statement.<\/p>\n\n\n\n
    Summary<\/h2>\n\n\n\n
      \n
    • IEnumerable<T><\/code> interface uses lazy evaluation i.e., the sequence is not generated until it is evaluated.<\/li>\n\n\n\n
    • Because of the IEnumerable<T><\/code>, LINQ can work with large sequences of objects without requiring excessive memory.<\/li>\n<\/ul>\n
      \n\t
      \n\t\t
      Was this tutorial helpful ?<\/div>\n\t\t
      \n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t Yes <\/span>\n\t\t\t<\/button>\n\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t No <\/span>\n\t\t\t<\/button>\n\t\t<\/div>\n\t<\/header>\n\n\t
      \n\t\t
      \n\t\t\t
      <\/div>\n\t\t\t\n\t\t\t