59. foreach를 사용할 수 있는 일반화 클래스

foreach를 사용할 수 있는 클래스를 만드는 데 필요한 것은...

IEnumerable 인터페이스를 상속해서 클래스를 만드는 것이다.

 

 

일반화 클래스도 IEnumerable 인터페이스를 상속하면 일단은 foreach를 통해 순회할 수 있지만,

요소를 순회할 때마다 형식 변환을 수행하는 오버로드각 발생한다는 문제점이 있다.

(기껏 일반화를 통해 형식 변환을 제거했더니 foreach 구문에서 형식 변환을 일으켜 성능을 저하시킨다니...)

 

System.Collections.Generic 네임스페이스에 이 문제를 풀 수 있는 열쇠가 있다.

IEnumerable의 일반화 버전인 IEnumerable<T> 인터페이스가 바로 그것이다.

이 인터페이스를 상속하면 형식 변환으로 인한 성능 저하가 없으면서도

foreach 순회가 가능한 클래스를 작성할 수 있다.

 

다음은 IEnumerable<T> 인터페이스의 메소드이다.

메소드	설명
IEnumerator GetEnumerator()	IEnumerator 형식의 객체를 반환(IEnumerable로부터 상속받은 메소드)
IEnumerator<T> GetEnumerator()	IEnumerator<T> 형식의 객체를 반환

 

 

<예제>

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

namespace EnumerableGeneric
{
    class MainApp
    {
        class MyList<T> : IEnumerable<T>, IEnumerator<T>
        {
            private T[] array;
            int position = -1;

            public MyList()
            {
                array = new T[3];
            }

            public T this[int index]
            {
                get { return array[index]; }
                set
                {
                    if (index >= array.Length)
                    {
                        Array.Resize<T>(ref array, index + 1);
                        Console.WriteLine($"Array Resized : {array.Length}");
                    }
                    array[index] = value;
                }
            }
            public int Length
            {
                get { return array.Length; }
            }

            public IEnumerator<T> GetEnumerator()
            {
                return this;
            }
            IEnumerator IEnumerable.GetEnumerator()
            {
                return this;
            }
            public T Current
            {
                get { return array[position]; }
            }
            object IEnumerator.Current
            {
                get { return array[position]; }
            }
            public bool MoveNext()
            {
                if(position==array.Length-1)
                {
                    Reset();
                    return false;
                }
                position++;
                return (position<array.Length);
            }
            public void Reset()
            {
                position = -1;
            }
            public void Dispose()
            {

            }
        }

        static void Main(string[] args)
        {
            MyList<string> strList = new MyList<string>();
            strList[0] = "abc";
            strList[1] = "def";
            strList[2] = "ghi";
            strList[3] = "jkl";
            strList[4] = "mno";

            foreach (var s in strList) Console.WriteLine(s);

            Console.WriteLine();
            MyList<int> intList = new MyList<int>();
            intList[0] = 0;
            intList[1] = 1;
            intList[2] = 2;
            intList[3] = 3;
            intList[4] = 4;

            foreach (var i in intList) Console.WriteLine(i);

            Console.WriteLine();

        }
    }
}

<예제 출력>

Array Resized : 4
Array Resized : 5
abc
def
ghi
jkl
mno

Array Resized : 4
Array Resized : 5
0
1
2
3
4