25. 제네릭스(Generics)

• 제네릭스(Generics) : int, float, double 등과 같은 데이터 타입을 확정하지 않고, 이 데이터 타입 자체를 타입 파라미터(Type Parameter)로 받아들이도록 하는 기능
  • 제네릭스(Generics)라고 하면 일반화라고 흔히 알려져있다.

Generic 메소드 선언 방식

     접근제한자 반환형식 메소드 이름 <형식 매개 변수> (매개변수) 
    {
        ...
    }

Ex)

void CopyData(int a, int b) 
    {
        b = a; b에 a를 복사
    }

    void CopyData(string a, string b)
    {
        b = a; b에 문자열 a를 복사
    }

    ... 다른 타입에 대한 CopyData 메소드들...

• 위의 방식은 데이터 형식에 따라서 여러 개의 메소드가 필요하다. 비효율적인 방법

• 위의 방식을 Generic 메소드로 변환하면

Ex) 
    void CopyData<T>(T a, T b) // 여기서 T는 Type을 뜻함
    {
        b = a; 
    }

위와 같은 코드가 되며 이와같이 다른 타입들에 대해서도 간단하게 선언할 수 있다.

Generics 사용예제

namespace GenericsEx
{
   class Program
    {   
        static void CopyData<T>(T[] a, T[] b)
        {
            for(int i = 0; i < a.Length; i++)
            {
                b[i] = a[i];    
            }
        }


        static void Main(string[] args)
        {
            int[] a = { 11, 22, 33, 44, 55 };
            int[] b = new int[a.Length];

            CopyData<int>(a, b);

            foreach(int i in b) 
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();

            string[] aa = { "사과", "배", "수박", "딸기", "복숭아" };
            string[] bb = new string[aa.Length];

            CopyData<string>(aa, bb);

            foreach(string i in bb)
            {
                Console.Write(i + ' ');
            }
        }
    }
}

Output

11 22 33 44 55
사과 배 수박 딸기 복숭아

일반화 클래스

일반화 클래스 선언 방식

• 일반화 클래스는 똑같은 기능을 하지만 내부적으로 사용하는 데이터 형식이 다를 경우에 사용

        class 클래스명 <T>
        {

        }
        class DemoList
        {
            private int[] array;
            public int GetItem(int idx){ return array[idx];}
        }

        class DemoList2
        {
            private double[] array;
            public double GetItem(int idx){ return array[idx];}
        }

        ... 다른 타입에 대한 DemoList 클래스들...

• 위와 같이 데이터타입만 다른 클래스들을 일반화 클래스로 작성하면 하나의 클래스만으로 커버할 수 있다.

        class DemoList<T>
        {
            private T[] array;
            public T GetItem(int idx){return array[idx]}
        }

        사용법 :
            DemoList<int> demoList1 = new DemoList<int>();
            DemoList<double> demoList2 = new DemoList<double>();

• 이와 같이 하나의 일반화 클래스를 사용해 다른 타입들을 커버할 수 있다.

namespace GenericsEx2
{
    class Program
    {   
        class MyList<T>
        {
            private T[] array;
            public MyList()
            {
                array = new T[4];
            }

            public T this[int idx]
            {
                get { return array[idx]; } 

                set 
                {
                    if (idx >= array.Length)
                    {
                        Array.Resize<T>(ref array, idx + 1);
                        Console.WriteLine($"배열 사이즈 조정 : {array.Length}");
                    }
                    array[idx] = value;
                }
            }
            public int Length
            {
                get { return array.Length; }
            }
        }
        static void Main(string[] args)
        {            
            MyList<string> mylist = new MyList<string>();
            mylist[0] = "A";
            mylist[1] = "B";
            mylist[2] = "C";
            mylist[3] = "D";
            mylist[4] = "E"; // set에서 배열 사이즈 조정일 일어남.

            for(int i = 0; i < mylist.Length; i++)
            {
                Console.WriteLine(mylist[i]);
            }

            MyList<int> mylist2 = new MyList<int>();
            mylist2[0] = 100;
            mylist2[1] = 200;
            mylist2[2] = 300;
            mylist2[3] = 400;
            mylist2[4] = 500;
            mylist2[5] = 600;
            mylist2[6] = 700;
            for (int i = 0; i < mylist2.Length; i++)
            {
                Console.WriteLine(mylist2[i]);
            }   
        }
    }
}

Output

배열 사이즈 조정 : 5
A
B
C
D
E
배열 사이즈 조정 : 5
배열 사이즈 조정 : 6
배열 사이즈 조정 : 7
100
200
300
400
500
600
700