MSDN Library
콘텐츠의 테이블 축소
콘텐츠의 테이블 확장
정보
요청한 주제가 아래에 표시됩니다. 그러나 이 주제는 이 라이브러리에 포함되지 않습니다.

IDictionary 인터페이스

2013-12-13

키/값 쌍의 제네릭이 아닌 컬렉션을 나타냅니다.

Namespace:  System.Collections
어셈블리:  mscorlib(mscorlib.dll)

public interface IDictionary : ICollection, 
	IEnumerable

IDictionary 형식에서는 다음과 같은 멤버를 노출합니다.

  이름설명
Public 속성CountICollection에 포함된 요소 수를 가져옵니다. (ICollection에서 상속됨)
Public 속성IsFixedSizeIDictionary 개체의 크기가 고정되어 있는지 여부를 나타내는 값을 가져옵니다.
Public 속성IsReadOnlyIDictionary 개체가 읽기 전용인지 여부를 나타내는 값을 가져옵니다.
Public 속성IsSynchronizedICollection에 대한 액세스가 동기화되어 스레드로부터 안전하게 보호되는지 여부를 나타내는 값을 가져옵니다. (ICollection에서 상속됨)
Public 속성Item지정된 키가 있는 요소를 가져오거나 설정합니다.
Public 속성KeysIDictionary 개체의 키를 포함하는 ICollection 개체를 가져옵니다.
Public 속성SyncRootICollection에 대한 액세스를 동기화하는 데 사용할 수 있는 개체를 가져옵니다. (ICollection에서 상속됨)
Public 속성ValuesIDictionary 개체의 값이 포함된 ICollection 개체를 가져옵니다.
맨 위

  이름설명
Public 메서드Add제공된 키와 값을 가진 요소를 IDictionary 개체에 추가합니다.
Public 메서드ClearIDictionary 개체에서 요소를 모두 제거합니다.
Public 메서드ContainsIDictionary 개체에 지정된 키를 가진 요소가 포함되어 있는지 여부를 확인합니다.
Public 메서드CopyTo특정 Array 인덱스부터 시작하여 ICollection의 요소를 Array에 복사합니다. (ICollection에서 상속됨)
Public 메서드GetEnumerator()IDictionary 개체에 대한 IDictionaryEnumerator 개체를 반환합니다.
Public 메서드GetEnumerator()컬렉션 전체에서 반복되는 열거자를 반환합니다. (IEnumerable에서 상속됨)
Public 메서드RemoveIDictionary 개체에서 지정된 키를 가진 요소를 제거합니다.
맨 위

  이름설명
Public 확장 메서드AsQueryableIEnumerableIQueryable로 변환합니다. (Queryable에서 정의됨)
Public 확장 메서드Cast<TResult>IEnumerable의 요소를 지정된 형식으로 변환합니다. (Enumerable에서 정의됨)
Public 확장 메서드OfType<TResult>지정된 형식에 따라 IEnumerable의 요소를 필터링합니다. (Enumerable에서 정의됨)
맨 위

IDictionary 인터페이스는 키/값 쌍의 제네릭이 아닌 컬렉션에 대한 기본 인터페이스입니다. 이 인터페이스의 제네릭 버전은 System.Collections.Generic.IDictionary<TKey, TValue>를 참조하세요.

각 요소는 DictionaryEntry 개체에 저장된 키/값 쌍입니다.

각 쌍의 키는 고유해야 합니다. 키가 null일 수 있는지 여부에 따라 다른 구현이 가능합니다. 값은 null일 수 있으며 고유하지 않아도 됩니다. IDictionary 인터페이스에서는 포함되어 있는 키와 값을 열거할 수 있지만 특정 정렬 순서를 따르지는 않습니다.

IDictionary는 읽기 전용, 고정 크기, 가변 크기의 세 가지 카테고리로 구현됩니다. 읽기 전용 IDictionary 개체는 수정할 수 없습니다. 고정 크기 IDictionary 개체에서는 요소를 추가하거나 제거할 수 없지만 기존 요소를 수정할 수는 있습니다. 가변 크기 IDictionary 개체에서는 요소를 추가, 제거 및 수정할 수 있습니다.

