제네릭
https://msdn.microsoft.com/ko-kr/library/512aeb7t.aspx
1. 제네릭이 2.0 버전의 C# 언어와 CLR(공용 언어 런타임)에 추가되었습니다.
2. 제네릭을 통해 .NET Framework에 형식 매개 변수(type parameters)라는 개념이 처음 소개되었습니다.
3. 형식 매개 변수를 사용하면 클라이언트 코드에서 클래스나 메서드를 선언하고 인스턴스화할 때까지 하나 이상의 형식 지정(specification)을 연기(defer)하는 클래스와 메서드를 디자인할 수 있습니다.
4. 예를 들어 다음과 같이 제네릭 형식 매개 변수 T를 사용하면 런타임 캐스트나 boxing 작업에 따른 비용이나 위험을 초래(incur)하지 않은 채 다른 클라이언트에서 사용 가능한 단일 클래스를 작성할 수 있습니다.
// Declare the generic class. public class GenericList<T> { void Add(T input) { } } class TestGenericList { private class ExampleClass { } static void Main() { // Declare a list of type int. GenericList<int> list1 = new GenericList<int>(); // Declare a list of type string. GenericList<string> list2 = new GenericList<string>(); // Declare a list of type ExampleClass. GenericList<ExampleClass> list3 = new GenericList<ExampleClass>(); } }
<제네릭 개요>
5. 제네릭 형식을 사용하면 코드 재사용(code reuse), 형식 안전성, 성능(performance)을 최대화할 수 있습니다.
6. 제네릭의 가장 일반적인 용도(the most common use)는 컬렉션 클래스를 만드는 것입니다.
7. .NET Framework 클래스 라이브러리에는 System.Collections.Generic 네임스페이스의 여러 가지 새로운 제네릭 컬렉션 클래스가 포함되어 있습니다.
8. 이러한 클래스는 가능한 경우 항상 System.Collections 네임스페이스의 ArrayList 같은 클래스 대신 사용해야 합니다.
9. 고유한 제네릭 인터페이스, 클래스, 메서드, 이벤트 및 대리자를 만들 수 있습니다.
10. 특정 데이터 형식의 메서드에만 액세스하도록 제네릭 클래스를 제한(constrain)할 수 있습니다.
11. 리플레션을 사용하면 런타임에 제네릭 데이터 형식에 사용되는 형식과 관련된정보를 얻을 수 있습니다.
<관련 단원>
12. 자세한 내용은 다음을 참조하십시오.
1) 제네릭 소개
2) 제네릭의 장점
3) 제네릭 형식 매개 변수
5) 제네릭 클래스
6) 제네릭 인터페이스
7) 제네릭 메서드
8) 제네릭 대리자
11) 제네릭 및 리플렉션
12) 런타임의 제네릭
13) .NET Framework 클래스 라이브러리의 제네릭
제네릭 소개
1. 제네릭 클래스 및 메서드를 사용하면 제네릭이 아닌 형식(counterparts)에서는 불가능한 재사용성, 형식 안전성 및 효율성을 달성할 수 있습니다.
2. 제네릭은 컬렉션 및 컬렉션을 다루는 메서드에서 가장 자주 사용됩니다.
3. .NET Framework 클래스라이브러리 버전 2.0에서는 System.Collections.Generic이라는 새로운 네임스페이스를 제공하며, 이 네임스페이스에는 새로운 제네릭 기반 컬렉션 클래스가 여러 개 있습니다.
4. .NET Framework 2.0 이상을 대상으로하는 모든 응용 프로그램에서는 이전의 ArrayList 같은 제네릭이 아닌 형식 대신 새로운 제네릭 컬렉션 클래스를 사용하는 것이 좋습니다.
5. 자세한 내용은 .NET Framework 클래스 라이브러리의 제네릭을 참조하십시오.
6. 물론 사용자 고유의 형식이 안전하고 효율적인 일반화 솔루션 및 디자인 패턴을 제공하기 위해 사용자 지정 제네릭 형식 및 메서드를 만들 수도 있습니다.
7. 다음 코드 예제에서는 이해를 돕기 위해(for demonstration purposes) 간단한 제네릭 연결 리스트 클래스를 보여 줍니다.
8. 대부분의 경우에는 사용자가 이러한 클래스를 직접 만드는 대신 .NET Framework 클래스 라이브러리에서 제공하는 List<T> 클래스를 사용해야 합니다.
9. 목록에 저장되는 항목의 형식을 지정하기 위해 일반적으로는(ordinarily) 구체적인(concrete) 형식이 사용될 여러 위치에 형식 매개 변수 T가 사용되고 있습니다.
10. 구체적으로는 다음과 같이 사용되고 있습니다.
1) AddHead 메서드의 메서드 매겨 변수 형식
2) 공용 메서드인 GetNext의 반환 형식 및 중첩 Node 클래스의 Data 속성
3) 중첩 클래스에 있는 전용 멤버 데이터의 형식
11. 중첩 Node 클래스에서도 T를 사용할 수 있습니다.
12. GenericList<int>와 같이 GenericList<T>를 구체적 형식을 사용하여 인스턴스화하면 모든 T가 int로 대체됩니다.
// type parameter T in angle brackets public class GenericList<T> { // The nested class is also generic on T. private class Node { // T used in non-generic constructor. public Node(T t) { next = null; data = t; } private Node next; public Node Next { get { return next; } set { next = value; } } // T as private member data type. private T data; // T as return type of property. public T Data { get { return data; } set { data = value; } } } private Node head; // constructor public GenericList() { head = null; } // T as method parameter type: public void AddHead(T t) { Node n = new Node(t); n.Next = head; head = n; } public IEnumerator<T> GetEnumerator() { Node current = head; while (current != null) { yield return current.Data; current = current.Next; } } }
13. 다음 코드 예제에서는 클라이언트 코드에서 제네릭 GenericList<T> 클래스를 사용하여 정수 목록을 만드는 방법을 보여 줍니다.
14. 형식 매개 변수를 변경하는 간단한 방법으로 다음 코드를 문자열이나 기타 사용자 지정 형식의 목록을 만들도록 쉽게 변경할 수 있습니다.
class TestGenericList { static void Main() { // int is the type argument GenericList<int> list = new GenericList<int>(); for (int x = 0; x < 10; x++) { list.AddHead(x); } foreach (int i in list) { System.Console.Write(i + " "); } System.Console.WriteLine("\nDone"); } }
제네릭의 장점
1. 제네릭을 사용하면 이전 버전의 공용 언어 런타임과 C# 언어에 적용되었던 제한 사항(limitation)을 해결할 수 있습니다.
2. 이전 버전에서는 유니버설 기본 형식인 Object와 형식 사이의 캐스팅을 통해 일반화를 수행(accomplish)했습니다.
3. 제네릭 클래스를 만들면 컴파일 타임에 안전한 컬렉션을 만들 수 있습니다.
4. 제네릭이 아닌 컬렉션 클래스를 사용하는 경우의 제한 사항을 보여 주는 예로는 .NET Framework 클래스 라이브러리에서 ArrayList 컬렉션 클래스를 사용하는 간단한 프로그램을 작성하는 경우를 들 수 있습니다.
5. ArrayList는 참조나 값 형식을 저장하기 위해 수정(modification)하지 않고도 사용할 수 있는 매우 편리한 컬렉션 클래스(a highly convenient collection)입니다.
// The .NET Framework 1.1 way to create a list: System.Collections.ArrayList list1 = new System.Collections.ArrayList(); list1.Add(3); list1.Add(105); System.Collections.ArrayList list2 = new System.Collections.ArrayList(); list2.Add("It is raining in Redmond."); list2.Add("It is snowing in the mountains.");
6. 그러나 이러한 편리함에는 상응하는 대가가 따릅니다(But this convenience comes at a cost).
7. ArrayList에 추가되는 모든 참조나 값 형식은 Object에 암시적으로 업캐스팅(upcast)됩니다.
8. 항목(items)이 값 형식이면 이를 목록에 추가할 때 boxing해야 하고 이를 검색할 때 unboxing해야 합니다.
9. 캐스팅이나 boxing 및 unboxing 작업은 모두 성능을 저하시킵니다.
10. 큰 컬렉션을 반복해야 하는 시나리오에서는 boxing과 unboxing의 영향을 결코 무시할 수 없습니다.
11. 다른 제한 사항으로는 컴파일 타임에 형식을 검사할 수 없다는 점을 들 수 있습니다(is lack of).
12. ArrayList는 Object에 모든 항목을 캐스팅하므로 컴파일 타임에 클라이언트 코드가 다음과 같은 작업을 수행하지 못하도록 막을 수 없습니다.
System.Collections.ArrayList list = new System.Collections.ArrayList(); // Add an integer to the list. list.Add(3); // Add a string to the list. This will compile, but may cause an error later. list.Add("It is raining in Redmond."); int t = 0; // This causes an InvalidCastException to be returned. foreach (int x in list) { t += x; }
13. 유형이 다른 컬렉션(a heterogeneous collection)을 만드는 경우 규칙을 정확히 따르는(perfectly acceptable) 의도적인(intentional) 선택일지라도 문자열과 ints를 단일 ArrayList에 결합하면 프로그래밍 오류가 발생할 확률이 더 커지고 이러한 오류는 런타임 이전에 발견할 수 없습니다.
14. 버전 1.0 및 1.1의 C# 언어에서는 고유한 형식별 컬렉현을 작성하는 방법으로만 .NET Framework 기본 클래스 라이브러리 컬렉션 클래스에서 코드를 일반화하는 위험(the dangers of generalized code)을 방지할 수 있었습니다.
15. 물론 이러한 클래스는 여러 데이터 형식에 다시 사용(reusable)할 수 없으므로 일반화의 이점(the benefits of generalization)이 사라지고 저장하려는 각 형식에 대해 클래스를 다시 작성해야만 합니다.
16. ArrayList 및 기타 유사한 클래스에 실제로 필요한 것은 클라이언트 코드에서 사용하려는 특정 데이터 형식을 인스턴스별로(on a per-instance basis) 지정할 수 있는 방법입니다.
17. 이렇게 하면 T:System.Object로 업캐스팅할 필요가 없어지고 컴파일러에서 형식을 검사할 수도 있게 됩니다.
18. 즉, ArrayList에는 형식 매개 변수가 필요합니다.
19. 제네릭은 바로 이러한 요구 사항을 충족시킵니다.
20. N:System.Collections.Generic 네임스페이스의 제네릭 List<T> 컬렉션에서는 컬렉션에 항목을 추가하는 동일한 작업을 다음과 같이 수행할 수 있습니다.
// The .NET Framework 2.0 way to create a list List<int> list1 = new List<int>(); // No boxing, no casting: list1.Add(3); // Compile-time error: // list1.Add("It is raining in Redmond.");
21. 클라이언트 코드에서 ArrayList와 비교할 때 List<T>을 사용하여 유일하게 추가된 구문은 선언과 인스턴스화의 형식 인수(the type argument)입니다.
22. 이와 같이 코딩이 약간 더 복잡해진 대신(In return for this slightly more coding complexity) ArrayList보다 안전하면서도 속도가 훨씬 빠른 목록을 만들 수 있습니다.
23. 이러한 차이는 목록 항목이 값 형식인 경우에 특히 잘 드러납니다.
제네릭 형식 매개 변수
1. 제네릭 형식 또는 메서드 정의에서 형식 매개 변수(a type parameters)는 클라이언트가 제네릭 형식의 변수를 인스턴스화할 때 지정하는 특정 형식에 대한 자리 표시자(placeholder)입니다.
2. 제네릭 소개에 나열된(listed) GenericList<T> 등의 제네릭 클래스는 실제로 형식이 아니고 형식에 대한 청사진(blueprint)과 같으므로 있는 그대로(as-is) 사용할 수는 없습니다.
3. 클라이언트 코드에서 GenericList<T>를 사용하려면 꺾쇠괄호(the angle brackets) 내에 형식 매개 변수를 지정하는 방법으로 생성된 형식을 선언하고 인스턴스화해야 합니다.
4. 이 특정 클래스(this particular class)에 대한 형식 매개 변수의 형식은 컴파일러에서 인식하는 모든 형식이 될 수 있습니다.
5. 만들 수 있는 생성된 형식 인스턴스의 수에는 제한이 없고(Any number of), 각 인스턴스에서는 다음과 같이 서로 다른 형식 매개 변수를 사용할 수 있습니다.
GenericList<float> list1 = new GenericList<float>(); GenericList<ExampleClass> list2 = new GenericList<ExampleClass>(); GenericList<ExampleStruct> list3 = new GenericList<ExampleStruct>();
<형식 매개 변수 명명 지침>
6. 필수적. 단일 문자 이름으로도 자체 설명이 가능하여(completely self explanatory) 설명적인 이름(descriptive names)을 굳이 사용할 필요가 없는 경우가 아니면 제네릭 형식 매개 변수 이름을 설명적인 이름으로 지정하십시오.
public interface ISessionChannel<TSession> { /*...*/ } public delegate TOutput Converter<TInput, TOutput>(TInput from); public class List<T> { /*...*/ }
7. 선택적. 단일 문자 형식 매개변수를 사용하는 형식에는 형식 매개 변수 이름(the type parameter name)으로 T를 사용하십시오.
public int IComparer<T>() { return 0; } public delegate bool Predicate<T>(T item); public struct Nullable<T> where T : struct { /*...*/ }
8. 필수적. 설명적인(descriptive) 형식 매개 변수 이름 앞에 "T"를 붙이십시오.
public interface ISessionChannel<TSession> { TSession Session { get; } }
9. 선택적. 매개 변수 이름 안에는 형식 매개 변수에 적용되는 제약 조건(constraints)을 나타내십시오.
10. 예를 들어 ISession으로 제한되는 매개 변수의 이름은 TSession이 될 수 있습니다.
제네릭 형식 매개 변수에 대한 제약 조건
1. 제네릭 클래스를 정의하는 경우 클래스를 인스턴스화할 때 클라이언트 코드에서 형식 인수에 사용할 수 있는 형식의 종류에 제약 조건(restrictions)을 적용할 수 있습니다.
2. 클라이언트 코드가 제약 조건에서 허용하지 않는 형식을 사용하여 클래스를 인스턴스화하려고 하면 컴파일 타임 오류가 발생합니다.
3. 이러한 제한(restrictions)을 제약 조건(constraints)이라고합니다.
4. 제약 조건은 컨텍스트 키워드 where를 사용하여 지정합니다.
5. 다음 표에서는 여섯 가지의 형식 제약 조건을 보여 줍니다.
설명 | |
|---|---|
where T: struct | |
where T : class | 형식 인수가 참조 형식이어야 합니다. 이는 모든 클래스, 인터페이스, 대리자 또는 배열 형식에도 적용됩니다. |
where T : new() | |
where T : <기본 클래스 이름> | 형식 인수가 지정된 기본 클래스이거나 지정된 기본 클래스에서 파생되어야 합니다. |
where T : <인터페이스 이름> | |
where T : U | T에 대해 지정한 형식 인수가 U에 대해 지정한 인수이거나 이 인수에서 파생되어야 합니다. |
<제약 조건 사용 이유>
6. 제네릭 목록의 항목을 검사(examine)하여 그 유효성 여부를 확인하거나 이 항목을 다른 항목과 비교하려는 경우, 컴파일러는 클라이언트 코드에서 지정할 수 있는 모든 형식 인수에 대해 호출해야 할 메서드나 연산자가 지원되는지 확인해야 합니다.
7. 하나 이상의 제약 조건을 제네릭 클래스 정의에 적용하면 이러한 확인(guarantee)이 가능합니다.
8. 예를 들어, 기본 클래스 제약 조건에서는 이 형식의 개체와 이 형식에서 파생된 개체만이 형식 인수로 사용될 수 있음을 컴파일러에 알립니다.
9. 컴파일러에서 이를 확인하면 사용자는 제네릭 클래스에서 해당 형식의 메서드를 호출할 수 있습니다.
10. 제약 조건은 컨텍스트 키워드 where를 사용하여 적용됩니다.
11. 다음 코드 예제에서는 기본 클래스 제약 조건을 적용하여 제네릭 소개의 GenericList<T> 클래스에 추가할 수 있는 기능을 보여 줍니다.
public class Employee { private string name; private int id; public Employee(string s, int i) { name = s; id = i; } public string Name { get { return name; } set { name = value; } } public int ID { get { return id; } set { id = value; } } } public class GenericList<T> where T : Employee { private class Node { private Node next; private T data; public Node(T t) { next = null; data = t; } public Node Next { get { return next; } set { next = value; } } public T Data { get { return data; } set { data = value; } } } private Node head; public GenericList() //constructor { head = null; } public void AddHead(T t) { Node n = new Node(t); n.Next = head; head = n; } public IEnumerator<T> GetEnumerator() { Node current = head; while (current != null) { yield return current.Data; current = current.Next; } } public T FindFirstOccurrence(string s) { Node current = head; T t = null; while (current != null) { //The constraint enables access to the Name property. if (current.Data.Name == s) { t = current.Data; break; } else { current = current.Next; } } return t; } }
12. 제약 조건을 사용하면 형식 T의 모든 항목이 항상 Employee 개체이거나 Employee에서 상속된 개체이므로 제네릭 클래스에서 Employee.Name 속성을 사용할 수 있습니다.
13. 여러 제약 조건을 동일한 형식 매개 변수에 적용할 수 있고 제약 조건 자체가 제네릭 형식일 수도 있습니다.
class EmployeeList<T> where T : Employee, IEmployee, System.IComparable<T>, new() { // ... }
14. 형식 매개 변수를 제한하면, 허용되는 작업의 수 및 제한하는 형식과 해당 상속 계층 구조(its inheritance hierarchy)의 모든형식에서 지원하는 메서드에 대해 허용되는 호출의 수를 늘릴 수 있습니다.
15. 따라서 제네릭 클래스나 메서드를 디자인할 때 System.Object에서 지원하지 않는 메서드를 호출하거나 제네릭 멤버에 대해 단순한 할당 이상의 작업을 수행하려는 경우에는 형식 매개 변수에 제약조건을 적용해야 합니다.
16. where T : class 제약 조건을 적용할 때는 형식 매개 변수에 대해 == 및 != 연산자를 사용하지 않아야 합니다.
17. 이러한 연산자에서는 값이 같은지(value equality) 확인하는 대신 참조가 동일한지만(reference identity) 테스트하기 때문입니다.
18. 인수로 사용되는 형식에서 이러한 연산자를 오버로드한 경우에도 마찬가지입니다(this is the case).
19. 다음 코드에서는 이러한 경우(this point)의 예를 보여 줍니다.
20. String 클래스에서 == 연산자를 오버로드해도 false가 출력됩니다.
public static void OpTest<T>(T s, T t) where T : class { System.Console.WriteLine(s == t); } static void Main() { string s1 = "target"; System.Text.StringBuilder sb = new System.Text.StringBuilder("target"); string s2 = sb.ToString(); OpTest<string>(s1, s2); }
21. 이러한 방식으로 동작하는 이유는 컴파일 시 컴파일러에는 T가 참조 형식이라는 정보만 제공되므로 모든 참조 형식에 유효한 default 연산자가 사용되기 때문입니다.
22. 값이 동일한지 테스트하려면 where T : IComparable<T> 제약 조건을 함께 적용하고 제네릭 클래스를 생성하는데 사용되는 모든 클래스에서 해당 인터페이스를 구현하는 것이 좋습니다.
23. 다음 예제와 같이 여러 매개 변수에 제약 조건을 적용하고 단일 매개 변수에 여러 제약 조건을 적용할 수 있습니다.
class Base { } class Test<T, U> where U : struct where T : Base, new() { }
<바인딩되지 않은 형식 매개 변수>
24. public 클래스 SampleClass<T>{}의 T와 같이 제약 조건이 없는 형식 매개 변수를 바인딩되지 않은 형식(unbounded type) 매개 변수라고 합니다.
25. 바인딩 되지 않은 형식 매개 변수에는 다음과 같은 규칙이 적용됩니다.
1) != 및 == 연산자를 사용할 수 없습니다. 구체적인 형식 인수(concrete type argument)에서 이러한 연산자를 지원하리라는 보장이 없기(there is no guarantee) 때문입니다.
2) 바인딩 되지 않은 형식 매개 변수와 System.Object 사이에 변환하거나 이 매개 변수를 임의의 인터페이스 형식으로 명시적으로 변환할 수 있습니다.
3) 바인딩 되지 않은 형식 매개 변수를 null과 비교할 수 있습니다. 바인딩되지 않은 매개 변수를 null과 비교하는 경우 형식 인수가 값 형식이면 비교 결과로 항상 false가 반환됩니다.
<제약 조건으로서의 형식 매개 변수>
26. generic 형식을 제약조건으로 사용하면 다음 예제에서와 같이 자체 형식 매개 변수가 있는 멤버 함수에서 해당 매개 변수를 포함 형식의 형식 매개 변수로 제한해야 하는 경우에 유용합니다.
27. 위 예제에서 T는 Add 메서드의 컨텍스트에서는 형식 제약 조건이고 List 클래스의 컨텍스트에서는 바인딩되지 않은 형식 매개 변수입니다.
28. 형식 매개 변수는 제네릭 클래스 정의에서 제약 조건으로도 사용할 수 있습니다.
29. 형식 매개 변수는 다른 형식의 매개 변수와 함께 꺾쇠 괄호 안에 선언되어야 합니다.
//Type parameter V is used as a type constraint. public class SampleClass<T, U, V> where T : V { }
30. 컴파일러에서는 형식 매개 변수가 System.Object에서 파생된다는 점을 제외하고는 이 제약 조건에 대해 어떠한 정보도 알 수 없으므로 형식 매개 변수와 제네릭 클래스를 함께 사용할 필요는 거의 없습니다.
31. 제네릭 클래스에 대해 형식 매개 변수를 제약 조건으로 사용하는 경우로는 두 형식 매개 변수 사이에 반드시 상속 관계가 있도록 정의하는 경우를 들 수 있습니다.
제네릭 클래스
1. 제네릭 클래스는 특정 데이터 형식(a particular data type)에 고유하지 않은 작업을 캡슐화합니다.
2. 제네릭 클래스는 연결된 목록, 해시 테이블, 스택, 큐, 트리 등의 컬렉션에 가장 일반적으로 사용됩니다.
3. 컬렉션에서 항목을 추가하고 제거하는 등의 작업은 저장되는 데이터의 형식에 관계없이(regardless of) 기본적으로 동일한 방식으로 수행됩니다.
4. 컬렉션 클래스가 필요한 대부분의 시나리오에서는 .NET Framework 클래스 라이브러리에서 제공하는 컬렉션을 사용하는 것이 좋습니다.
5. 이러한 클래스 사용에 대한 자세한 내용은 .NET Framework 클래스 라이브러리의 제네릭을 참조하십시오.
6. 일반적으로(typically) 기존의 구체적인 클래스로(an existing concrete class) 시작하여 일반성(generalization)과 편의성(usability)의 균형이 맞을 때까지 형식을 하나씩 형식 매개 변수로 바꾸는 방법으로 제네릭 클래스를 만듭니다.
7. 사용자 고유의 제네릭 클래스를 만들 때는 다음과 같은 사항을 고려해야 합니다.
1) 형식 매개 변수로 일반화할 형식:
a) 일반적으로는(as a rule), 매개 변수화(parameterize)할 수 있는 형식이 많을수록 코드의 융통성(flexible)과 재사용 가능성(reusable)이 향상됩니다.
b) 그러나 코드를 지나치게 일반화하면 다른 개발자가 읽거나 이해하기가 어려워집니다.
2) 형식 매개 변수에 적용할 제약 조건(형식 매개 변수에 대한 제약 조건) 참조
a) 필요한 형식을 처리할 수 있는 범위 내에서 최대한 많은 제약 조건을 적용하는 것이 좋습니다.
b) 예를 들어 사용자 제네릭 클래스를 참조 형식으로만 사용하려는 경우에는 클래스 제약 조건을 적용합니다.
c) 이렇게 하면 클래스를 값 형식으로 잘못 사용하는 것을(unintended use)) 막을 수 있고, T에 as 연산자를 사용하여 null 값 여부를 확인할 수 있습니다.
3) 제네릭 동작을 기본 클래스와 서브클래스로 분할할지 여부.
a) 제네릭 클래스는 기본 클래스가 될 수 있으므로(serve as) 제네릭이 아닌 클래스에 적용되는 디자인 고려 사항(considerations)이 동일하게 적용됩니다.
b) 자세한 내용은 이 항목의 뒷부분에서 설명하는 제네릭 기본 클래스에서 상속하는 데 대한 규칙을 참조하십시오.
4) 제네릭 인터페이스를 하나 이상 구현할지 여부
a) 예를 들어 제네릭 기반 컬렉션(a generics-based collection)의 항목을 만드는 데 사용될 클래스를 디자인하는 경우 IComparable<T>(T는 사용자 클래스 형식)과 같은 인터페이스를 구현해야 할 수 있습니다.
8. 간단한 제네릭 클래스의 예제를 보려면 제네릭 소개를 참조하십시오.
9. 형식 매개 변수와 제약 조건에 대한 규칙은 제네릭 클래스 동작에서 특히 상속과 멤버 액세스 가능성에 대해 몇 가지 영향(several implications)을 줍니다.
10. 계속하려면(proceeding) 몇 가지 용어(some terms)를 이해하고 있어야 합니다.
11. Note<T>, 제네릭 클래스의 경우 클라이언트 코드에서는 형식 인수를 지정하여 폐쇄형 생성(a closed constructed type)(Node<int>)을 만드는 방법으로 클래스를 참조하거나,
12. 제네릭 기본 클래스를 지정하는 경우와 같이 형식 매개 변수를 지정하지 않고 개방형 생성 형식(Node<T>)을 만드는 방법으로 클래스를 참조할 수 있습니다.
13. 제네릭 클래스는 구체적인 클래스, 폐쇄형 구성 클래스 또는 개방형 구성 기본 클래스에서 상속할 수 있습니다.
class BaseNode { } class BaseNodeGeneric<T> { } // concrete type class NodeConcrete<T> : BaseNode { } //closed constructed type class NodeClosed<T> : BaseNodeGeneric<int> { } //open constructed type class NodeOpen<T> : BaseNodeGeneric<T> { }
14. 제네릭이 아닌 구체적인 클래스는 폐쇄형 생성 기본 클래스에서는 상속할 수 있지만 개방형 생성 클래스 또는 형식 매개 변수에서는 상속할 수 없습니다.
15. 이는 런타임에 클라이언트 코드에서 기본 클래스를 인스턴스화할 때 필요한 형식 인수를 제공할 수 없기 때문이다.
//No error class Node1 : BaseNodeGeneric<int> { } //Generates an error //class Node2 : BaseNodeGeneric<T> {} //Generates an error //class Node3 : T {}
16. 개방형 생성 형식에서 상속하는 제네릭 클래스에서는 다음 코드와 같이 상속하는 클래스에서 공유하지 않는 모든 클래스 형식 매개 변수에 대해 형식 인수를 제공해야 합니다.
class BaseNodeMultiple<T, U> { } //No error class Node4<T> : BaseNodeMultiple<T, int> { } //No error class Node5<T, U> : BaseNodeMultiple<T, U> { } //Generates an error //class Node6<T> : BaseNodeMultiple<T, U> {}
17. 개방형 생성 형식에서 상속하는 제네릭 클래스에서는 기본 형식에 대한 제약 조건(a superset of)을 포함하거나 암시적인 제약 조건을 지정해야 합니다.
class NodeItem<T> where T : System.IComparable<T>, new() { } class SpecialNodeItem<T> : NodeItem<T> where T : System.IComparable<T>, new() { }
18. 제네릭 형식은 다음과 같이 여러 형식 매개 변수 및 제약 조건을 사용할 수 있습니다.
class SuperKeyType<K, V, U> where U : System.IComparable<U> where V : new() { }
19. 개방형 생성 형식 및 폐쇄형 생성 형식은 메서드 매개 변수로 사용될 수 있습니다.
void Swap<T>(List<T> list1, List<T> list2) { //code to swap items } void Swap(List<int> list1, List<int> list2) { //code to swap items }
20. 제네릭 클래스에서 인터페이스를 구현하면 이 클래스의 모든 인스턴스를 해당 인터페이스에 캐스팅할 수 있습니다.
21. 제네릭 클래스는 비가변적(invariant)입니다.
22. 즉, 입력 매개 변수에서 List<BaseClass>를 지정하면 List<DerivedClass>를 제공하려고 할 때 컴파일 타임 오류가 발생합니다.
제네릭 인터페이스
1. 제네릭 컬렉션 클래스 또는 컬렉션의 항목을 나타내는 제네릭 클래스에 대한 인터페이스를 정의하는 것이 유용한 경우가 많습니다.
2. 값 형식에 대해 boxing 및 unboxing 연산을 하지 않으려면 제네릭 클래스에서 IComparable 대신 IComparable<T> 같은 제네릭 인터페이스를 사용하는 것이 좋습니다(the preference).
3. .NET Framework 클래스 라이브러리에는 System.Collections.Generic 네임스페이스의 컬렉션 클래스에 사용할 제네릭 인터페이스가 여러 개 정의되어 있습니다.
4. 인터페이스를 형식 매개 변수에 대한 제약 조건으로 지정한 경우 이 인터페이스를 구현하는 형식만 사용할 수 있습니다.
5. 다음 코드 예제에서는 GenericList<T>에서 파생되는 SortedList<T> 클래스를 보여 줍니다.
6. 자세한 내용은 제네릭 소개를 참조하십시오.
7. SortedList<T>는 where T : IComparable<T> 제약 조건을 추가합니다
8. 따라서 SortedList<T>의 BubbleSort 메서드에서는 목록 요소에 대해 제네릭 CompareTo 메서드를 사용할 수 있습니다.
9. 이 예제에서 목록 요소는 IComparable<Person>을 구현하는 단순 클래스인 Person입니다.
//Type parameter T in angle brackets. public class GenericList<T> : System.Collections.Generic.IEnumerable<T> { protected Node head; protected Node current = null; // Nested class is also generic on T protected class Node { public Node next; private T data; //T as private member datatype public Node(T t) //T used in non-generic constructor { next = null; data = t; } public Node Next { get { return next; } set { next = value; } } public T Data //T as return type of property { get { return data; } set { data = value; } } } public GenericList() //constructor { head = null; } public void AddHead(T t) //T as method parameter type { Node n = new Node(t); n.Next = head; head = n; } // Implementation of the iterator public System.Collections.Generic.IEnumerator<T> GetEnumerator() { Node current = head; while (current != null) { yield return current.Data; current = current.Next; } } // IEnumerable<T> inherits from IEnumerable, therefore this class // must implement both the generic and non-generic versions of // GetEnumerator. In most cases, the non-generic method can // simply call the generic method. System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { return GetEnumerator(); } } public class SortedList<T> : GenericList<T> where T : System.IComparable<T> { // A simple, unoptimized sort algorithm that // orders list elements from lowest to highest: public void BubbleSort() { if (null == head || null == head.Next) { return; } bool swapped; do { Node previous = null; Node current = head; swapped = false; while (current.next != null) { // Because we need to call this method, the SortedList // class is constrained on IEnumerable<T> if (current.Data.CompareTo(current.next.Data) > 0) { Node tmp = current.next; current.next = current.next.next; tmp.next = current; if (previous == null) { head = tmp; } else { previous.next = tmp; } previous = tmp; swapped = true; } else { previous = current; current = current.next; } } } while (swapped); } } // A simple class that implements IComparable<T> using itself as the // type argument. This is a common design pattern in objects that // are stored in generic lists. public class Person : System.IComparable<Person> { string name; int age; public Person(string s, int i) { name = s; age = i; } // This will cause list elements to be sorted on age values. public int CompareTo(Person p) { return age - p.age; } public override string ToString() { return name + ":" + age; } // Must implement Equals. public bool Equals(Person p) { return (this.age == p.age); } } class Program { static void Main() { //Declare and instantiate a new generic SortedList class. //Person is the type argument. SortedList<Person> list = new SortedList<Person>(); //Create name and age values to initialize Person objects. string[] names = new string[] { "Franscoise", "Bill", "Li", "Sandra", "Gunnar", "Alok", "Hiroyuki", "Maria", "Alessandro", "Raul" }; int[] ages = new int[] { 45, 19, 28, 23, 18, 9, 108, 72, 30, 35 }; //Populate the list. for (int x = 0; x < 10; x++) { list.AddHead(new Person(names[x], ages[x])); } //Print out unsorted list. foreach (Person p in list) { System.Console.WriteLine(p.ToString()); } System.Console.WriteLine("Done with unsorted list"); //Sort the list. list.BubbleSort(); //Print out sorted list. foreach (Person p in list) { System.Console.WriteLine(p.ToString()); } System.Console.WriteLine("Done with sorted list"); } }
10. 단일 형식에 다음과 같이 여러 인터페이스를 제약 조건으로 지정할 수 있습니다.
class Stack<T> where T : System.IComparable<T>, IEnumerable<T> { }
11. 인터페이스에서는 다음과 같이 두 개 이상의 형식 매개 변수를 정의할 수 있습니다.
interface IDictionary<K, V>
{
}12. 클래스에 적용되는 상속 규칙이 인터페이스에도 적용됩니다.
interface IMonth<T> { } interface IJanuary : IMonth<int> { } //No error interface IFebruary<T> : IMonth<int> { } //No error interface IMarch<T> : IMonth<T> { } //No error //interface IApril<T> : IMonth<T, U> {} //Error
13. 제네릭 인터페이스에 반공변성(contra-variant)이 있는 경우, 즉 형식 매개 변수만 반환 값으로 사용하는 경우 제네릭 인터페이스는 제네릭이 아닌 인터페이스에서 상속할 수 있습니다.
14. .NET Framework 클래스 라이브러리에서 IEnumerable<T>은 GetEnumerator의 반환 값 및 Current 속성 getter에 T만 사용하므로 IEnumerable<T>은 IEnumerable에서 상속합니다.
15. 구체적인 클래스에서는 다음과 같이 폐쇄형 구성 인터페이스를 구현할 수 있습니다.
interface IBaseInterface<T> { } class SampleClass : IBaseInterface<string> { }
16. 제네릭 클래스는 클래스 매개 변수 목록에서 인터페이스에 필요한 모든 인수를 제공하는 경우 다음과 같이 제네릭 인터페이스 또는 폐쇄형 구성 인터페이스를 구현할 수 있습니다.
interface IBaseInterface1<T> { } interface IBaseInterface2<T, U> { } class SampleClass1<T> : IBaseInterface1<T> { } //No error class SampleClass2<T> : IBaseInterface2<T, string> { } //No error
17. 제네릭 클래스, 제네릭 구조체 또는 제네릭 인터페이스 내의 메서드에는 메서드 오버로드를 제어하는 규칙이 동일하게 적용됩니다.
18. 자세한 내용은 제네릭 메서드를 참조하십시오.
제네릭 메서드
1. 제네릭 메서드는 다음과 같이 형식 매개 변수를 사용하여 선언한 메서드입니다.
static void Swap<T>(ref T lhs, ref T rhs) { T temp; temp = lhs; lhs = rhs; rhs = temp; }
2. 다음 코드 예제에서는 형식 인수에 int를 사용하여 메서드를 호출하는 방법을 보여 줍니다.
public static void TestSwap() { int a = 1; int b = 2; Swap<int>(ref a, ref b); System.Console.WriteLine(a + " " + b); }
3. 형식 인수를 생략하고 컴파일러에서 이를 자동으로 유추하도록 할 수도 있습니다.
4. Swap에 대한 다음 호출은 위 예제의 호출과 동일한 작업을 수행합니다.
Swap(ref a, ref b);
5. 정적 메서드와 인스턴스 메서드에는 형식 유추(inference)를 위한 동일한 규칙이 적용됩니다.
6. 컴파일러에서는 사용자가 전달하는 메서드 인수를 기준으로 형식 매개 변수를 유추할 수 있지만 제약 조건이나 반환 값만으로는 형식 매개 변수를 유추할 수 없습니다.
7. 따라서 매개 변수가 없는 메서드에 대해서는 형식 유추가 실행되지 않습니다.
8. 형식 유추는 컴파일러에서 오버로드된 메서드 시그니처를 확인(resolve)하려고 하기 전에 컴파일 타임에 진행됩니다.
9. 컴파일러는 동일한 이름을 공유하는 모든 제네릭 메서드에 형식 유추 논리를 적용합니다.
10. 오버로드 확인(resolution) 단계(step)에서 컴파일러는 형식 유추에 성공한 제네릭 메서드만 포함합니다.
11. 제네릭 클래스 내에서 제네릭이 아닌 메서드는 다음과 같이 클래스 수준 형식 매개 변수에 액세스할 수 있습니다.
class SampleClass<T> { void Swap(ref T lhs, ref T rhs) { } }
9. 포함하는 클래스(containing class)와 동일한 형식 매개 변수를 사용하는 제네릭 메서드를 정의하면 컴파일러에서 CS0693 경고가 발생합니다.
10. 이는 메서드 범위 내에서 내부 T에 대해 제공한 인수가 외부 T에 대에 제공한 인수를 숨기기 때문입니다.
11. 클래스를 인스턴스화할 때 제공한 인수가 아닌 다른 형식 인수를 사용하여 제네릭 클래스 메서드를 호출할 수 있으려면 다음 예제의 GenericList2<T>에서와 같이 메서드의 형식 매개 변수에 다른 식별자를 제공하는 것이 좋습니다.
class GenericList<T> { // CS0693 void SampleMethod<T>() { } } class GenericList2<T> { //No warning void SampleMethod<U>() { } }
12. 메서드에서 형식 매개 변수에 대한 더 구체적인 작업(more specialized operations)을 수행하려면 제약 조건을 사용합니다.
13. SwapIfGreater<T>라는 이 버전의 Swap<T>은 IComparable<T>을 구현하는 형식 인수와만 함께 사용할 수 있습니다.
void SwapIfGreater<T>(ref T lhs, ref T rhs) where T : System.IComparable<T> { T temp; if (lhs.CompareTo(rhs) > 0) { temp = lhs; lhs = rhs; rhs = temp; } }
14. 제네릭 메서드는 여러 형식 매개 변수에 대해 오버로드할 수 있습니다.
15. 예를 들어 다음 메서드에서는 모두 동일한 클래스에 지정할 수 있습니다.
void DoWork() { } void DoWork<T>() { } void DoWork<T, U>() { }
제네릭 대리자
1. 대리자는 자체 형식 매개 변수를 정의할 수 있습니다.
2. 제네릭 대리자를 참조하는 코드에서는 제네릭 클래스를 인스턴스화하거나 제네릭 메서드를 호출할 때와 마찬가지로 다음 예제와 같이 형식 매개 변수를 지정하여 폐쇄형 구성 형식을 만들 수 있습니다.
public delegate void Del<T>(T item); public static void Notify(int i) { } Del<int> m1 = new Del<int>(Notify);
3. C# 버전 2.0에는 메서드 그룹 변환이라는 새로운 기능이 있습니다.
4. 이 기능은 제네릭 대리자뿐만 아니라 구체적인 대리자에도 적용되며, 이를 통해 위 코드를 다음과 같이 단순화된 구문으로 작성할 수 있습니다.
Del<int> m2 = Notify;5. 제네릭 클래스 내에 정의된 대리자에서는 클래스 메서드와 마찬가지로 제네릭 클래스 형식 매개 변수를 사용할 수 있습니다.
class Stack<T> { T[] items; int index; public delegate void StackDelegate(T[] items); }
6. 대리자를 참조하는 코드에서는 다음과 같이 포함하는 클래스의 형식 매개 변수를 지정해야 합니다.
private static void DoWork(float[] items) { } public static void TestStack() { Stack<float> s = new Stack<float>(); Stack<float>.StackDelegate d = DoWork; }
7. sender 인수에 강력한 형식을 사용할 수 있고 Object 사이에서 캐스팅할 필요가 없으므로 제네릭 대리자는 특히 일반적인 디자인 패턴을 기반으로 이벤트를 정의할 때 유용합니다.
delegate void StackEventHandler<T, U>(T sender, U eventArgs); class Stack<T> { public class StackEventArgs : System.EventArgs { } public event StackEventHandler<Stack<T>, StackEventArgs> stackEvent; protected virtual void OnStackChanged(StackEventArgs a) { stackEvent(this, a); } } class SampleClass { public void HandleStackChange<T>(Stack<T> stack, Stack<T>.StackEventArgs args) { } } public static void Test() { Stack<double> s = new Stack<double>(); SampleClass o = new SampleClass(); s.stackEvent += o.HandleStackChange; }
제네릭 코드의 default 키워드
1. 제네릭 클래스 및 메서드에서 다음과 같은 내용을 미리 알지 못하는 경우 매개 변수화된 형식 T에 기본값을 할당하는 방법에 대한 문제가 발생합니다(arise).
1) T가 참조 형식인지 값 형식인지 여부
2) T가 값 형식인 경우 숫자 값인지 구조체인지 여부
2. t가 매개 변수화된 형식 T의 변수인 경우 "t = null"과 같은 구문은 T가 참조 형식인 경우에만 유효하고 "t = 0"은 구조체가 아닌 숫자 값 형식인 경우에만 사용할 수 있습니다.
3. 참조 형식에 대해서는 null을 반환하고 숫자 값 형식에는 0을 반환하는 default 키워드를 사용하면 이 문제를 해결할 수 있습니다.
4. 구조체에 대해서는 멤버가 값 형식인지 참조 형식인지 여부에 따라 0 또는 null로 초기화된 구조체의 각 멤버가 반환됩니다.
5. null 허용 값 형식의 경우 default는 다른 구조체와 같이 초기화되는 System.Nullable<T>을 반환합니다.
6. GenericList<T> 클래스에 있는 다음 예제에서는 default 키워드를 사용하는 방법을 보여 줍니다.
7. 자세한 내용은 제네리 개요(Overview)를 참조하십시오.
namespace ConsoleApplication1 { class Program { static void Main(string[] args) { // Test with a non-empty list of integers. GenericList<int> gll = new GenericList<int>(); gll.AddNode(5); gll.AddNode(4); gll.AddNode(3); int intVal = gll.GetLast(); // The following line displays 5. System.Console.WriteLine(intVal); // Test with an empty list of integers. GenericList<int> gll2 = new GenericList<int>(); intVal = gll2.GetLast(); // The following line displays 0. System.Console.WriteLine(intVal); // Test with a non-empty list of strings. GenericList<string> gll3 = new GenericList<string>(); gll3.AddNode("five"); gll3.AddNode("four"); string sVal = gll3.GetLast(); // The following line displays five. System.Console.WriteLine(sVal); // Test with an empty list of strings. GenericList<string> gll4 = new GenericList<string>(); sVal = gll4.GetLast(); // The following line displays a blank line. System.Console.WriteLine(sVal); } } // T is the type of data stored in a particular instance of GenericList. public class GenericList<T> { private class Node { // Each node has a reference to the next node in the list. public Node Next; // Each node holds a value of type T. public T Data; } // The list is initially empty. private Node head = null; // Add a node at the beginning of the list with t as its data value. public void AddNode(T t) { Node newNode = new Node(); newNode.Next = head; newNode.Data = t; head = newNode; } // The following method returns the data value stored in the last node in // the list. If the list is empty, the default value for type T is // returned. public T GetLast() { // The value of temp is returned as the value of the method. // The following declaration initializes temp to the appropriate // default value for type T. The default value is returned if the // list is empty. T temp = default(T); Node current = head; while (current != null) { temp = current.Data; current = current.Next; } return temp; } } }
C++ 템플릿과 C# 제네릭의 차이점
1. C# 제네릭과 C++ 템플릿은 모두 매개 변수가 있는 형식을 지원하는 언어 기능(language features)입니다.
2. 그러나 이 둘 사이에는 여러 가지 차이점이 있습니다.
3. 구문이라는 측면에서(At the syntax level) C# 제네릭은 C++ 템플릿처럼 복잡하지 않으며 매개 변수가 있는 형식을 보다 간편하게 다룰 수 있습니다.
4. 또한 C#에서는 C++ 템플릿이 제공하는 모든 기능을 제공하지는 않습니다.
5. 구현이라는 측면에서 가장 큰 차이점은, C# 제네릭 형식 대체(substitutions)는 런타임에 수행되므로 인스턴스화된 개체에서 제네릭 형식 정보가 유지(preserve)된다는 점입니다.
6. 자세한 내용은 런타임의 제네릭을 참조하십시오.
7. 다음은 C# 제네릭과 C++ 템플릿 간의 주요 차이점(the key differences)입니다.
1) C# 제네릭은 C++ 템플릿과 같은 정도의 융통성(flexibility)을 제공하지 않습니다. 예를 들어, C# 제네릭 클래스에서 사용자 정의 연산자를 호출할 수는 있지만 산술 연산자를 호출할 수는 없습니다.
2) C#에서는 template C<int i> {} 같은 비형식 템플릿 매개 변수(non-type template parameters)를 허용하지 않습니다.
3) C#에서는 명시적 특수화(explicit specialization)를 지원하지 않습니다. 즉, 특정 형식에 대한 템플릿을 사용자 지정하여 구현할 수 없습니다.
4) C#에서는 부분 특수화(partial specialization)를 지원하지 않습니다. 즉, 형식 인수의 하위 집합(subset)을 사용자 지정하여 구현할 수 없습니다.
5) C#에서는 형식 매개 변수를 제네릭 형식에 대한 기본 클래스로 사용할 수 없습니다.
6) C#에서는 형식 매개 변수에 기본 형식을 사용할 수 없습니다.
7) C#에서는 생성된 형식을 제네릭으로 사용할 수는 있지만 제네릭 형식 매개 변수 자체가 제네릭이 될 수는 없습니다. C++에서는 템플릿 매개 변수를 허용합니다.
8) C++에서는 템플릿의 모든 형식 매개 변수에 대해서는 유효하지 않을 수 있는 코드가 허용되며 이러한 코드는 형식 매개 변수로 사용되는 특정 형식에 대해 검사를 받습니다. C#에서는 제약 조건을 충족하는 모든 형식과 함께 사용할 수 있도록 클래스의 코드를 작성해야 합니다. 예를 들어 C++의 경우 형식 매개 변수의 개체에 대해 + 및 - 산술 연산자를 사용하는 함수를 작성할 수 있습니다. 이 경우 이러한 연산자를 지원하지 않는 형식으로 템플릿을 인스턴스화할 때 오류가 발생합니다. C#에서는 이러한 함수를 작성할 수 없고(disallow) 제약 조건에서 추론 가능한(deduce) 언어 구문(consructs)만 사용할 수 있습니다.
제네릭 및 리플렉션
1. CLR(공용 언어 런타임)에서는 런타임에 제네릭 형식 정보에 액세스할 수 있으므로 리플렉션(reflection)을 사용하면 제네릭이 아닌 형식에 대해서와 동일한 방식으로 제네릭 형식에 대한 정보를 얻을 수 있습니다.
2. 자세한 내용은 런타임의 제네릭을 참조하십시오.
3. .NET Framework 2.0에서는 제네릭 형식에 대한 런타임 정보를 사용할 수 있도록 여러 가지 새로운 멤버가 Type 클래스에 추가되었습니다.
4. 이러한 메서드와 속성의 사용 방법에 대한 자세한 내용은 해당 클래스에 대한 문서를 참조하십시오.
5. System.Reflection.Emit 네임스페이스에도 제네릭을 지원하는 새 멤버가 추가되었습니다.
6. 자세한 내용은 방법: 리플렉션 내보내기를 사용하여 제네릭 형식 정의를 참조하십시오.
7. 제네릭 리플렉션에 사용되는 용어에 대한 고정 조건(invariant conditions) 목록은 IsGenericType 속성 설명을 참조하십시오.
System.Type 멤버 이름 | 설명 |
|---|---|
형식이 제네릭인 경우 true를 반환합니다. | |
제네릭 형식 정의의 형식 매개 변수 또는 생성된 형식에 대해 제공되는 형식 인수를 나타내는 Type 개체의 배열을 반환합니다. | |
현재 생성된 형식의 내부(underlying) 제네릭 형식 정의를 반환합니다. | |
현재 제네릭 형식 매개 변수에 대한 제약 조건을 나타내는 Type 개체의 배열을 반환합니다. | |
특정 형식이 지정되지 않은 형식 매개 변수가 형식 또는 형식의 바깥쪽 형식이나 메서드에 포함되어 있는 경우 true를 반환합니다. | |
현재 제네릭 형식 매개 변수의 특수 제약 조건을 설명하는 GenericParameterAttributes 플래그의 조합을 가져옵니다. | |
형식 매개 변수를 나타내는 Type 개체에 대해 형식 매개 변수를 선언한 제네릭 메서드 정의 또는 제네릭 형식 정의의 형식 매개 변수 목록에서 형식 매개 변수가 차지하는 위치를 가져옵니다. | |
현재 Type이 제네릭 형식이나 메서드 정의의 형식 매개 변수를 표시하는지 여부를 나타내는 값을 가져옵니다. | |
현재 제네릭 형식 매개 변수를 정의한 제네릭 메서드를 반환합니다. 형식 매개 변수가 제네릭 메서드를 통해 정의되지 않은 경우 null을 반환합니다. | |
현재 제네릭 형식 정의의 형식 매개 변수에 대한 형식 배열의 요소를 대체하고, 생성된 결과 형식을 나타내는 Type 개체를 반환합니다. |
8. 또한 제네릭 메서드에 대한 런타임 정보를 사용할 수 있도록 새로운 멤버가 MethodInfo 클래스에 추가되었습니다.
9. 제네릭 메서드 리플렉션에 사용되는 용어에 대한 고정 조건의 목록을 보려면 IsGenericMethod 속성 설명(remarks)을 참조하십시오.
설명 | |
|---|---|
메서드가 제네릭인 경우 true를 반환합니다. | |
생성된 제네릭 메서드의 형식 인수나 제네릭 메서드 정의의 형식 매개 변수를 나타내는 Type 개체의 배열을 반환합니다. | |
현재 생성된 메서드의 내부 제네릭 메서드 정의를 반환합니다. | |
특정 형식이 지정되지 않은 형식 매개 변수가 메서드 또는 메서드의 바깥쪽 형식에 포함되어 있는 경우 true를 반환합니다. | |
현재 MethodInfo가 제네릭 메서드의 정의를 나타내는 경우 true를 반환합니다. | |
현재 제네릭 메서드 정의의 형식 매개 변수를 형식 배열의 요소로 대체하고, 생성된 메서드를 나타내는MethodInfo 개체를 반환합니다. |
런타임의 제네릭
1. 제네릭 형식 또는 메서드가 MSIL(Microsoft Intermediate Language)로 컴파일되면 자체적으로 형식 매개 변수를 갖는 것으로 식별하는(identify) 메타데이터가 포함됩니다.
2. 제네릭 형식의 MSIL이 사용되는 방식은 제공된 형식 매개 변수가 값 형식인지 참조 형식인지에 따라 다릅니다.
3. 값 형식을 매개 변수로 사용하여 제네릭 형식을 처음 생성할 경우 런타임에서는 제공된 매개 변수를 MSIL의 해당 위치에 대체하여 특수화된 제네릭 형식을 만듭니다.
4. 고유한 값 형식이 매개 변수로 사용될 때마다 특수화된 제네릭 형식이 만들어집니다.
5. 예를 들어 프로그램 코드에서 다음과 같이 정수로 구성된 스택을 선언한다고 가정합니다.
Stack<int> stack;6. 이 시점에서 런타임은 매개 변수를 정수로 적절히 대체하여 특수화된 버전의 Stack<T> 클래스를 생성합니다.
7. 이제부터 프로그램에서 정수 스택을 사용하여 런타임은 생성된 특수화 Stack<T> 클래스를 다시 사용합니다.
8. 다음 예제에서는 Stack<int> 코드의 단일 인스턴스를 공유하는 정수 스택의 두 인스턴스를 만듭니다.
Stack<int> stackOne = new Stack<int>(); Stack<int> stackTwo = new Stack<int>();
9. 그러나 코드의 다른 지점에서 long과 같이 값 형식이 다르거나, 사용자 정의된 구조체를 매개 변수로 사용하는 다른 Stack<T> 클래스를 만들었다고 가정(suppose)해 보십시오.
10. 이 경우 런타임에서는 제네릭 형식의 다른 버전을 생성하여 MSIL의 적절한 위치에 long을 대체합니다.
11. 특수화된 각 제네릭 클래스에는 내부적으로 값 형식이 포함되므로 변환은 더 이상 필요하지 않습니다.
12. 참조 형식에 대해서는 제네릭의 작동 방식이 조금(somewhat) 다릅니다.
13. 참조 형식을 사용하여 제네릭 형식이 처음 생성될 때 런타임에서는 MSIL의 매개 변수를 개체 참조(object references)로 대체하여 특수화된 제네릭 형식을 만듭니다.
14. 이후 참조 형식에 관게없이 참조 형식을 매개 변수로 사용하여 생성된 형식이 인스턴스화될 때마다 런타임에서는 이전에 만든 특수화된 버전의 제네릭 형식을 다시 사용합니다.
15. 이는 모든 참조의 크기가 동일하기 때문에 가능합니다.
16. 예를 들어 Customer 클래스와 Order 클래스라는 두 참조 형식이 있고 Customer 형식의 스택을 만들었다고 가정합니다.
class Customer { } class Order { }
Stack<Customer> customers;
17. 이 시점에서 런타임은 데이터를 저장하는 대신 이후에 채워질 개체 참조를 저장하는 특수화된 버전의 Stack<T> 클래스를 생성합니다.
18. 코드의 다음 줄에서 Order라는 다른 참조 형식의 스택을 만든다고 가정해 봅니다.
Stack<Order> orders = new Stack<Order>();19. 값 형식과는 달리, Order 형식에 대한 또 다른 특수화된 버전의 Stack<T> 클래스는 만들어지지 않습니다.
20. 대신 특수화된 버전의 Stack<T> 클래스 인스턴스가 만들어지고 orders 변수가 이 인스턴스를 참조하도록 설정됩니다.
21. 이후에 Customer 형식의 스택을 만드는 코드 줄이 나타난다고 가정해 봅니다.
customers = new Stack<Customer>();22. Order 형식을 사용하여 만든 Stack<T> 클래스를 사용한 경우와 마찬가지로 특수화된 Stack<T> 클래스의 다른 인스턴스가 생성됩니다.
23. 여기에(therein) 포함된 포인터는 Customer 형식과 크기가 같은 메모리 영역을 참조하도록 설정됩니다.
24. 참조 형식의 수는 프로그램마다 크게(widly) 다를 수(vary) 있으므로, 제네릭을 C# 방식으로 구현하면 컴파일러가 참조 형식의 제네릭 클래스에 대해 만드는 특수화된 클래스의 수가 1개로 줄어들어 코드가 매우 간결해집니다.
25. 뿐만 아니라(moreover) 값 형식 또는 참조 형식 매개 변수를 사용하여 제네릭 C# 클래스가 인스턴스화되면 런타임에 리플렉션을 통해 쿼리(query)할 수 있고 실제 형식과 형식 매개 변수를 모두 조사(ascertain)할 수 있습니다.
.NET Framework 클래스 라이브러리의 제네릭
1. .NET Framework 클래스 라이브러리 버전 2.0에서는 System.Collections.Generic이라는 새로운 네임스페이스를 제공하며, 이 네임스페이스에는 바로 사용할 수 있는(several ready-to-use) 제네릭 컬렉션 클래스 및 관련(associated) 인터페이스가 있습니다.
2. System 같은 기타 네임스페이스에서도 IComparable<T> 같은 새로운 제네릭 인터페이스를 제공합니다.
3. 이러한 클래스 및 인터페이스는 이전 버전의 .NET Framework에서 제공하던 제네릭이 아닌 컬렉션 클래스보다 효율적이고 형식 안전적입니다.
4. 사용자 지정 컬렉션 클래스를 디자인하고 구현가지 전에 .NET Framework 클래스 라이브러리에서 제공하는 클래스를 사용하거나 파생시킬 수 있는지 고려해 보십시오.
'프로그래밍 > C#' 카테고리의 다른 글
| 스레드 (0) | 2016.06.14 |
|---|---|
| 보간된 문자열(Interpolated strings) (0) | 2016.06.14 |
| C# 기타 (0) | 2016.06.10 |
| C# 컨텍스트 키워드 (0) | 2016.06.06 |
| C# 키워드 T~Z (0) | 2016.06.03 |
