How do `IEnumerable` and `IEnumerator` enable efficient iteration in C#?

In-depth understanding of IEnumerable and IEnumerator in C#: a powerful tool for efficient iteration

In software development, efficient iteration of object collections is crucial. The .NET framework provides two key interfaces for this: IEnumerable and IEnumerator.

IEnumerableInterface

IEnumerableThe interface represents a collection of objects. It defines a single method GetEnumerator() that returns a IEnumerator object. Any class that allows iteration of its elements can implement this interface.

IEnumeratorInterface

The

IEnumerator interface represents an enumerator, which is an object that can be used to iterate over a collection of objects. It defines two methods: MoveNext() and Current(). MoveNext() Advances the enumerator to the next element in the collection and returns a Boolean value indicating whether the iterator has reached the end of the collection. Current()Returns the current element in the collection.

Usage of IEnumerable and foreach statements

IEnumerable is usually used in conjunction with the foreach statement in C#. The foreach statement provides a concise and convenient way to iterate over a collection of objects. The compiler automatically calls the collection object's GetEnumerator() method and uses the resulting IEnumerator object to iterate over its elements.

Why use IEnumerable and IEnumerator?

Efficiency: IEnumerable and IEnumerator allow efficient iteration by avoiding loading the entire collection into memory. They provide a mechanism to access the elements of a collection one by one, thereby reducing memory overhead and improving performance.

Extensibility: IEnumerable and IEnumerator are standard interfaces and any class can implement them. This allows developers to create custom classes that can be easily iterated on in a consistent manner regardless of their internal implementation.

Example usage

Consider the following example:

<code class="language-csharp">using System;
using System.Collections.Generic;

public class MyCollection : IEnumerable<int>
{
    private List<int> _data = new List<int>();

    public IEnumerator<int> GetEnumerator()
    {
        foreach (int item in _data)
        {
            yield return item;
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    public void Add(int value)
    {
        _data.Add(value);
    }
}

public class Example
{
    public static void Main(string[] args)
    {
        MyCollection myCollection = new MyCollection();
        myCollection.Add(1);
        myCollection.Add(2);
        myCollection.Add(3);

        foreach (int item in myCollection)
        {
            Console.WriteLine(item);
        }
    }
}</code>

In this example, the MyCollection class implements IEnumerable<int> and defines a custom enumerator to iterate over its elements. The foreach statement is then able to iterate over the collection and print the elements to the console.

The above is the detailed content of How do `IEnumerable` and `IEnumerator` enable efficient iteration in C#?. For more information, please follow other related articles on the PHP Chinese website!