컬렉션(Collection)

[獨先生]

컬렉션(Collection)

1. 컬렉션 전체 반복.

이 항목에서는 ArrayList를 만들고 사용하는 방법을 설명합니다.

여기에서 중요한 부분은 foreach 명령을 사용하여 목록을 반복하는 방법입니다.

ArrayList는 Collection 네임스페이스의 멤버이며 개체의 모든 형식을 자신의 요소로 사용할 수 있습니다.

또한 이 항목에서는 ArrayList 개체의 메서드 및 속성에 대해서도 설명합니다.

컬렉션은 배열과 매우 비슷하기 때문에 전체적으로 메서드 및 속성이 약간 더 많은 특별한 배열처럼 보일 수 있습니다.

이 예제에서는 ArrayList 컬렉션이 사용됩니다.

ArrayList는 모든 종류의 개체를 사용할 수 있지만 여러 컬렉션을 사용하는 경우에는 하나의 데이터 형식만 사용하는 것이 좋습니다.

검토할 첫 샘플 코드는 목록을 만드는 코드입니다.

한 줄로 간단하게 구성된 해당 코드에서 ArrayList의 생성자를 사용하여 이 컬렉션의 새 인스턴스를 만듭니다.

배열과 달리 ArrayList에 요소를 추가하면 목록에 사용되는 요소의 수가 자동으로 계산됩니다.

// declare the list, with a default capacity of 16

ArrayList al = new ArrayList();

ArrayList를 처음 만들면 요소가 하나도 없지만 최대 16개까지 요소를 추가할 수 있습니다.

17번째 요소를 추가하려고 하면 ArrayList는 해당 용량을 두 배로 늘립니다.

컬렉션의 용량을 이런 방식으로 늘리면 성능 히트가 발생할 수 있으므로 이 과정을 알고 있는 것이 좋습니다.

비록 성능에 사소한 영향을 주긴 하지만 컬렉션에 필요한 요소의 수를 알고 있으면 이에 맞게 용량을 미리 설정할 수 있습니다.

ArrayList의 기본 용량이 16 이상인지 확인하려면 ArrayList에 해당 용량과 요소의 수를 요청해야 합니다.

이렇게 하려면 목록에 있는 같은 이름의 속성에 액세스합니다.

// display the initial count, and capacity. 0 and 16

