C# 배열(Array)과 IEnumerator 완전 이해하기

1. 먼저 큰 그림: IEnumerable & IEnumerator란 무엇인가

1-1. IEnumerable / IEnumerable<T>

IEnumerable는 "열거할 수 있는 것"을 의미하는 인터페이스이다
가장 중요한 멤버는 GetEnumerator() 메서드이다

// 비제네릭
public interface IEnumerable
{
    IEnumerator GetEnumerator();
}

// 제네릭
public interface IEnumerable<out T> : IEnumerable
{
    IEnumerator<T> GetEnumerator();
}
  

즉 어떤 타입이든 IEnumerable 또는 IEnumerable<T>를 구현하고 있으면 foreach로 돌릴 수 있다는 의미이다

1-2. IEnumerator / IEnumerator<T>

IEnumerator는 "현재 위치를 기억하면서 한 칸씩 이동하는 열거자"를 의미하는 인터페이스이다
핵심 멤버는 다음과 같다

// 비제네릭
public interface IEnumerator
{
    bool MoveNext();    // 다음 요소로 이동, 이동 성공 여부 반환
    object Current { get; } // 현재 요소
    void Reset();       // 처음 위치로 리셋 (요즘은 잘 안씀)
}

// 제네릭
public interface IEnumerator<out T> : IDisposable, IEnumerator
{
    new T Current { get; }
}
  

정리하면 다음과 같다

• IEnumerable = 열거자를 만들어주는 쪽이다
• IEnumerator = 실제로 한 칸씩 움직이며 데이터에 접근하는 객체이다

2. 배열(Array)은 IEnumerable를 구현하고 있다

C#의 모든 1차원 배열은 다음 인터페이스들을 구현하고 있다

• IEnumerable
• IEnumerable<T>
• ICollection, IList 등도 구현하지만 여기서는 생략한다

예를 들어 int[] 배열이 있다고 하면, 이 배열은 IEnumerable<int>이다

int[] numbers = { 10, 20, 30 };

// 명시적으로 캐스팅 가능
IEnumerable enumerable = numbers;
IEnumerable<int> genericEnumerable = numbers;

// 물론 foreach는 바로 사용 가능
foreach (var n in numbers)
{
    Console.WriteLine(n);
}
  

즉 배열도 "foreach가 가능한 컬렉션"이라는 점에서는 List와 완전히 동일한 개념이다
단, 구현 방식은 조금 다르며, 배열은 CLR 레벨에서 특별 취급되는 타입이라는 점이 다를 뿐이다

3. foreach가 배열에서 실제로 하는 일 (컴파일 후 모습)

3-1. foreach의 표면적인 코드

int[] numbers = { 1, 2, 3, 4, 5 };

foreach (int n in numbers)
{
    Console.WriteLine(n);
}
  

이 코드는 우리가 익숙하게 쓰는 형태이다
하지만 컴파일러는 이 코드를 다음과 비슷한 형태로 변환한다

3-2. 비슷한 형태로 풀어 쓴 코드

int[] numbers = { 1, 2, 3, 4, 5 };

// 1. GetEnumerator 호출
IEnumerator<int> enumerator = ((IEnumerable<int>)numbers).GetEnumerator();

try
{
    // 2. MoveNext로 한 칸씩 이동
    while (enumerator.MoveNext())
    {
        // 3. Current로 현재 요소 읽기
        int n = enumerator.Current;
        Console.WriteLine(n);
    }
}
finally
{
    // 4. IDisposable이면 Dispose 호출
    if (enumerator is IDisposable d)
    {
        d.Dispose();
    }
}
  

실제 실제로는 JIT 최적화 때문에 배열의 경우 이런 형태로 최적화된 for 루프로 바뀌는 경우도 많지만, foreach의 개념 상으로 보면 위 패턴을 따르고 있다고 이해하면 된다

4. 배열에서 IEnumerator 직접 사용해보기

4-1. 비제네릭 IEnumerator 사용

int[] numbers = { 10, 20, 30 };

IEnumerator enumerator = numbers.GetEnumerator();

while (enumerator.MoveNext())
{
    // Current는 object 타입이라 캐스팅 필요
    int value = (int)enumerator.Current;
    Console.WriteLine(value);
}
  

여기서 numbers.GetEnumerator()는 비제네릭 IEnumerator를 반환한다
그래서 Currentobject(int) 캐스팅이 필요하다

4-2. 제네릭 IEnumerator<T>로 다루기

int[] numbers = { 10, 20, 30 };

// IEnumerable<int>로 캐스팅해서 제네릭 열거자 얻기
IEnumerable<int> seq = numbers;
IEnumerator<int> enumerator = seq.GetEnumerator();

while (enumerator.MoveNext())
{
    int value = enumerator.Current; // 캐스팅 불필요
    Console.WriteLine(value);
}

enumerator.Dispose(); // using 또는 try-finally로 감싸는 것이 정석이다
  

제네릭 버전을 쓰면 Currentint

int[] numbers = { 1, 2, 3, 4, 5 };
foreach (int n in numbers)

{

// 작업

}

int[] numbers = { 1, 2, 3, 4, 5 };
for (int i = 0; i < numbers.Length; i++)

{

int n = numbers[i];

// 작업

}

public class IntCollection : IEnumerable<int>
{
    private int[] _items;

    public IntCollection(int[] items)
    {
        _items = items;
    }

    // IEnumerable<int> 구현
    public IEnumerator<int> GetEnumerator()
    {
        // 배열의 열거자를 그대로 반환해도 되고
        // yield return으로 커스텀 열거자를 만들어도 된다
        foreach (var item in _items)
        {
            yield return item;
        }
    }

    // IEnumerable (비제네릭) 구현
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator(); // 제네릭 버전 재사용
    }
}

// 사용 예
var collection = new IntCollection(new[] { 1, 2, 3 });

foreach (var n in collection)
{
    Console.WriteLine(n);
}
  

int[] numbers = { 1, 2, 3 };
var e = ((IEnumerable<int>)numbers).GetEnumerator();

// MoveNext 호출 없이 Current 접근 (잘못된 코드)
int value = e.Current; // 정의되지 않은 동작, InvalidOperationException 가능
  

IEnumerable<int> seq = new List<int> { 1, 2, 3 };

using (var e = seq.GetEnumerator())
{
    while (e.MoveNext())
    {
        int value = e.Current;
        Console.WriteLine(value);
    }
}