It’s 2021, and you’re still confused about the `IEnumerator` and `IEnumerable` interfaces?

[[375509]]

This article is reprinted from the WeChat public account "Full Stack Coder Portrait", the author is Xiaomajia. Please contact the Full Stack Coder Portrait public account for reprinting this article.

The two interface words IEnumerator and IEnumerable are similar and have related meanings, and it is difficult to distinguish them.

After many years in the industry, I have never systematically sorted out this pair of Li Kui and Li Gui.

Recently, I have been arguing with the article "Actually, LRU is just so-so" by the God of Why. Solution 1 uses an array to implement LRU. The handwritten algorithm involves this pair of interfaces. I will take this opportunity to cover this pair of difficult enemies.

IEnumerator

The IEnumerator and IEnumerable interfaces have similar names and are often used together, but they have different purposes.

The IEnumerator interface provides a way to iterate over a collection within a class. IEnumerator requires you to implement three methods:

1. MoveNext method: This method increases the collection index by 1 and returns a bool value indicating whether the end of the collection has been reached.
2. Reset Method: It resets the collection index to its initial value -1, which invalidates the enumerator.
3. Current method: Returns the current object at position

IEnumerable

The IEnumerable interface provides support for foreach iteration. IEnumerable requires you to implement the GetEnumerator method.

 public IEnumerator GetEnumerator()
 {
 return (IEnumerator)this;
 }

Which interface should I use?

Based on the above words alone, it is difficult to distinguish the usage scenarios of the two interfaces.

The IEnumerator interface defines how to iterate over collection-type objects in a class.

The IEnumerable interface allows enumeration using a foreach loop.

Therefore, the GetEnumerator method of the IEnumerable interface returns an IEnumerator interface. To implement IEnumerable, you must also implement IEnumerator.

From the English root:

The IEnumerator interface represents an enumerator, which defines the enumeration method and is a noun.

The IEnumerable interface represents that the object has the property of being enumerable and is an adjective.

In short, if you want to provide support for foreach, then make the object enumerable first, and then talk about the enumeration method, that is, implement these two interfaces.

Best Practices

• Implement IEnumerator in a nested class so you can create multiple enumerators.
• Provides exception handling for the IEnumerator's Current method.

Why do this?

If the contents of the collection change, the reset method will be called, and then the current enumerator will be invalid, and you will receive an IndexOutOfRangeException (other situations may also cause this exception). So a Try...Catch block is executed to catch this exception and throw an InvalidOperationException, indicating that modifying the collection content is not allowed while iterating.

"This is also the reason why we often get an InvalidOperationException when trying to modify the iterated object in foreach.

The following uses the car list as an example to implement the IEnumerator IEnumerable interface

 using System;
 using System.Collections;
 namespace ConsoleEnum
 {
 public class cars : IEnumerable
 {
        private car[] carlist; 
   
        // Create internal array in constructor.
 public cars()
 {
            carlist= new car[6]
 {
                new car( "Ford" ,1992),
                new car( "Fiat" ,1988),
                new car( "Buick" ,1932),
                new car( "Ford" ,1932),
                new car( "Dodge" ,1999),
                new car( "Honda" ,1977)
 };
 }
        //private enumerator class
        private class MyEnumerator:IEnumerator
 {
 public car[] carlist;
 int position = -1; 
 
 //constructor
 public MyEnumerator(car[] list)
 {
 carlist=list;
 }
            private IEnumerator getEnumerator()
 {
 return (IEnumerator)this;
 }
 //IEnumerator
 public bool MoveNext()
 {
 position++;
 return (position < carlist.Length);
 }
 //IEnumerator
 public void Reset()
 {
                position = -1;
 }
 //IEnumerator
 public object Current  
 {
 get
 {
 try
 {
 return carlist[position];
 }
                    catch (IndexOutOfRangeException)
 {
                        throw new InvalidOperationException();
 }
 }
 }
        } // end nested class
 public IEnumerator GetEnumerator()
 {
 return new MyEnumerator(carlist);
 }
 }
 }

When foreach cars, you can clearly see

• The foreach syntax sugar first encounters the enumerable cars. It actually accesses the GetEnumerator() method implemented by cars to get the iterator
• Foreach each iteration actually accesses the Current property of the iterator