Console.WriteLine("The initial Count of our list is {0} " +

             and it's Capacity is {1}", al.Count, al.Capacity);

'  display the initial count, and capacity. 0 and 16

Console.WriteLine("The initial Count of our list is {0} " & _

      "and it's Capacity is {1}", al.Count, al.Capacity)

이 예제 코드를 직접 실행해 보면 결과를 확인할 수 있습니다.

현재 목록에 있는 요소 수보다 적거나 0 이하로는 용량 속성을 설정할 수 없습니다.

추가한 요소 수를 나타내는 Count는 읽기 전용이며 목록에 있는 실제 요소 수를 반영합니다.

목록에 항목을 추가하려면 모든 개체를 인수로 사용하고 해당 개체를 목록의 끝에 두는 Add 메서드를 사용합니다.

개체를 목록의 특정 위치에 두려면 Insert 메서드를 사용하여 새 개체를 둘 인덱스 및 삽입할 개체를 지정합니다.

목록에 요소를 추가할 수 있을 뿐만 아니라 목록에서 요소를 제거할 수도 있습니다.

이렇게 하려면 Remove 메서드를 사용하여 제거할 개체를 지정하거나(개체 참조 사용) RemoveAt 메서드를 사용하여 제거할 요소의 인덱스를 전달합니다.

다음 코드 예제에서는 개체를 추가하고 제거하는 방법을 설명합니다.

// declare an Int32 object, to add to the list

Int32 intTemp = 12;

// add elements to the list

al.Add("Apple");

al.Add(intTemp);

al.Add( new MyType() ); // a specific object you made.

Console.WriteLine("Removing the integer object...");

// remove a specific element, using the Remove method

al.Remove(intTemp);

Console.WriteLine("Removing the MyType object...");

// remove a specific object, using RemoveAt

al.RemoveAt(2); // remove the MyType. Remember, we just removed intTemp,

                           // which reduced all element indexes by 1.

Console.WriteLine("Inserting new object...");

// add an object at a specific location

al.Insert(0, "Grapes");

//display the count, and capacity

Console.WriteLine("After modifying our list, Count is {0} " +

                           "and Capacity is {1}", al.Count, al.Capacity);

위의 코드를 실행하면 목록에 문자열만 남습니다.

이렇게 되면 foreach 문을 사용하는 데 도움이 됩니다.

ArrayList를 만든 다음 목록의 각 요소를 차례로 가리키는 임시 개체를 만들어 해당 목록을 반복할 수 있습니다.

이 때 이 임시 '포인팅' 개체의 데이터 형식이 유용하게 사용됩니다.

이제 목록에 남은 문자열을 String 개체로 만들 수 있습니다.

목록에 문자열만 남아 있는지 여부가 확실하지 않으면 일반 Object를 사용합니다.

목록에 있는 요소를 출력한 다음에는 Clear 메서드를 사용하여 목록에 있는 모든 요소를 제거합니다.

다음 코드 예제에서는 이 개념에 대해 설명합니다.

// note that because we know only Strings are left in our list,

// we can use a String object in our foreach statement. If you

// are at all uncertain, use foreach (Object item in al)

foreach (String item in al) {

             Console.WriteLine(item);

}

// remove all elements from the list

al.Clear();

ArrayList에는 목록을 조작하는 데 도움이 되는 유용한 메서드 및 속성이 많이 포함되어 있습니다.

2. HashTable 컬렉션 사용.

이 예제에서는 해시 테이블을 만들고 사용하는 방법을 설명합니다.

해시 테이블은 키 값 조합으로 구성된 컬렉션이며 빠른 검색에 적합한 데이터 구조입니다.

키 또는 관련 값을 사용하여 해시 테이블을 검색할 수도 있지만 빠르게 검색하려면 일반적으로 키를 사용하여 검색하는 것이 좋습니다.

위에서 설명한 대로 해시 테이블은 컬렉션의 한 형식입니다.

해시 테이블을 채울 때 해당 테이블에 추가할 키와 키에 대한 값을 제공해야 합니다.

아래 예제에서는 사용하는 조합의 형식을 알 수 있도록 키에 대한 값으로 직원 ID 번호와 이름이 사용됩니다.

키는 숫자가 아닐 수 있으며 모든 개체를 사용할 수 있습니다.

해시 테이블의 장점은 다음과 같습니다.

키 값 쌍을 해시 테이블에 추가하면 해당 테이블이 키를 검색하고 키를 식별하는 번호인 해시 코드를 제공합니다.

추가하는 각 키에는 해시 코드가 있습니다.

이러한 해시 코드는 해시 테이블에 있는 엔트리를 쉽게 조직화할 수 있도록 데이터 구조에 저장됩니다.

이렇게 되면 나중에 해당 테이블에서 항목을 빠르게 찾을 수 있습니다.

이러한 해시 테이블을 사용하지 않으면 배열에서 검색 작업을 수행할 때 해당 배열의 모든 요소를 일일이 검색해야 합니다.

또한 요소의 위치를 알지 못하므로 해당 엔트리를 빠르게 검색할 수도 없습니다.

그러나 검색할 데이터 구조의 위치를 알고 있는 키를 제공하면 모든 요소의 하위 집합만 검색하면

되므로 해시 테이블을 사용하여 특정 키를 보다 빠르게 검색할 수 있습니다.

이러한 빠른 검색 메커니즘은 키를 사용하여 검색하는 경우에만 가능합니다.

값을 사용하여 검색할 수도 있지만 키를 사용하여 검색하는 경우보다는 늦습니다.

따라서 가능하면 키 검색을 수행하는 것이 좋습니다.

해시 테이블에 요소를 추가하려면 Add 메서드를 호출하고 추가할 키 값 쌍을 전달합니다.

// Here we'll create a hashtable of employee numbers and employee names

Hashtable table = new Hashtable();

// now, we will add elements to the hashtable, as key-value pairs

table.Add(5123, "Jay");

table.Add(1829, "Tom");

table.Add(2882, "Matt");

해시 테이블을 채운 다음 키와 값을 모두 사용하여 해당 테이블에 있는 요소를 검색할 수 있습니다.

실제 예제에서는 사용자가 값 또는 키를 사용하여 검색할 수 있도록 합니다.

이 두 검색 작업이 약간 다를 수 있으나 개념은 같습니다.

// SEARCHING BY VALUE. Use the method ContainsValue

String valueToFind = "Jay";

if (table.ContainsValue(valueToFind)) {

             Console.WriteLine("Found {0} in the list.", valueToFind );

}

// SEARCHING BY KEY. Use the method Contains

int keyToFind = 5123;

if (table.Contains(keyToFind)) {

             Console.WriteLine("Found {0} in the list.", keyToFind);

}

 

단순한 검색 작업 이외에도 제거할 요소를 식별하는 키를 Remove 메서드에 전달한 다음

이 메서드를 사용하여 해시 테이블에서 엔트리를 제거하거나, 해시 테이블의 인스턴스 내에서

Keys 컬렉션이나 Values 컬렉션을 사용하여 해시 테이블을 열거할 수도 있습니다.

// using the Remove method to delete a particular item...

table.Remove(5123);

// enumerating over the collection with a foreach statement

// Note the alternate of iterating through by value is demonstrated

// foreach (Object o in table.Values) {

foreach (Object o in table.Keys) {

             Console.WriteLine(o.ToString());

}

지금까지 해시 테이블의 기본적인 사용 방법을 설명했습니다.

해시 테이블에 엔트리를 채웠으면 해시 테이블을 반복하는 방법을 알아야 합니다.

다음 코드에서는 foreach 문을 사용하여 목록 사이를 이동하고, 각 키 값 조합을 화면에 출력하는 방법을 설명합니다.

이렇게 하려면 각 요소의 Key 및 Value 속성을 참조해야 합니다.

다음 샘플에서는 컬렉션을 반복하는 방법을 설명합니다.

// if you are wondering where DictionaryEntry comes from, it is

// the generic object type of each element in the hashtable

foreach (DictionaryEntry d in table) {

             // use the Key and Value properties

             Console.WriteLine ("{0}\t{1}", d.Key, d.Value);

}

3. 사용할 컬렉션 선택.

이 예제에서는 Queue, SortedList 및 Hashtable 컬렉션의 저장 프로시저 및 기능에 대해 설명합니다.

이 예제의 기본 목적은 개발자들이 여러 가지 컬렉션 형식의 기능을 이해함으로써 자신의 필요에 맞는 컬렉션을 선택할 수 있도록 하는 것입니다.

처음에는 자신의 필요에 가장 적합한 컬렉션을 결정하기가 어렵다고 생각될 수 있습니다.

하지만 경험을 쌓으면 점차 사용할 수 있는 여러 가지 컬렉션에 대해 잘 알게 되고 나중에는

ICollection이나 IList를 확장함으로써 사용자 고유의 컬렉션을 사용자 지정할 수도 있게 될 것입니다.

여기에서 다룰 세 가지 컬렉션은 Queue, SortList, Hashtable입니다.

Queue는 '선입선출' 원칙에 따라 사용되는 정렬되지 않는 컬렉션입니다.

l        엔트리를 입력 순서에 따라 저장해야 할 때 Queue를 사용합니다.

l        Queue의 끝에 요소를 쉽게 추가하려면 Queue를 사용합니다.

Enqueue 메서드에서 이 기능을 제공합니다.

l        Queue에서 최상위 항목을 쉽게 읽고 제거하려면 Queue를 사용합니다. 이 기능은 Dequeue 메서드에서 제공합니다.

요소를 제거하지는 않고 해당 요소가 무엇인지 확인만 하려는 경우에는 Peek 메서드를 사용합니다.

l        빠른 검색 기능이 필요한 경우 Queue를 사용하지 않습니다.

Queue의 검색 기능은 빠르지 않기 때문입니다.

l        사용자나 최종 사용자가 지정한 특정 요소를 제거해야 하는 경우 Queue를 사용하지 않습니다.

l        요소의 순서를 바꾸거나 정렬해야 하는 경우 Queue를 사용하지 않습니다.

SortedList는 문자 그대로 정렬된 항목의 컬렉션입니다.

SortedList는 키-값 쌍으로 구성되며 정렬은 값이 아니라 키를 기준으로 합니다.

l        많은 작업을 할 필요 없이 항목을 정렬하려면 SortedList를 사용합니다.

l        요소가 정렬되는 방식(요소가 비교되는 방식)을 제어하려면 SortedList를 사용합니다.

l        SortedList의 빠른 키 검색 기능을 사용하려면 SortedList를 사용합니다.

l        Remove 또는 RemoveAt 메서드를 사용하여 특정 요소를 제거하려면 SortedList를 사용합니다.

l        특정 위치에 요소를 삽입해야 하는 경우에는 SortedList를 사용하지 않습니다.

삽입한 위치에 상관 없이 해당 요소가 정렬되기 때문입니다.

l        동일한 값을 가지는 여러 개의 키를 저장하려는 경우 SortedList를 사용하지 않습니다.

       SortedList 내의 모든 키는 고유해야 하기 때문입니다.

l        빠른 검색(특히 값을 기준으로 하는 경우)이 가장 필요한 기능일 경우에는 Hashtable 등의 다른 컬렉션을 사용하는 것이 좋습니다.

Hashtable도 키-값 쌍을 필요로 하는 요소 집합입니다.

Hashtable에서는 사용자에게 알려지지 않는 내부 알고리즘을 사용하여 키-값 쌍을 정렬합니다.

키-값 쌍은 값을 매우 빠르게 검색할 수 있도록 '버킷'에 저장됩니다.

l        검색이 우선적으로 필요한 기능일 경우 Hashtable을 사용합니다.

Hashtable에서는 키를 기준으로 검색할 때 매우 빠른 검색 메커니즘을 제공하며

값을 기준으로 검색할 때 매우 뛰어난 검색 기능을 제공합니다.

l        Remove 메서드를 사용하여 특정 요소를 제거하려면 Hashtable을 사용합니다.

l        요소가 저장되는 순서에 상관이 없는 경우 Hashtable을 사용합니다.

l        요소를 특정 순서로 저장해야 하는 경우에는 Hashtable을 사용하지 않습니다.

이 경우에는 Hashtable에서 요소를 정렬하는 방식에 의존할 수 없습니다.

l        특정 위치에 요소를 삽입해야 하는 경우에는 Hashtable을 사용하지 않습니다.

l        동일한 값을 가지는 여러 개의 키를 저장하려는 경우 SortedList를 사용하지 않습니다.

       SortedList 내의 모든 키는 고유해야 하기 때문입니다.

l        동일한 값을 가지는 여러 개의 키를 저장하려는 경우 Hashtable을 사용하지 않습니다.

       Hashtable 내의 모든 키는 고유해야 하기 때문입니다.

다음 단계에서는 각 컬렉션의 선언 방법과 각 컬렉션에 동일한 정보를 채우는 방법에 대해 살펴보겠습니다.

Hashtable과 SortedList는 모두 키-값 조합을 필요로 하지만 이 예제에서는 키와 값 모두에 대해 동일한 엔트리를 사용할 것입니다.

즉, 성 컬렉션을 만들고 특정 쌍의 키와 값 모두에 동일한 성을 사용할 것입니다.

예를 들어, 하나의 쌍은 "Smith"-"Smith"가 됩니다.

// don't forget to include those 'using' statements

using System;

using System.Collections;

// ... class and method declarations...

// the declaration for an array of information

String names = new String[] {"Simpson", "Bristow", "Walls",

                           "Gilligan","Davidson","Laurence",

                           "Jackson","Singh","O'Connor","Moynagh"};

// the declarations for each of the three collections

Queue q = new Queue();

SortedList sl = new SortedList();

Hashtable ht = new Hashtable();

// we use a foreach statement to populate our collections

foreach (String s in names)

{

             // to add an element to the queue, use Enqueue

             // A queue only receives the value you want to add

             q.Enqueue(s);

             // Use Add of SortedList/Hashtable to add elements

             // Note that you must add key-value pairs

             sl.Add(s, s);

             ht.Add(s, s);

}

컬렉션에서 항목을 제거할 수도 있습니다.

하지만 사용되는 메서드는 해당 컬렉션에 따라 다릅니다.

많은 컬렉션에서는 지정된 요소를 제거하는 Remove 메서드를 지원합니다.

Hashtable과 SortedList 모두 사용자가 지정하는 요소를 제거하기 위해 이 메서드를 지원합니다.

많은 컬렉션에서는 RemoveAt 메서드도 지원하지만 여기에서 다루는 세 컬렉션 중에서는 SortedList만 RemoveAt 메서드를 지원합니다.

RemoveAt 메서드를 사용하는 경우에는 제거할 요소의 인덱스를 지정해야 하므로 Queue나

Hashtable의 경우에는 적합하지 않으며, 따라서 이 두 컬렉션은 이 메서드를 지원하지 않는 것입니다.

Queue에서 요소를 제거하는 것은 Queue의 최상위 요소에 대해서만 수행될 수 있으므로 특별한 경우입니다.

따라서 이 경우에는 다음 샘플에서와 같이 Dequeue 메서드를 사용하여 요소를 제거합니다.

//to remove an element with a specific key, use the Remove method

//where the concept of a key  is invalid, specify the object to remove

sl.Remove(keyValue); // removes the arbitrary keyvalue

ht.Remove(keyValue); // removes the arbitrary keyvalue

//to remove an element at a specific index, use the RemoveAt method

//This does not make sense for collections such as a Hashtable/Queue

sl.RemoveAt(indexValue); //removes the specified index

//A Queue does not have the concept of an arbitrary remove

//Use Dequeue to read, AND remove the top element off the Queue

q.Dequeue(); //remove the top value

컬렉션을 만든 다음에는 단순한 반복 문을 사용하여 값을 인쇄하는 방법으로 해당 컬렉션 내의 정보를 볼 수 있습니다.

여기에서 그 결과를 보여 주기는 어려우므로 사용자가 출력을 테스트해야 합니다.

Queue에서는 항목 순서를 변경하지 않고, SortedList에서는 항목을 사전순으로 정렬하며, Hashtable에서는

순서를 변경하지만 그 변경 방식을 사용자는 알 수 없습니다.

즉, Hashtable에서는 고유의 정렬 메커니즘을 사용합니다.

Console.WriteLine("The Entries In The Queue");

foreach (String s in q) {

             Console.WriteLine(s);

}

// note that we have to parse the Values of the SortedList, rather than

// the actual SortedList itself

Console.WriteLine("The Entries In The SortedList");

foreach (String s in sl.Values) {

             Console.WriteLine(s);

}

// note that we have to parse the Values of the Hashtable, rather than

// the actual Hashtable itself

Console.WriteLine("The Entries In The SortedList");

foreach (String s in ht.Values) {

             Console.WriteLine(s);

}

지금까지 각 컬렉션의 구성 방식과 값 검색 방법을 보여 주는 코드를 살펴보았습니다. 

하지만 각각의 컬렉션 내에서 값을 검색하는 방법에 대해서도 살펴보아야 합니다.

다음 코드 예제에서는 각 컬렉션 내에서 값을 찾는 데 필요한 명령을 보여 줍니다.

키 및 값을 기준으로 검색하는 메서드는 SortedList와 Hashtable 모두에 대해 표시됩니다.

Hashtable은 검색에 매우 유용하며, SortedList는 특히 키를 기준으로 검색할 때 매우 유용합니다.

Queue에서도 검색 기능을 제공하지만 Queue의 실제 용도는 검색이 아니기 때문에 검색 메커니즘이 보다 느립니다.

// use these lines of code to retrieve the time before the search

Int64 startTime;

startTime = Environment.TickCount;

// use these lines of code to retrieve the time, after the search.

// You can subtract this value from the above, to get a duration.

Int64 endTime;

endTime = Environment.TickCount;

// use Contains to search a Queue for an entry,

// or a Hashtable/SortedList for a KEY

// Contains returns a boolean, indicating if value/key was found

bool foundValue;

Dim valToFind as Int64

foundValue = q.Contains(valToFind);

foundValue = sl.Contains(valToFind);

foundValue = ht.Contains(valToFind);

// use ContainsValue to search a SortedList/Hashtable for a VALUE

foundValue = sl.ContainsValue(valToFind);

foundValue = ht.ContainsValue(valToFind);

 요약

 Collections 네임스페이스 내에는 다양한 기능을 제공하는 컬렉션이 많이 있습니다.

사용할 수 있는 여러 가지 컬렉션에 대해 잘 알면 각 상황에 따라 어떤 컬렉션을 사용하는 것이 좋은지 알 수 있으므로 유용합니다.

4. 컬렉션 구현.

이 예제에서는 ICollection 인터페이스에서 파생된 클래스를 만드는 방법에 대해 설명합니다.

collection 네임스페이스에는 고유한 속성 및 메서드 집합이 있는 여러 인터페이스가 있습니다.

이러한 컬렉션을 구현하는 기본 방법을 알면 일반 개체가 아닌 특정 데이터 형식을 반환하는 강력한 형식의 컬렉션을 빌드할 수 있습니다.

ICollection을 구현하는 첫째 단계는 클래스에 대한 선언에 인터페이스를 구현하는 것입니다.

이 때 인터페이스를 지원할 수 있도록 해당 인터페이스에서 사용될 메서드나 속성을 모두 구현해야 합니다.

모든 메서드에서 작업을 수행할 필요는 없지만, 특정 인터페이스를 구현한 사실을 알고 있는 사용자는

해당 기능을 사용할 것으로 예상하기 때문에 특정 메서드에서 아무 작업도 수행하지 않는 경우 이를 알려야 합니다.

이 샘플 코드의 CopyTo에서는 아무 작업도 수행하지 않지만 예외를 throw하여 사용자에게 이를 알려야 합니다.

여기에 표시된 나머지 메서드는 ICollection을 지원하기 위해 구현해야 하는 메서드입니다.

using System.Collections;

class EmployeeCollection : ICollection {

             // The methods you have to support...

             public virtual void CopyTo(Array array, int index) {

                           // you would have to make it very clear in documentation that users cannot

                           // use this functionality. Ultimately, you need to support all implemented methods

                           throw new Exception("This method is not supported in this implementation");

             }

             public virtual int Count { //this will be how we track the size of our collection

                           get {

                                        return _size;

                           }

             }

             // these two properties are required to support synchronization

             // only the signatures are included here...

             // Note that they are read-only, so you only have to define a Get procedure

             public virtual Object SyncRoot {}

             public virtual bool IsSynchronized {}

             // this method is what allows your users to parse your collection using foreach

             public virtual IEnumerator GetEnumerator() {

                           return new EmployeeEnumerator(this);

             }

}

새 컬렉션의 기본 사항에 대해 알았으므로 컬렉션 자체의 내부 메커니즘을 설계하는 방법을 결정해야 합니다.

이 때 메서드를 통해 노출되는 컬렉션 멤버의 배열을 사용하는 것이 좋습니다.

이 예제에서는 변수뿐만 아니라 Employee 배열을 사용하여 사용자가 배열에 넣은 요소의 현재 크기

또는 수와 배열의 실제 크기(용량)를 추적합니다.

또한 지원할 생성자가 있는 경우 이를 결정해야 합니다.

이 시나리오에서는 요소를 포함하고 있지는 않지만 컬렉션의 초기 용량을 16으로 설정하는 0 인수 생성자를 지원합니다.

// the internal deployment of the collection.

// Note that you have strongly typed it here to an Employee

private Employee[] _array;

private int _size;

private int _capacity;       // Last valid element in the collection

// the only constructor supported in this example.

// Often you would provide many constructors

public EmployeeCollection() {

             _array = new Employee[16];

             _capacity = 16;

             _size = 0;

}

요소를 저장하는 데 사용되는 변수에 대해 알아 보았으므로 이제 첫 샘플이 GetEnumerator 메서드에서 참조한 클래스를 만들어야 합니다.

이 클래스는 Reset 및 Current 속성과 MoveNext 메서드를 지원해야 하는 IEnumerator를 구현합니다.

이러한 메서드에 적용되는 표준 단계가 있지만 이 샘플에서는 MoveNext만 살펴봅니다.

Reset 및 Current의 서명은 포함되지만 코드는 포함되지 않습니다.

MoveNext 메서드는 사용자가 foreach(For Each) 문을 반복할 때마다 호출됩니다.

MoveNext 메서드에서는 컬렉션의 현재 요소에 포인터를 유지하고, 해당 메서드가 호출되면 다음 요소로 포인터가 이동합니다.

Current는 요청될 때 요소를 반환합니다.

이 예제에서는 현재 요소의 인덱스뿐만 아니라 컬렉션의 내부 표시(_ec)가 유지됩니다.

또한 이러한 모든 메서드는 자동으로 호출되므로 사용자는 해당 메서드에 foreach를 사용하는 방법만 알면 됩니다.

//note that you implement IEnumerator

class EmployeeEnumerator : IEnumerator {

             private EmployeeCollection _ec;   // a copy of our collection

             private int _index;               // track the index of the current element

             private Object currentElement;    // the current element, returned by Current

             // our implementation of MoveNext

             public virtual bool MoveNext() {

                           if (_index < 0) {  // check to see if you can take this action. False indicates

                                                        // that the MoveNext did not work

                                        currentElement = _ec._array;

                                        return false;

                           }

                           currentElement = _ec.GetElement(_index); // moved so reset current element

                           _index++;                                // increase our index appropriately

                           //once at the end of our collection, ensure the user cannot MoveNext

                           if (_index == _ec._size) {

                                        _index = -1;

                           }

                           return true;

             }

             // these are the signatures for the other methods you need to use. See the

             // major sample for the code we placed in these methods

             public virtual void Reset() {}                 // resets the enumerator

             // do exception checking, and if all is OK, return the current element

             public virtual Object Current {}

}

다음 단계는 컬렉션에서 제공할 기능을 결정하는 것입니다.

이 기능은 컬렉션에 추가할 메서드를 통해 노출됩니다.

사용자의 요구에 보다 근접한 기능을 제공할 수도 있으므로 IList 등과 같은 구현 가능한 다른 인터페이스를 고려해야 합니다.

여기서 선택한 ICollection은 예제용입니다.

다음 샘플 코드에서는 GetEmployee 및 Clear 메서드에 대해 설명합니다.

// routine to return an employee, specified by id

public Employee GetEmployee(int id) {

             if (_size == 0) {

                           throw new InvalidOperationException

                                                     ("You cannot get an employee when the collection is empty.");

             }

             foreach (Employee e in _array) { // loop through the array, searching for the employee

                           if ( id == e.ID) {

                                        return e; // return the element found!

                           }

             }

             return null;   // if the employee wasn't found, return null. Note that your user

                           // documentation would explain that this is what you do in this scenario

}

public void Clear() { //clear the array

             if (_capacity > 0) {

                           Array.Clear(_array, 0, _size); //clear the array

             }

             else {

                           Array.Clear(_array, 0, _array.Length);

                           Array.Clear(_array, 0, _capacity);

             }

             _capacity = 0; //reset the capacity, and size of the array

             _size = 0;

}

 사용자가 컬렉션을 사용하려는 경우, GetEnumerator를 통해 열거자가 지원되므로 foreach(For Each) 문을 사용할 수 있습니다. 

사용자는 컬렉션에서 수행할 수 있는 작업과 수행할 수 없는 작업에 대해 알아야 하며,

이를 알지 못하는 경우 예상한 대로 메서드를 호출해야 합니다.

다음 코드 예제에서는 사용자가 컬렉션을 사용하는 방법을 설명합니다.

// declare the collection, using the default constructor provided

// it is a good idea to include many overloaded constructors, for all the items that can be set

EmployeeCollection ec = new EmployeeCollection();

Console.WriteLine("Adding elements to the EmployeeCollection");

ec.AddEmployee( 1234, "John" );

ec.AddEmployee( 5678, "Lisa" );

ec.AddEmployee( 3283, "Max" );

ec.AddEmployee( 1928, "Regina" );

ec.AddEmployee( 4019, "Clarence" );

foreach(Employee e in ec) // iterate over the collection using foreach

             Console.WriteLine(ec.GetEmployee(e.ID));

Console.WriteLine("Retrieving the employee with id 4019...");

Console.WriteLine(ec.GetEmployee(4019).ToString());

Console.WriteLine("Clearing the collection...");

ec.Clear();

Console.WriteLine("Setting the name of existing employee with id 5678...");

ec.SetName(5678, "Katherine");

5. 컬렉션 복제.

이 예제에서는 ArrayList를 복제하는 방법을 설명합니다.

복제란 ArrayList의 '부분' 복사본을 만드는 것으로, 개체 자체를 실제로 복사하는 것이 아니라

원본 목록에 있는 모든 개체 참조가 대상 목록에 의해 복사되는 것을 의미합니다.

복제된 목록을 수정하는 경우 목록에 개체 참조가 있으면 원본 목록도 수정됩니다.

ArrayList는 개체의 일반 컬렉션입니다.

ArrayList를 만들 때 값이나 참조 형식 개체를 컬렉션에 둘 수 있습니다.

여기에 포함된 예제는 Name과 ID로 구성된 참조 형식인 Employee와 변경할 수 없는 String입니다.

첫 단계에서는 ArrayList를 만드는 데 필요한 코드를 검토하고 여기에 요소를 추가합니다.

//don't forget you are using statements, at the top of your code...

using System;

using System.Collections;

//... class and method declarations...

ArrayList al = new ArrayList();

ArrayList.Add( new Employee(7182, "Laurie Davies") ); //add an employee object to the list

ArrayList.Add( "Test String 1" );                     //add a string to the list

이제 목록이 채워지면 이 목록을 복제할 수 있습니다.

복제를 종종 원본의 '부분 복사본'이라고 합니다.

즉, 문자열이나 정수 같은 참조할 수 없는 데이터 형식을 한 목록에서 다른 목록으로 실제로 복사한다는 것을 뜻합니다.

반면에 원본 목록에 개체 참조가 있으면 참조도 복사되어 복제된 목록에 처음 목록의 개체에 대한 동일한 참조가 포함됩니다.

이렇게 하면 모든 요소를 직접 실제로 복사하는 것보다 훨씬 빠르게 한 목록을 다른 목록으로 복사할 수 있습니다.

다음 샘플에서는 목록을 복제하는 방법을 설명합니다.

복사본에 있는 개체 참조를 수정하면 원본도 변경되지만, 참조할 수 없는 항목은 수정해도 원본이 변경되지 않습니다.

//this line creates a new list, cloned from the list you made in the previous example

ArrayList newList = (ArrayList)al.Clone();

//set the Name property of the Employee object in the copied list to another value

((Employee)newList[0]).Name = "Mary Smith";

//set the String element in the copied list to another value

newList[1] = "Modified String 1";

//print the values of the original list. The employee name has changed,

//while the String has remained the same

foreach(Object o in newList) {

             Console.WriteLine(o.ToString());

}

이제 ArrayList를 복제할 때 발생하는 사항에 대해 확인하였으므로 전체 컬렉션을 실제로 복사하는 방법을 설명합니다.

Array 개체와 마찬가지로 다른 컬렉션에서도 Clone을 지원합니다.

일반적으로 수행할 수 있는 대부분의 복사 작업은 컬렉션을 복사하는 가장 빠른 프로세스이며

프로그래밍할 대부분의 인스턴스를 지원하므로 Clone 프로세스와 거의 비슷합니다.

그러나 목록을 '전체 복사'해야 할 경우도 있습니다.

다음 코드 예제에서는 이전 목록에서 새 목록을 만드는 방법을 설명합니다.

//declare your new list

ArrayList nl = new ArrayList();

//loop through the entries in the original ArrayList

for (int i=0;i < al.Count;i++) {

             if ((al[i]).GetType() == typeof(Employee)) {

                           //add the copied object reference to the new list, as a new Object

                           nl.Add(new Employee(((Employee)al[i]).ID, ((Employee)al[i]).Name));

             }

             else {

                           //non-referential entries can be added as they are...

                           nl.Add(al[i]);

             }

}

//use the same code as in the previous sample to modify elements in your new list,

//and see if the original list is affected. In this scenario, the original will not be changed

//by modifying EITHER types of elements

부분 및 전체 복사의 개념에 대해 잘 알고 있어야 하며, 이 개념은 결국 개체 참조 일치와 아주 비슷합니다.

기본적으로 복제는 개체 참조를 단순히 복사하는 것이지 상당한 시간이 소요되는 프로세스인 컬렉션에 있는 모든 개체를 다시 만드는 것은 아닙니다.