C# 언어의 foreach 문(Visual Basic에서는 for each)은 컬렉션에 있는 각 요소의 형식을 필요로 합니다. IDictionary 개체의 각 요소가 키/값 쌍이므로 요소 형식은 키의 형식도, 값의 형식도 아닙니다. 대신 요소 형식은 DictionaryEntry입니다. 예를 들면 다음과 같습니다.

foreach (DictionaryEntry de in CastMembers) {...}

foreach 문은 열거자에 대한 래퍼로, 컬렉션에서 읽는 것만 허용하고 컬렉션에 쓰는 것은 허용하지 않습니다.

구현자 참고 사항

구현 클래스에는 키를 비교할 수단이 있어야 합니다.

다음 코드 예제에서는 IDictionary 인터페이스를 구현하는 단순 사전 클래스를 정의하는 방법을 보여 줍니다.

참고참고:

이 예제를 실행하려면 Windows Phone용 정적 TextBlock 컨트롤이 있는 예제 빌드를 참조하세요.


using System;
using System.Collections;

// This class implements a simple dictionary using an array of DictionaryEntry objects (key/value pairs).
public class SimpleDictionary : IDictionary
{
   // The array of items
   private DictionaryEntry[] items;
   private Int32 ItemsInUse = 0;

   // Construct the SimpleDictionary with the desired number of items.
   // The number of items cannot change for the life time of this SimpleDictionary.
   public SimpleDictionary(Int32 numItems)
   {
      items = new DictionaryEntry[numItems];
   }


   #region IDictionary Members
   public bool IsReadOnly { get { return false; } }
   public bool Contains(object key)
   {
      Int32 index;
      return TryGetIndexOfKey(key, out index);
   }
   public bool IsFixedSize { get { return false; } }
   public void Remove(object key)
   {
      if (key == null) throw new ArgumentNullException("key");
      // Try to find the key in the DictionaryEntry array
      Int32 index;
      if (TryGetIndexOfKey(key, out index))
      {
         // If the key is found, slide all the items up.
         Array.Copy(items, index + 1, items, index, ItemsInUse - index - 1);
         ItemsInUse--;
      }
      else
      {
         // If the key is not in the dictionary, just return. 
      }
   }
   public void Clear() { ItemsInUse = 0; }
   public void Add(object key, object value)
   {
      // Add the new key/value pair even if this key already exists in the dictionary.
      if (ItemsInUse == items.Length)
         throw new InvalidOperationException("The dictionary cannot hold any more items.");
      items[ItemsInUse++] = new DictionaryEntry(key, value);
   }
   public ICollection Keys
   {
      get
      {
         // Return an array where each item is a key.
         Object[] keys = new Object[ItemsInUse];
         for (Int32 n = 0; n < ItemsInUse; n++)
            keys[n] = items[n].Key;
         return keys;
      }
   }
   public ICollection Values
   {
      get
      {
         // Return an array where each item is a value.
         Object[] values = new Object[ItemsInUse];
         for (Int32 n = 0; n < ItemsInUse; n++)
            values[n] = items[n].Value;
         return values;
      }
   }
   public object this[object key]
   {
      get
      {
         // If this key is in the dictionary, return its value.
         Int32 index;
         if (TryGetIndexOfKey(key, out index))
         {
            // The key was found; return its value.
            return items[index].Value;
         }
         else
         {
            // The key was not found; return null.
            return null;
         }
      }

