이 문서는 기계 번역을 이용하여 번역되었습니다. 문서를 영문으로 보려면 영문 확인란을 선택하세요. 마우스 포인터를 텍스트 위로 이동시켜 팝업 창에서 영문 텍스트를 표시할 수도 있습니다.
번역
영문

IDictionary 인터페이스

 

게시 날짜: 2016년 11월

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

네임스페이스:   System.Collections
어셈블리:  mscorlib(mscorlib.dll에 있음)

[ComVisibleAttribute(true)]
public interface IDictionary : ICollection, IEnumerable

이름설명
System_CAPS_pubpropertyCount

ICollection에 포함된 요소 수를 가져옵니다.(ICollection에서 상속됨)

System_CAPS_pubpropertyIsFixedSize

나타내는 값을 가져옵니다 여부는 IDictionary 개체 크기가 고정된 되어 있습니다.

System_CAPS_pubpropertyIsReadOnly

나타내는 값을 가져옵니다 여부는 IDictionary 개체가 읽기 전용입니다.

System_CAPS_pubpropertyIsSynchronized

ICollection에 대한 액세스가 동기화되어 스레드로부터 안전하게 보호되는지를 나타내는 값을 가져옵니다.(ICollection에서 상속됨)

System_CAPS_pubpropertyItem[Object]

지정한 키를 가진 요소를 가져오거나 설정합니다.

System_CAPS_pubpropertyKeys

가져옵니다는 ICollection 개체의 키를 포함 하는 IDictionary 개체입니다.

System_CAPS_pubpropertySyncRoot

ICollection에 대한 액세스를 동기화하는 데 사용할 수 있는 개체를 가져옵니다.(ICollection에서 상속됨)

System_CAPS_pubpropertyValues

가져옵니다는 ICollection 값을 포함 하는 개체는 IDictionary 개체입니다.

이름설명
System_CAPS_pubmethodAdd(Object, Object)

제공된 키와 값을 가진 요소를 IDictionary 개체에 추가합니다.

System_CAPS_pubmethodClear()

IDictionary 개체에서 요소를 모두 제거합니다.

System_CAPS_pubmethodContains(Object)

IDictionary 개체에 지정한 키를 가진 요소가 포함되어 있는지 여부를 결정합니다.

System_CAPS_pubmethodCopyTo(Array, Int32)

특정 ICollection 인덱스부터 시작하여 Array의 요소를 Array에 복사합니다.(ICollection에서 상속됨)

System_CAPS_pubmethodGetEnumerator()

반환 된 IDictionaryEnumerator 개체에 대 한는 IDictionary 개체입니다.

System_CAPS_pubmethodRemove(Object)

IDictionary 개체에서 지정한 키를 가지는 요소를 제거합니다.

이름설명
System_CAPS_pubmethodAsParallel()

오버로드되었습니다. 쿼리를 병렬화할 수 있도록 합니다.(ParallelEnumerable에서 정의됨)

System_CAPS_pubmethodAsQueryable()

오버로드되었습니다. 변환 된 IEnumerableIQueryable합니다.(Queryable에서 정의됨)

System_CAPS_pubmethodCast<TResult>()

요소에 캐스트는 IEnumerable 지정 된 형식입니다.(Enumerable에서 정의됨)

System_CAPS_pubmethodOfType<TResult>()

요소를 필터링 한 IEnumerable 지정된 된 형식에 기반 합니다.(Enumerable에서 정의됨)

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

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

각 쌍에 고유 키를 있어야 합니다. 키를 null이 될 수 있는지 여부에 구현이 달라질 수 있습니다. 값은 null 일 수 있으며 고유할 필요는 없습니다. IDictionary 인터페이스를 사용 하면 포함 된 키와 값을 열거할 수 있지만 특정 정렬 순서를 의미 하지는 않습니다.

IDictionary 세 가지 범주에 해당 구현을: 읽기 전용, 고정 크기, 다양 한 크기입니다. 읽기 전용 IDictionary 개체를 수정할 수 없습니다. 고정 크기 IDictionary 개체를 추가 하거나 제거할 요소를 허용 하지 않지만 기존 요소를 수정할 수는 있습니다. 가변 크기 IDictionary 개체 추가, 제거 및 요소를 수정할 수 있습니다.

foreach C# 언어의 (For Each Visual basic에서) 컬렉션의 요소 형식의 개체를 반환 합니다. 이후의 각 요소는 IDictionary 개체는 키/값 쌍, 요소 형식이 아닙니다 키의 형식 또는 값의 형식입니다. 요소 형식은 만으로도 DictionaryEntry합니다. 예:

foreach (DictionaryEntry de in myDictionary)
{
    //...
}

foreach 문을에서 읽기만 가능 하지만 컬렉션에 작성 하지을 수 있는 열거자를 중심으로 래핑됩니다.

구현자 참고 사항:

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

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

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 App
{
    static void Main()
    {
        // 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);

        Console.WriteLine("Number of elements in dictionary = {0}", d.Count);

        Console.WriteLine("Does dictionary contain 'Jeff'? {0}", d.Contains("Jeff"));
        Console.WriteLine("Jeff's age is {0}", d["Jeff"]);

        // Display every entry's key and value.
        foreach (DictionaryEntry de in d)
        {
            Console.WriteLine("{0} is {1} years old.", de.Key, de.Value);
        }

        // 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)
            Console.WriteLine(s);

        // Show the ages (values) of the people in the dictionary.
        foreach (Int32 age in d.Values)
            Console.WriteLine(age);
    }
}

// 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 플랫폼
8 이후 사용 가능
.NET Framework
1.1 이후 사용 가능
이식 가능한 클래스 라이브러리
이식 가능한 .NET 플랫폼 에서 지원됨
Silverlight
2.0 이후 사용 가능
Windows Phone Silverlight
7.0 이후 사용 가능
Windows Phone
8.1 이후 사용 가능
맨 위로 이동
표시: