[C#] 일반화 프로그래밍: 메서드, 클래스, 제약조건

일반화 메서드

데이터 타입을 매개변수처럼 받아서 쓸 수 있도록 해준다. 

namespace GenericMeThodExample
{
    class MainApp
    {
        static void CopyArray<T>(T[] source, T[] target)
        {
            for (int i = 0; i < source.Length; i++)
            {
                target[i] = source[i];
            }
        }

        public static void Main(string[] args) 
        {
            // int 형식 배열을 넣으면
            int[] source = { 1, 2, 3, 4, 5 };
            int[] target = new int[source.Length];

            CopyArray(source, target); // 자동으로 int형으로 인식

            Console.WriteLine(string.Join(", ", target));

            // string 형식 배열을 넣으면
            string[] source2 = { "a", "b", "c", "d", "e" };
            string[] target2 = new string[source.Length];

            CopyArray(source2, target2); // 자동으로 string형으로 인식

            Console.WriteLine(string.Join(", ", target2));
        }
    }
}

 

일반화 클래스

클래스도 데이터 형식만 다르게 하고 싶은 경우, 데이터 형식을 매개변수처럼 두고 나머지는 일반화할 수 있다.

namespace GenericClassExample
{
    class MyList<T>
    {
        private T[] array;
        // MyList 선언 시 크기가 3인 배열이 생성됨
        public MyList() 
        {
            array = new T[3];
        }
        // MyList 인덱서
        public T this[int index]
        {
            get
            {
                return array[index];
            }
            set
            {
                if (index >= array.Length)
                {
                    Array.Resize(ref array, index + 1);
                }
                array[index] = value;
            }
        }
        // Length 함수를 쓰면 현재 길이 반환
        public int Length
        {
            get { return array.Length; }
        }

        // 현재 List 목록을 나타내는 함수
        public string CurrentList
        {
            get
            {
                return string.Join(", ", array);
            }
        }
    }
    class MainApp
    {
        public static void Main(string[] args)
        {
            // string 배열로 선언
            MyList<string> list = new MyList<string>();
            list[0] = "a";
            list[1] = "b";
            list[2] = "c";
            list[3] = "d";
            Console.WriteLine(list.Length);
            Console.WriteLine(list.CurrentList);

            // int 배열로 선언
            MyList<int> list2 = new MyList<int>();
            list2[0] = 1;
            list2[1] = 2;
            list2[2] = 3;
            list2[3] = 4;
            Console.WriteLine(list2.Length);
            Console.WriteLine(list2.CurrentList);
        }
    }
}

 

매개변수에 제약조건 추가

• Class Container<T> where T : struct   => T는 반드시 값 형식이어야 한다.

public class Container<T> where T : struct { ... }
public class Program
{
    public static void Main(string[] args)
    {
        Container<int double char struct enum 등 값 형식> container = new Container<값형식>(값 타입);
    }
}

• Class Container<T> where T : class   => T는 반드시 참조 형식이어야 한다.

public class Container<T> where T : struct { ... }
public class Program
{
    public static void Main(string[] args)
    {
        Container<string object class interface 등의 참조형식> container = new Container<참조형식>(참조 타입);
    }
}

• Class Container<T> where T : new()   => T는 반드시 매개변수가 없는 생성자가 있어야 한다.

public class Container<T> where T : new()
{
    private T item;

    public Container()
    {
        item = new T();
    }
}

public class Program
{
    public static void Main(string[] args)
    {
        Container<데이터 타입 아무거나> container = new Container<데이터 타입 아무거나>();
    }
}

• Class Container<T> where T : 기반클래스명   => T는 반드시 명시한 기반 클래스의 파생 클래스여야 한다.

public class Container<T> where T : SomeBaseClass { ... }
public class Program
{
    public static void Main(string[] args)
    {
        Container<SomeBaseClass 혹은 SomeBaseClass를 상속받는 클래스> container = new Container<SomeBaseClass 혹은 SomeBaseClass를 상속받는 클래스>(new SomeBaseClass 혹은 SomeBaseClass를 상속받는 클래스());
    }
}

• Class Container<T> where T : 기반인터페이스명   => T는 반드시 명시한 인터페이스를 구현해야한다.

public class Container<T> where T : ISomeInterface { ... }
public class Program
{
    public static void Main(string[] args)
    {
        Container< ISomeInterface> container = new Container< ISomeInterface>( ISomeInterface를 상속받는 클래스());
    }
}

• Class Container<T, U> where T : U   => T는 반드시 또 다른 형식 매개변수 U로부터 상속받은 클래스여야 한다.

public class Container<T, U> where T : U { ... }

public class A { }
public class B : A { }
public class C : B { }

public class Program
{
    public static void Main(string[] args)
    {
        Container<B, A> container = new Container<B, A>(new C());
    }
}