IDictionary 介面

定義

表示索引鍵/值組的非泛型集合。

public interface class IDictionary : System::Collections::ICollection
public interface IDictionary : System.Collections.ICollection
[System.Runtime.InteropServices.ComVisible(true)]
public interface IDictionary : System.Collections.ICollection
type IDictionary = interface
    interface ICollection
    interface IEnumerable
[<System.Runtime.InteropServices.ComVisible(true)>]
type IDictionary = interface
    interface ICollection
    interface IEnumerable
Public Interface IDictionary
Implements ICollection
衍生
屬性
實作

範例

下列程式碼範例示範如何定義實作 介面的 IDictionary 簡單字典類別。

using namespace System;
using namespace System::Collections;

// This class implements a simple dictionary using an array of
// DictionaryEntry objects (key/value pairs).
public ref class SimpleDictionary : public IDictionary
{
    // The array of items
private:
    array<DictionaryEntry^>^ items;
private:
    int itemsInUse;

    // Construct the SimpleDictionary with the desired number of
    // items. The number of items cannot change for the life time of
    // this SimpleDictionary.
public:
    SimpleDictionary(int size)
    {
        items = gcnew array<DictionaryEntry^>(size);
    }

    #pragma region IDictionary Members
public:
    property virtual bool IsReadOnly
    {
        bool get()
        {
            return false;
        }
    }
public:
    virtual bool Contains(Object^ key)
    {
        int index;
        return TryGetIndexOfKey(key, &index);
    }
public:
    virtual property bool IsFixedSize
    {
        bool get()
        {
            return false;
        }
    }
public:
    virtual void Remove(Object^ key)
    {
        if (key == nullptr)
        {
            throw gcnew ArgumentNullException("key");
        }
        // Try to find the key in the DictionaryEntry array
        int index;
        if (TryGetIndexOfKey(key, &index))
        {
            // If the key is found, slide all the items down.
            Array::Copy(items, index + 1, items, index, itemsInUse -
                index - 1);
            itemsInUse--;
        }
        else
        {
            // If the key is not in the dictionary, just return.
            return;
        }
    }
public:
    virtual void Clear()
    {
        itemsInUse = 0;
    }
public:
    virtual 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 gcnew InvalidOperationException
                ("The dictionary cannot hold any more items.");
        }
        items[itemsInUse++] = gcnew DictionaryEntry(key, value);
    }
public:
    virtual property ICollection^ Keys
    {
        ICollection^ get()
        {
            // Return an array where each item is a key.
            array<Object^>^ keys = gcnew array<Object^>(itemsInUse);
            for (int i = 0; i < itemsInUse; i++)
            {
                keys[i] = items[i]->Key;
            }
            return keys;
        }
    }
public:
    virtual property ICollection^ Values
    {
        ICollection^ get()
        {
            // Return an array where each item is a value.
            array<Object^>^ values = gcnew array<Object^>(itemsInUse);
            for (int i = 0; i < itemsInUse; i++)
            {
                values[i] = items[i]->Value;
            }
            return values;
        }
    }