      set
      {
         // If this key is in the dictionary, change its value. 
         Int32 index;
         if (TryGetIndexOfKey(key, out index))
         {
            // The key was found; change its value.
            items[index].Value = value;
         }
         else
         {
            // This key is not in the dictionary; add this key/value pair.
            Add(key, value);
         }
      }
   }
   private Boolean TryGetIndexOfKey(Object key, out Int32 index)
   {
      for (index = 0; index < ItemsInUse; index++)
      {
         // If the key is found, return true (the index is also returned).
         if (items[index].Key.Equals(key)) return true;
      }

      // Key not found, return false (index should be ignored by the caller).
      return false;
   }
   private class SimpleDictionaryEnumerator : IDictionaryEnumerator
   {
      // A copy of the SimpleDictionary object's key/value pairs.
      DictionaryEntry[] items;
      Int32 index = -1;

      public SimpleDictionaryEnumerator(SimpleDictionary sd)
      {
         // Make a copy of the dictionary entries currently in the SimpleDictionary object.
         items = new DictionaryEntry[sd.Count];
         Array.Copy(sd.items, 0, items, 0, sd.Count);
      }

      // Return the current item.
      public Object Current { get { ValidateIndex(); return items[index]; } }

      // Return the current dictionary entry.
      public DictionaryEntry Entry
      {
         get { return (DictionaryEntry)Current; }
      }

      // Return the key of the current item.
      public Object Key { get { ValidateIndex(); return items[index].Key; } }

      // Return the value of the current item.
      public Object Value { get { ValidateIndex(); return items[index].Value; } }

      // Advance to the next item.
      public Boolean MoveNext()
      {
         if (index < items.Length - 1) { index++; return true; }
         return false;
      }

      // Validate the enumeration index and throw an exception if the index is out of range.
      private void ValidateIndex()
      {
         if (index < 0 || index >= items.Length)
            throw new InvalidOperationException("Enumerator is before or after the collection.");
      }

      // Reset the index to restart the enumeration.
      public void Reset()
      {
         index = -1;
      }
   }
   public IDictionaryEnumerator GetEnumerator()
   {
      // Construct and return an enumerator.
      return new SimpleDictionaryEnumerator(this);
   }
   #endregion

   #region ICollection Members
   public bool IsSynchronized { get { return false; } }
   public object SyncRoot { get { throw new NotImplementedException(); } }
   public int Count { get { return ItemsInUse; } }
   public void CopyTo(Array array, int index) { throw new NotImplementedException(); }
   #endregion

   #region IEnumerable Members
   IEnumerator IEnumerable.GetEnumerator()
   {
      // Construct and return an enumerator.
      return ((IDictionary)this).GetEnumerator();
   }
   #endregion
}

public sealed class Example
{
   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      // Create a dictionary that contains no more than three entries.
      IDictionary d = new SimpleDictionary(3);

      // Add three people and their ages to the dictionary.
      d.Add("Jeff", 40);
      d.Add("Kristin", 34);
      d.Add("Aidan", 1);

      outputBlock.Text += String.Format("Number of elements in dictionary = {0}", d.Count) + "\n";

      outputBlock.Text += String.Format("Does dictionary contain 'Jeff'? {0}", d.Contains("Jeff")) + "\n";
      outputBlock.Text += String.Format("Jeff's age is {0}", d["Jeff"]) + "\n";

      // Display every entry's key and value.
      foreach (DictionaryEntry de in d)
      {
         outputBlock.Text += String.Format("{0} is {1} years old.", de.Key, de.Value) + "\n";
      }

      // Remove an entry that exists.
      d.Remove("Jeff");

      // Remove an entry that does not exist, but do not throw an exception.
      d.Remove("Max");

      // Show the names (keys) of the people in the dictionary.
      foreach (String s in d.Keys)
         outputBlock.Text += s + "\n";

      // Show the ages (values) of the people in the dictionary.
      foreach (Int32 age in d.Values)
         outputBlock.Text += age + "\n";
   }
}

// This code produces the following output.
//
// Number of elements in dictionary = 3
// Does dictionary contain 'Jeff'? True
// Jeff's age is 40
// Jeff is 40 years old.
// Kristin is 34 years old.
// Aidan is 1 years old.
// Kristin
// Aidan
// 34
// 1


Windows Phone OS

지원되는 버전: 8.0, 7.1, 7.0

Windows Phone

표시:
© 2016 Microsoft