Posted on by Shekh Ali

IEnumerable Interface in C# with examples

In this article, We will discuss how to implement an IEnumerable interface in C# with multiple examples along with code implementation.

What is an IEnumerable interface in C#?

In C#, the IEnumerable interface is considered as the base interface for all the non-generic collections that can be enumerated by using the foreach statement.

IEnumerable in C# is available in System.Collections namespace. It contains a single method called GetEnumerator which returns IEnumerator Interface.
The returned IEnumerator interface provides the ability to iterate or loop through the collection by exposing the Current property and MoveNext() and Reset() methods.

Syntax Of IEnumerable Interface C#

// Namespace: System.Collections
public interface IEnumerable

Key Points about IEnumerable in C#

    • IEnumerable is an interface available in System.Collections namespace.
    • IEnumerable exposes an enumerator, which supports a simple iteration over a non-generic collection using foreach statement in C#.
    • IEnumerator interface provides the ability for non-generic collections to loop through the collection by exposing the Current property and MoveNext() and Reset() methods.
    • We can use IEnumerable when we need read-only access to the collection.
    • IEnumerable can be used to iterate when the records are already loaded into the memory.
    • We can use both IEnumerable and IEnumerator interfaces in case we want to iterates over the custom collection class in C#.
    • An IEnumerable interface can be used with the Linq query expression.
    • IEnumerable is best suitable for working with in-memory collections like Array, List, stack, queue, Dictionary, etc.
    • IEnumerable is not suitable for pagination as it read the collection in forward-only mode.
    • IEnumerable doesn’t support lazy loading.
    • An IEnumerable interface does not support custom query.
image IEnumerable in C#
IEnumerable in C#

MoveNext() and Reset() Methods of IEnumerator Interface In C#

IEnumerator.MoveNext

public bool MoveNext ();
 MoveNext()  method of IEnumerator interface returns true if the enumerator was successfully advanced to the next element of the collection. It returns false if the enumerator has passed the end of the collection.

IEnumerator.Reset

public void Reset ();
 Reset()  Method of IEnumerator interface is used to Sets the enumerator to its initial position, which is before the first element in the collection.

If any kind of alteration or changes is made to the collection, such as adding, modifying, or deleting elements, the behavior of Reset is undefined.

InvalidOperationException can be throw if the collection was modified after the enumerator was created.

IEnumerator.Current Property Of IEnumerator Interface

public object Current { get; }

The  Current  property of the IEnumerator interface is used to Gets the element in the collection at the current position of the enumerator.

C# IEnumerable – Example #1

Let’s understand the IEnumerable interface using the following example.
In the following code snippet, we will store a range of integer variables using the IEnumerable interface, then we will print the numbers greater than 5.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace IEnumerableInterfaceDemo
{
    class Program
    {
        static void Main()
        {
            IEnumerable<int> Items = from values in Enumerable.Range(1, 10)
                                      where values > 5 select values;
            foreach (int item in Items)
            {
                Console.WriteLine(item);
            }
            Console.ReadLine();

        }
    }   
}
// Output:
// 6
// 7
// 8
// 9
// 10

C# Implement IEnumerable for custom collection – Example #2

Let’s implement IEnumerable and IEnumerator interface to support iteration over the custom collection.
Following is the code snippet for a custom collection.

using System;
using System.Collections;
namespace IEnumerableInterfaceDemo
{   //Author: Shekh Ali

    // EmployeeInfo class is a business object.
    public class EmployeeInfo
    {
        public int Id { get; set; }
        public string firstName { get; set; }
        public string lastName { get; set; }
        public EmployeeInfo(int id, string firstName, string lastName)
        {
            this.Id = id;
            this.firstName = firstName;
            this.lastName = lastName;
        }

    }

    // This class implements IEnumerable so that it can be used
    // with Foreach loop.
    public class CustomEmployeeCollection : IEnumerable
    {
        public EmployeeInfo[] empInfo;
        public CustomEmployeeCollection(EmployeeInfo[] empArray)
        {
            empInfo = new EmployeeInfo[empArray.Length];
            for (int index = 0; index < empArray.Length; index++)
            {
                empInfo[index] = empArray[index];
            }
        }

        // Implementation for the GetEnumerator method.
        IEnumerator IEnumerable.GetEnumerator()
        {
            return (IEnumerator)GetEnumerator();
        }
        public EmployeeEnumerator GetEnumerator()
        {
            return new EmployeeEnumerator(empInfo);
        }
    }

    public class EmployeeEnumerator : IEnumerator
    {

        int currentPosition = -1;
        public EmployeeInfo[] empInfo;
        public EmployeeEnumerator(EmployeeInfo[] empInfo)
        {
            this.empInfo = empInfo;
        }
       
        
        public bool MoveNext()
        {
            currentPosition++;

            if (currentPosition < empInfo.Length)
            {
                return true;
            }

            return false;
        }    
        object IEnumerator.Current => Current;
        public EmployeeInfo Current => empInfo[currentPosition];
        void IEnumerator.Reset() => currentPosition = 0;
        
    }

    class Program
    {
        static void Main()
        {
            EmployeeInfo[] employeeInfo = new EmployeeInfo[3]
           {
                new EmployeeInfo(101, "Shekh", "Ali"),
                new EmployeeInfo(102, "Denni", "Thomas"),
                new EmployeeInfo(103, "Mark", "Adams")
           };

            CustomEmployeeCollection customEmployeeCollection = new 
            CustomEmployeeCollection(employeeInfo);
            Console.WriteLine($"ID      FirstName   LastName");
            foreach (var employee in customEmployeeCollection)
            {
           Console.WriteLine($"{employee.Id}      {employee.firstName}      {employee.lastName} ");
            }
            Console.ReadLine();

        }
    }
}
CustomCollection using IEnumerable Interface
The output of the above program.

Conclusion:

In this article, we discussed how to implement the IEnumerable and IEnumerator interface with multiple examples.
Also, we learn how to iterate over a custom collection using IEnumerable and IEnumerator interface.

I hope you liked this post, if you have any questions, please post your question in the comment section.

Thanks for visiting 🙂

Recommended Articles

    1. 10 Difference between interface and abstract class In C#
    2. Exception Handling in C#| Use of try, catch and finally block
    3. C# Enum | How To Play With Enum in C#?
    4. C# extension methods with examples
    5. Properties In C# with examples
    6. Generic Delegates in C# With Examples
    7. Constructors in C# with Examples
    8. How to host your .net application to AWS EC2 Windows Server for free?

Leave a Reply