public:
    virtual property Object^ default[Object^]
    {
        Object^ get(Object^ key)
        {
            // If this key is in the dictionary, return its value.
            int index;
            if (TryGetIndexOfKey(key, &index))
            {
                // The key was found; return its value.
                return items[index]->Value;
            }
            else
            {
                // The key was not found; return null.
                return nullptr;
            }
        }

        void set(Object^ key, Object^ value)
        {
            // If this key is in the dictionary, change its value.
            int index;
            if (TryGetIndexOfKey(key, &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:
    bool TryGetIndexOfKey(Object^ key, int* 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:
    ref class SimpleDictionaryEnumerator : public IDictionaryEnumerator
    {
        // A copy of the SimpleDictionary object's key/value pairs.
private:
        array<DictionaryEntry^>^ items;
private:
        int index;

public:
        SimpleDictionaryEnumerator(SimpleDictionary^ sd)
        {
            // Make a copy of the dictionary entries currently in the
            // SimpleDictionary object.
            items = gcnew array<DictionaryEntry^>(sd->Count);
            Array::Copy(sd->items, 0, items, 0, sd->Count);
            index = -1;
        }

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

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

        // Return the key of the current item.
public:
        virtual property Object^ Key
        {
            Object^ get()
            {
                ValidateIndex();
                return items[index]->Key;
            }
        }

        // Return the value of the current item.
public:
        virtual property Object^ Value
        {
            Object^ get()
            {
                ValidateIndex();
                return items[index]->Value;
            }
        }

        // Advance to the next item.
public:
        virtual bool 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 gcnew InvalidOperationException
                    ("Enumerator is before or after the collection.");
            }
        }

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

    #pragma region ICollection Members
public:
    virtual property bool IsSynchronized
    {
        bool get()
        {
            return false;
        }
    }

public:
    virtual property Object^ SyncRoot
    {
        Object^ get()
        {
            throw gcnew NotImplementedException();
        }
    }

public:
    virtual property int Count
    {
        int get()
        {
            return itemsInUse;
        }
    }

public:
    virtual void CopyTo(Array^ array, int index)
    {
        throw gcnew NotImplementedException();
    }
    #pragma endregion

    #pragma region IEnumerable Members

    virtual IEnumerator^ IEnumerable_GetEnumerator() 
        = IEnumerable::GetEnumerator
    {
        // Construct and return an enumerator.
        return ((IDictionary^)this)->GetEnumerator();
    }
    #pragma endregion
};

int main()
{
    // Create a dictionary that contains no more than three
    // entries.
    IDictionary^ d = gcnew 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.
    for each (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.
    for each (String^ s in d->Keys)
    {
        Console::WriteLine(s);
    }

    // Show the ages (values) of the people in the dictionary.
    for each (int 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
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
Imports System.Collections

' This class implements a simple dictionary using an array of DictionaryEntry objects (key/value pairs).
Public Class SimpleDictionary
    Implements IDictionary

    ' The array of items
    Dim items() As DictionaryEntry
    Dim ItemsInUse As Integer = 0

    ' Construct the SimpleDictionary with the desired number of items.
    ' The number of items cannot change for the life time of this SimpleDictionary.
    Public Sub New(ByVal numItems As Integer)
        items = New DictionaryEntry(numItems - 1) {}
    End Sub

    ' IDictionary Members
    Public ReadOnly Property IsReadOnly() As Boolean Implements IDictionary.IsReadOnly
        Get
            Return False
        End Get
    End Property

    Public Function Contains(ByVal key As Object) As Boolean Implements IDictionary.Contains
        Dim index As Integer
        Return TryGetIndexOfKey(key, index)
    End Function

    Public ReadOnly Property IsFixedSize() As Boolean Implements IDictionary.IsFixedSize
        Get
            Return False
        End Get
    End Property

    Public Sub Remove(ByVal key As Object) Implements IDictionary.Remove
        If key = Nothing Then
            Throw New ArgumentNullException("key")
        End If
        ' Try to find the key in the DictionaryEntry array
        Dim index As Integer
        If TryGetIndexOfKey(key, index) Then

            ' If the key is found, slide all the items up.
            Array.Copy(items, index + 1, items, index, (ItemsInUse - index) - 1)
            ItemsInUse = ItemsInUse - 1
        Else

            ' If the key is not in the dictionary, just return. 
        End If
    End Sub

    Public Sub Clear() Implements IDictionary.Clear
        ItemsInUse = 0
    End Sub

    Public Sub Add(ByVal key As Object, ByVal value As Object) Implements IDictionary.Add

        ' Add the new key/value pair even if this key already exists in the dictionary.
        If ItemsInUse = items.Length Then
            Throw New InvalidOperationException("The dictionary cannot hold any more items.")
        End If
        items(ItemsInUse) = New DictionaryEntry(key, value)
        ItemsInUse = ItemsInUse + 1
    End Sub

    Public ReadOnly Property Keys() As ICollection Implements IDictionary.Keys
        Get

            ' Return an array where each item is a key.
            ' Note: Declaring keyArray() to have a size of ItemsInUse - 1
            '       ensures that the array is properly sized, in VB.NET
            '       declaring an array of size N creates an array with
            '       0 through N elements, including N, as opposed to N - 1
            '       which is the default behavior in C# and C++.
            Dim keyArray() As Object = New Object(ItemsInUse - 1) {}
            Dim n As Integer
            For n = 0 To ItemsInUse - 1
                keyArray(n) = items(n).Key
            Next n

            Return keyArray
        End Get
    End Property

    Public ReadOnly Property Values() As ICollection Implements IDictionary.Values
        Get
            ' Return an array where each item is a value.
            Dim valueArray() As Object = New Object(ItemsInUse - 1) {}
            Dim n As Integer
            For n = 0 To ItemsInUse - 1
                valueArray(n) = items(n).Value
            Next n

            Return valueArray
        End Get
    End Property

    Public Property Item(ByVal key As Object) As Object Implements IDictionary.Item
        Get

            ' If this key is in the dictionary, return its value.
            Dim index As Integer
            If TryGetIndexOfKey(key, index) Then

                ' The key was found return its value.
                Return items(index).Value
            Else

                ' The key was not found return null.
                Return Nothing
            End If
        End Get

        Set(ByVal value As Object)
            ' If this key is in the dictionary, change its value. 
            Dim index As Integer
            If TryGetIndexOfKey(key, index) Then

                ' 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)
            End If
        End Set
    End Property

    Private Function TryGetIndexOfKey(ByVal key As Object, ByRef index As Integer) As Boolean
        For index = 0 To ItemsInUse - 1
            ' If the key is found, return true (the index is also returned).
            If items(index).Key.Equals(key) Then
                Return True
            End If
        Next index

        ' Key not found, return false (index should be ignored by the caller).
        Return False
    End Function

    Private Class SimpleDictionaryEnumerator
        Implements IDictionaryEnumerator

        ' A copy of the SimpleDictionary object's key/value pairs.
        Dim items() As DictionaryEntry
        Dim index As Integer = -1

        Public Sub New(ByVal sd As SimpleDictionary)
            ' Make a copy of the dictionary entries currently in the SimpleDictionary object.
            items = New DictionaryEntry(sd.Count - 1) {}
            Array.Copy(sd.items, 0, items, 0, sd.Count)
        End Sub

        ' Return the current item.
        Public ReadOnly Property Current() As Object Implements IDictionaryEnumerator.Current
            Get
                ValidateIndex()
                Return items(index)
            End Get
        End Property

        ' Return the current dictionary entry.
        Public ReadOnly Property Entry() As DictionaryEntry Implements IDictionaryEnumerator.Entry
            Get
                Return Current
            End Get
        End Property

        ' Return the key of the current item.
        Public ReadOnly Property Key() As Object Implements IDictionaryEnumerator.Key
            Get
                ValidateIndex()
                Return items(index).Key
            End Get
        End Property

        ' Return the value of the current item.
        Public ReadOnly Property Value() As Object Implements IDictionaryEnumerator.Value
            Get
                ValidateIndex()
                Return items(index).Value
            End Get
        End Property

        ' Advance to the next item.
        Public Function MoveNext() As Boolean Implements IDictionaryEnumerator.MoveNext
            If index < items.Length - 1 Then
                index = index + 1
                Return True
            End If

            Return False
        End Function

        ' Validate the enumeration index and throw an exception if the index is out of range.
        Private Sub ValidateIndex()
            If index < 0 Or index >= items.Length Then
                Throw New InvalidOperationException("Enumerator is before or after the collection.")
            End If
        End Sub

        ' Reset the index to restart the enumeration.
        Public Sub Reset() Implements IDictionaryEnumerator.Reset
            index = -1
        End Sub

    End Class

    Public Function GetEnumerator() As IDictionaryEnumerator Implements IDictionary.GetEnumerator

        'Construct and return an enumerator.
        Return New SimpleDictionaryEnumerator(Me)
    End Function


    ' ICollection Members
    Public ReadOnly Property IsSynchronized() As Boolean Implements IDictionary.IsSynchronized
        Get
            Return False
        End Get
    End Property

    Public ReadOnly Property SyncRoot() As Object Implements IDictionary.SyncRoot
        Get
            Throw New NotImplementedException()
        End Get
    End Property

    Public ReadOnly Property Count() As Integer Implements IDictionary.Count
        Get
            Return ItemsInUse
        End Get
    End Property

    Public Sub CopyTo(ByVal array As Array, ByVal index As Integer) Implements IDictionary.CopyTo
        Throw New NotImplementedException()
    End Sub

    ' IEnumerable Members
    Public Function GetEnumerator1() As IEnumerator Implements IEnumerable.GetEnumerator

        ' Construct and return an enumerator.
        Return Me.GetEnumerator()
    End Function
End Class

Public NotInheritable Class App
    Public Shared Sub Main()
        ' Create a dictionary that contains no more than three entries.
        Dim d As IDictionary = 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.
        Dim de As DictionaryEntry
        For Each de In d
            Console.WriteLine("{0} is {1} years old.", de.Key, de.Value)
        Next

        ' 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.
        Dim s As String

        For Each s In d.Keys
            Console.WriteLine(s)
        Next

        ' Show the ages (values) of the people in the dictionary.
        Dim age As Integer
        For Each age In d.Values
            Console.WriteLine(age)
        Next

    End Sub
End Class

' 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

備註

介面 IDictionary 是索引鍵/值組非一般集合的基底介面。 如需此介面的泛型版本,請參閱 System.Collections.Generic.IDictionary<TKey,TValue>

每個元素都是儲存在 物件中的 DictionaryEntry 索引鍵/值組。

每個配對都必須有唯一索引鍵。 實作可能會因是否允許索引鍵為 Null 而有所不同。 此值可以是 Null,而且不一定是唯一的。 IDictionary介面允許列舉包含的索引鍵和值,但並不表示任何特定的排序次序。

IDictionary 實作分為三種類別:唯讀、固定大小、可變大小。 無法修改唯讀 IDictionary 物件。 固定大小 IDictionary 物件不允許新增或移除專案,但允許修改現有的專案。 可變大小 IDictionary 物件允許新增、移除和修改專案。

foreachVisual Basic 中 C# 語言 (的 語句) For Each 會傳回集合中專案類型的 物件。 因為物件的每個元素 IDictionary 都是索引鍵/值組,所以元素類型不是索引鍵的類型或值的型別。 相反地,元素類型為 DictionaryEntry 。 例如:

for each (DictionaryEntry de in myDictionary)
{
    //...
}
foreach (DictionaryEntry de in myDictionary)
{
    //...
}
For Each de As DictionaryEntry In myDictionary
    '...
Next de

語句 foreach 是列舉值周圍的包裝函式,只允許從 讀取,但不允許寫入集合。

給實施者的注意事項

實作類別必須有比較索引鍵的方法。

屬性

Count

取得 ICollection 中所包含的項目數。

(繼承來源 ICollection)
IsFixedSize

取得值,指出 IDictionary 物件是否具有固定的大小。

IsReadOnly

取得值,這個值表示 IDictionary 物件是否唯讀。

IsSynchronized

取得值,這個值表示對 ICollection 的存取是否同步 (安全執行緒)。

(繼承來源 ICollection)
Item[Object]

取得或設定具有指定索引鍵的項目。

Keys

取得 ICollection 物件,其中包含 IDictionary 物件的索引鍵。

SyncRoot

取得可用以同步存取 ICollection 的物件。

(繼承來源 ICollection)
Values

取得 ICollection 物件,其中含有 IDictionary 物件中的值。

方法

Add(Object, Object)

將隨附有索引鍵和值的項目加入至 IDictionary 物件。

Clear()

將所有項目從 IDictionary 物件移除。

Contains(Object)

判斷 IDictionary 物件是否包含具有指定索引鍵的項目。

CopyTo(Array, Int32)

從特定的 ICollection 索引開始,將 Array 的項目複製到 Array

(繼承來源 ICollection)
GetEnumerator()

傳回 IDictionary 物件的 IDictionaryEnumerator 物件。

Remove(Object)

IDictionary 物件中移除具有指定索引鍵的項目。

擴充方法

Cast<TResult>(IEnumerable)

IEnumerable 的項目轉換成指定的型別。

OfType<TResult>(IEnumerable)

根據指定的型別來篩選 IEnumerable 的項目。

AsParallel(IEnumerable)

啟用查詢的平行化作業。

AsQueryable(IEnumerable)

IEnumerable 轉換成 IQueryable

適用於

另請參閱