Hashtable Třída

Definice

Obor názvů:

System.Collections

Sestavení:

System.Runtime.dll

Zdroj:

Hashtable.cs

Představuje kolekci párů klíč-hodnota uspořádaných podle hodnot hash klíčů.

public ref class Hashtable : ICloneable, System::Collections::IDictionary, System::Runtime::Serialization::IDeserializationCallback, System::Runtime::Serialization::ISerializable

public class Hashtable : ICloneable, System.Collections.IDictionary, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable

type Hashtable = class
    interface ICollection
    interface IEnumerable
    interface IDictionary
    interface ICloneable
    interface IDeserializationCallback
    interface ISerializable

Public Class Hashtable
Implements ICloneable, IDeserializationCallback, IDictionary, ISerializable

Dědičnost

Object

Hashtable

Odvozené

System.Configuration.SettingsAttributeDictionary

System.Configuration.SettingsContext

System.Data.PropertyCollection

System.Printing.IndexedProperties.PrintPropertyDictionary

Implementuje

ICollection IDictionary IEnumerable ICloneable IDeserializationCallback ISerializable

Příklady

Následující příklad ukazuje, jak vytvořit, inicializovat a provádět různé funkce pro objekt Hashtable a jak vytisknout jeho klíče a hodnoty.

using namespace System;
using namespace System::Collections;

public ref class Example
{
public:
    static void Main()
    {
        // Create a new hash table.
        //
        Hashtable^ openWith = gcnew Hashtable();
        
        // Add some elements to the hash table. There are no
        // duplicate keys, but some of the values are duplicates.
        openWith->Add("txt", "notepad.exe");
        openWith->Add("bmp", "paint.exe");
        openWith->Add("dib", "paint.exe");
        openWith->Add("rtf", "wordpad.exe");

        // The Add method throws an exception if the new key is 
        // already in the hash table.
        try
        {
            openWith->Add("txt", "winword.exe");
        }
        catch(...)
        {
            Console::WriteLine("An element with Key = \"txt\" already exists.");
        }

        // The Item property is the default property, so you 
        // can omit its name when accessing elements. 
        Console::WriteLine("For key = \"rtf\", value = {0}.", openWith["rtf"]);
        
        // The default Item property can be used to change the value
        // associated with a key.
        openWith["rtf"] = "winword.exe";
        Console::WriteLine("For key = \"rtf\", value = {0}.", openWith["rtf"]);

        // If a key does not exist, setting the default Item property
        // for that key adds a new key/value pair.
        openWith["doc"] = "winword.exe";

        // ContainsKey can be used to test keys before inserting 
        // them.
        if (!openWith->ContainsKey("ht"))
        {
            openWith->Add("ht", "hypertrm.exe");
            Console::WriteLine("Value added for key = \"ht\": {0}", openWith["ht"]);
        }

        // When you use foreach to enumerate hash table elements,
        // the elements are retrieved as KeyValuePair objects.
        Console::WriteLine();
        for each( DictionaryEntry de in openWith )
        {
            Console::WriteLine("Key = {0}, Value = {1}", de.Key, de.Value);
        }

        // To get the values alone, use the Values property.
        ICollection^ valueColl = openWith->Values;
        
        // The elements of the ValueCollection are strongly typed
        // with the type that was specified for hash table values.
        Console::WriteLine();
        for each( String^ s in valueColl )
        {
            Console::WriteLine("Value = {0}", s);
        }

        // To get the keys alone, use the Keys property.
        ICollection^ keyColl = openWith->Keys;
        
        // The elements of the KeyCollection are strongly typed
        // with the type that was specified for hash table keys.
        Console::WriteLine();
        for each( String^ s in keyColl )
        {
            Console::WriteLine("Key = {0}", s);
        }

        // Use the Remove method to remove a key/value pair.
        Console::WriteLine("\nRemove(\"doc\")");
        openWith->Remove("doc");

        if (!openWith->ContainsKey("doc"))
        {
            Console::WriteLine("Key \"doc\" is not found.");
        }
    }
};

int main()
{
    Example::Main();
}

/* This code example produces the following output:

An element with Key = "txt" already exists.
For key = "rtf", value = wordpad.exe.
For key = "rtf", value = winword.exe.
Value added for key = "ht": hypertrm.exe

Key = dib, Value = paint.exe
Key = txt, Value = notepad.exe
Key = ht, Value = hypertrm.exe
Key = bmp, Value = paint.exe
Key = rtf, Value = winword.exe
Key = doc, Value = winword.exe

Value = paint.exe
Value = notepad.exe
Value = hypertrm.exe
Value = paint.exe
Value = winword.exe
Value = winword.exe

Key = dib
Key = txt
Key = ht
Key = bmp
Key = rtf
Key = doc

Remove("doc")
Key "doc" is not found.
 */

using System;
using System.Collections;

class Example
{
    public static void Main()
    {
        // Create a new hash table.
        //
        Hashtable openWith = new Hashtable();

        // Add some elements to the hash table. There are no
        // duplicate keys, but some of the values are duplicates.
        openWith.Add("txt", "notepad.exe");
        openWith.Add("bmp", "paint.exe");
        openWith.Add("dib", "paint.exe");
        openWith.Add("rtf", "wordpad.exe");

        // The Add method throws an exception if the new key is
        // already in the hash table.
        try
        {
            openWith.Add("txt", "winword.exe");
        }
        catch
        {
            Console.WriteLine("An element with Key = \"txt\" already exists.");
        }

        // The Item property is the default property, so you
        // can omit its name when accessing elements.
        Console.WriteLine("For key = \"rtf\", value = {0}.", openWith["rtf"]);

        // The default Item property can be used to change the value
        // associated with a key.
        openWith["rtf"] = "winword.exe";
        Console.WriteLine("For key = \"rtf\", value = {0}.", openWith["rtf"]);

        // If a key does not exist, setting the default Item property
        // for that key adds a new key/value pair.
        openWith["doc"] = "winword.exe";

        // ContainsKey can be used to test keys before inserting
        // them.
        if (!openWith.ContainsKey("ht"))
        {
            openWith.Add("ht", "hypertrm.exe");
            Console.WriteLine("Value added for key = \"ht\": {0}", openWith["ht"]);
        }

        // When you use foreach to enumerate hash table elements,
        // the elements are retrieved as KeyValuePair objects.
        Console.WriteLine();
        foreach( DictionaryEntry de in openWith )
        {
            Console.WriteLine("Key = {0}, Value = {1}", de.Key, de.Value);
        }

        // To get the values alone, use the Values property.
        ICollection valueColl = openWith.Values;

        // The elements of the ValueCollection are strongly typed
        // with the type that was specified for hash table values.
        Console.WriteLine();
        foreach( string s in valueColl )
        {
            Console.WriteLine("Value = {0}", s);
        }

        // To get the keys alone, use the Keys property.
        ICollection keyColl = openWith.Keys;

        // The elements of the KeyCollection are strongly typed
        // with the type that was specified for hash table keys.
        Console.WriteLine();
        foreach( string s in keyColl )
        {
            Console.WriteLine("Key = {0}", s);
        }

        // Use the Remove method to remove a key/value pair.
        Console.WriteLine("\nRemove(\"doc\")");
        openWith.Remove("doc");

        if (!openWith.ContainsKey("doc"))
        {
            Console.WriteLine("Key \"doc\" is not found.");
        }
    }
}

/* This code example produces the following output:

An element with Key = "txt" already exists.
For key = "rtf", value = wordpad.exe.
For key = "rtf", value = winword.exe.
Value added for key = "ht": hypertrm.exe

Key = dib, Value = paint.exe
Key = txt, Value = notepad.exe
Key = ht, Value = hypertrm.exe
Key = bmp, Value = paint.exe
Key = rtf, Value = winword.exe
Key = doc, Value = winword.exe

Value = paint.exe
Value = notepad.exe
Value = hypertrm.exe
Value = paint.exe
Value = winword.exe
Value = winword.exe

Key = dib
Key = txt
Key = ht
Key = bmp
Key = rtf
Key = doc

Remove("doc")
Key "doc" is not found.
 */

Imports System.Collections

Module Example

    Sub Main()

        ' Create a new hash table.
        '
        Dim openWith As New Hashtable()

        ' Add some elements to the hash table. There are no 
        ' duplicate keys, but some of the values are duplicates.
        openWith.Add("txt", "notepad.exe")
        openWith.Add("bmp", "paint.exe")
        openWith.Add("dib", "paint.exe")
        openWith.Add("rtf", "wordpad.exe")

        ' The Add method throws an exception if the new key is 
        ' already in the hash table.
        Try
            openWith.Add("txt", "winword.exe")
        Catch
            Console.WriteLine("An element with Key = ""txt"" already exists.")
        End Try

        ' The Item property is the default property, so you 
        ' can omit its name when accessing elements. 
        Console.WriteLine("For key = ""rtf"", value = {0}.", _
            openWith("rtf"))

        ' The default Item property can be used to change the value
        ' associated with a key.
        openWith("rtf") = "winword.exe"
        Console.WriteLine("For key = ""rtf"", value = {0}.", _
            openWith("rtf"))

        ' If a key does not exist, setting the default Item property
        ' for that key adds a new key/value pair.
        openWith("doc") = "winword.exe"

        ' ContainsKey can be used to test keys before inserting 
        ' them.
        If Not openWith.ContainsKey("ht") Then
            openWith.Add("ht", "hypertrm.exe")
            Console.WriteLine("Value added for key = ""ht"": {0}", _
                openWith("ht"))
        End If

        ' When you use foreach to enumerate hash table elements,
        ' the elements are retrieved as KeyValuePair objects.
        Console.WriteLine()
        For Each de As DictionaryEntry In openWith
            Console.WriteLine("Key = {0}, Value = {1}", _
                de.Key, de.Value)
        Next de

        ' To get the values alone, use the Values property.
        Dim valueColl As ICollection = openWith.Values

        ' The elements of the ValueCollection are strongly typed
        ' with the type that was specified for hash table values.
        Console.WriteLine()
        For Each s As String In valueColl
            Console.WriteLine("Value = {0}", s)
        Next s

        ' To get the keys alone, use the Keys property.
        Dim keyColl As ICollection = openWith.Keys

        ' The elements of the KeyCollection are strongly typed
        ' with the type that was specified for hash table keys.
        Console.WriteLine()
        For Each s As String In keyColl
            Console.WriteLine("Key = {0}", s)
        Next s

        ' Use the Remove method to remove a key/value pair.
        Console.WriteLine(vbLf + "Remove(""doc"")")
        openWith.Remove("doc")

        If Not openWith.ContainsKey("doc") Then
            Console.WriteLine("Key ""doc"" is not found.")
        End If

    End Sub

End Module

' This code example produces the following output:
'
'An element with Key = "txt" already exists.
'For key = "rtf", value = wordpad.exe.
'For key = "rtf", value = winword.exe.
'Value added for key = "ht": hypertrm.exe
'
'Key = dib, Value = paint.exe
'Key = txt, Value = notepad.exe
'Key = ht, Value = hypertrm.exe
'Key = bmp, Value = paint.exe
'Key = rtf, Value = winword.exe
'Key = doc, Value = winword.exe
'
'Value = paint.exe
'Value = notepad.exe
'Value = hypertrm.exe
'Value = paint.exe
'Value = winword.exe
'Value = winword.exe
'
'Key = dib
'Key = txt
'Key = ht
'Key = bmp
'Key = rtf
'Key = doc
'
'Remove("doc")
'Key "doc" is not found.

# Create new hash table using PowerShell syntax
$OpenWith = @{}

# Add one element to the hash table using the Add method
$OpenWith.Add('txt', 'notepad.exe')

# Add three eleements using PowerShell syntax three different ways
$OpenWith.dib = 'paint.exe'

$KeyBMP = 'bmp'
$OpenWith[$KeyBMP] = 'paint.exe'

$OpenWith += @{'rtf' = 'wordpad.exe'}

# Display hash table
"There are {0} in the `$OpenWith hash table as follows:" -f $OpenWith.Count
''

# Display hashtable properties
'Count of items in the hashtable  : {0}' -f $OpenWith.Count
'Is hashtable fixed size?         : {0}' -f $OpenWith.IsFixedSize
'Is hashtable read-only?          : {0}' -f $OpenWith.IsReadonly
'Is hashtabale synchronised?      : {0}' -f $OpenWith.IsSynchronized
''
'Keys in hashtable:'
$OpenWith.Keys
''
'Values in hashtable:'
$OpenWith.Values
''

<#
This script produces the following output:

There are 4 in the $OpenWith hash table as follows:

Name                           Value                                                                            
----                           -----                                                                            
txt                            notepad.exe                                                                      
dib                            paint.exe                                                                        
bmp                            paint.exe                                                                        
rtf                            wordpad.exe                                                                      

Count of items in the hashtable  : 4
Is hashtable fixed size?         : False
Is hashtable read-only?          : False
Is hashtabale synchronised?      : False

Keys in hashtable:
txt
dib
bmp
rtf

Values in hashtable:
notepad.exe
paint.exe
paint.exe
wordpad.exe
#>

Poznámky

Každý prvek je pár klíč/hodnota uložený v objektu DictionaryEntry . Klíč nemůže být null, ale hodnota může být.

Důležité

Nedoporučujeme používat Hashtable třídu pro nový vývoj. Místo toho doporučujeme použít obecnou Dictionary<TKey,TValue> třídu. Další informace najdete v tématu Na GitHubu by se neměly používat jiné než obecné kolekce .

Objekty používané jako klíče jsou Hashtable potřeba k přepsání Object.GetHashCode metody (nebo IHashCodeProvider rozhraní) a Object.Equals metody (nebo IComparer rozhraní). Implementace metod i rozhraní musí zpracovávat rozlišování velkých a malých písmen stejným způsobem; v opačném případě se Hashtable může chovat nesprávně. Například při vytváření Hashtablemusíte použít CaseInsensitiveHashCodeProvider třídu (nebo jakoukoli implementaci IHashCodeProvider nerozlišující malá a malá písmena) s CaseInsensitiveComparer třídou (nebo jakoukoli implementací nerozlišující IComparer malá a malá písmena).

Kromě toho musí tyto metody při zavolání se stejnými parametry vytvořit stejné výsledky, zatímco klíč existuje v Hashtable. Alternativou je použít Hashtable konstruktor s parametrem IEqualityComparer . Pokud by klíčová rovnost byla pouze referenční rovnost, postačí zděděná implementace Object.GetHashCode a Object.Equals .

Klíčové objekty musí být neměnné, pokud se používají jako klíče v objektu Hashtable.

Když je prvek přidán do Hashtable, element je umístěn do kontejneru na základě hash kódu klíče. Následné vyhledávání klíče používá kód hash klíče k vyhledávání pouze v jedné konkrétní kbelíku, čímž se podstatně snižuje počet porovnání klíčů potřebných k nalezení prvku.

Faktor zatížení Hashtable určuje maximální poměr prvků k kontejnerům. Menší faktory zatížení způsobují rychlejší průměrné doby vyhledávání za cenu zvýšené spotřeby paměti. Výchozí faktor zatížení 1.0 obecně poskytuje nejlepší rovnováhu mezi rychlostí a velikostí. Při vytvoření objektu Hashtable lze také zadat jiný faktor zatížení.

Při přidání elementů do Hashtablese zvyšuje skutečný faktor Hashtable zatížení. Když skutečný faktor zatížení dosáhne zadaného faktoru zatížení, počet kontejnerů v objektu Hashtable se automaticky zvýší na nejmenší prvočíslo, které je větší než dvojnásobek aktuálního Hashtable počtu kontejnerů.

Každý objekt klíče v objektu Hashtable musí poskytovat vlastní hashovací funkci, ke které lze přistupovat voláním GetHash. Konstruktoru však může být předán Hashtable jakýkoli objekt implementuje IHashCodeProvider a tato hash funkce se používá pro všechny objekty v tabulce.

Kapacita je Hashtable počet prvků, které Hashtable může obsahovat. Při přidání prvků do Hashtable, kapacita se automaticky zvýší podle potřeby prostřednictvím reallokace.

Pouze rozhraní .NET Framework: U velmi velkých Hashtable objektů můžete zvýšit maximální kapacitu na 2 miliardy prvků v 64bitovém systému nastavením enabled atributu konfiguračního <gcAllowVeryLargeObjects> prvku na true v prostředí běhu.

Příkaz foreach jazyka C# (For Each v jazyce Visual Basic) vrátí objekt typu elementů v kolekci. Vzhledem k tomu, že každý prvek Hashtable je pár klíč/hodnota, typ prvku není typem klíče ani typem hodnoty. Místo toho je DictionaryEntrytyp elementu . Příklad:

for each(DictionaryEntry de in myHashtable)
{
    // ...
}

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

For Each de As DictionaryEntry In myHashtable
    ' ...
Next de

Příkaz foreach je obálka kolem enumerátoru, který umožňuje pouze čtení z kolekce, nikoli zápis do.

Protože serializace a deserializace výčtu pro Hashtable může způsobit změnu pořadí prvků, není možné pokračovat ve výčtu bez volání Reset metody.

Poznámka

Vzhledem k tomu, že klíče mohou být zděděny a jejich chování změněno, nelze jejich absolutní jedinečnost zaručit porovnáním pomocí Equals metody .

Konstruktory

Hashtable()	Inicializuje novou prázdnou Hashtable instanci třídy pomocí výchozí počáteční kapacity, faktoru zatížení, zprostředkovatele hash kódu a porovnávače.
Hashtable(IDictionary)	Inicializuje novou instanci Hashtable třídy zkopírováním elementů ze zadaného slovníku do nového Hashtable objektu. Nový Hashtable objekt má počáteční kapacitu rovnající se počtu zkopírovaných prvků a používá výchozí faktor zatížení, zprostředkovatele hash kódu a porovnávač.
Hashtable(IDictionary, IEqualityComparer)	Inicializuje novou instanci Hashtable třídy zkopírováním elementů ze zadaného slovníku do nového Hashtable objektu. Nový Hashtable objekt má počáteční kapacitu rovnající se počtu zkopírovaných prvků a používá výchozí faktor zatížení a zadaný IEqualityComparer objekt.
Hashtable(IDictionary, IHashCodeProvider, IComparer)	Zastaralé. Inicializuje novou instanci Hashtable třídy zkopírováním elementů ze zadaného slovníku do nového Hashtable objektu. Nový Hashtable objekt má počáteční kapacitu, která se rovná počtu zkopírovaných prvků, a používá výchozí faktor zatížení a zadaného zprostředkovatele a porovnávače hash kódu. Toto rozhraní API je zastaralé. Alternativu najdete v tématu Hashtable(IDictionary, IEqualityComparer).
Hashtable(IDictionary, Single)	Inicializuje novou instanci Hashtable třídy zkopírováním elementů ze zadaného slovníku do nového Hashtable objektu. Nový Hashtable objekt má počáteční kapacitu, která se rovná počtu zkopírovaných prvků, a používá zadaný faktor zatížení a výchozího zprostředkovatele a porovnávače kódu hash.
Hashtable(IDictionary, Single, IEqualityComparer)	Inicializuje novou instanci Hashtable třídy zkopírováním elementů ze zadaného slovníku do nového Hashtable objektu. Nový Hashtable objekt má počáteční kapacitu rovnající se počtu zkopírovaných prvků a používá zadaný faktor zatížení a IEqualityComparer objekt.
Hashtable(IDictionary, Single, IHashCodeProvider, IComparer)	Zastaralé. Inicializuje novou instanci Hashtable třídy zkopírováním elementů ze zadaného slovníku do nového Hashtable objektu. Nový Hashtable objekt má počáteční kapacitu rovnající se počtu zkopírovaných prvků a používá zadaný faktor zatížení, zprostředkovatele hash kódu a porovnávač.
Hashtable(IEqualityComparer)	Inicializuje novou prázdnou Hashtable instanci třídy pomocí výchozí počáteční kapacity a faktoru zatížení a zadaného IEqualityComparer objektu.
Hashtable(IHashCodeProvider, IComparer)	Zastaralé. Inicializuje novou prázdnou Hashtable instanci třídy pomocí výchozí počáteční kapacity a faktoru zatížení a zadaného zprostředkovatele a porovnávače hash kódu.
Hashtable(Int32)	Inicializuje novou prázdnou Hashtable instanci třídy pomocí zadané počáteční kapacity a výchozího faktoru zatížení, zprostředkovatele hash kódu a porovnávače.
Hashtable(Int32, IEqualityComparer)	Inicializuje novou prázdnou Hashtable instanci třídy pomocí zadané počáteční kapacity a IEqualityComparera výchozího faktoru zatížení.
Hashtable(Int32, IHashCodeProvider, IComparer)	Zastaralé. Inicializuje novou prázdnou Hashtable instanci třídy pomocí zadané počáteční kapacity, zprostředkovatele hash kódu, porovnávače a výchozího faktoru zatížení.
Hashtable(Int32, Single)	Inicializuje novou prázdnou Hashtable instanci třídy pomocí zadané počáteční kapacity a faktoru zatížení a výchozího zprostředkovatele a porovnávače hash kódu.
Hashtable(Int32, Single, IEqualityComparer)	Inicializuje novou prázdnou Hashtable instanci třídy pomocí zadané počáteční kapacity, faktoru zatížení a IEqualityComparer objektu.
Hashtable(Int32, Single, IHashCodeProvider, IComparer)	Zastaralé. Inicializuje novou prázdnou Hashtable instanci třídy pomocí zadané počáteční kapacity, faktoru zatížení, zprostředkovatele hash kódu a porovnávače.
Hashtable(SerializationInfo, StreamingContext)	Zastaralé. Inicializuje novou prázdnou Hashtable instanci třídy, která je serializovatelná pomocí zadaných SerializationInfo a StreamingContext objektů.

Vlastnosti

comparer	Zastaralé. Získá nebo nastaví IComparer na použití pro Hashtable.
Count	Získá počet párů klíč/hodnota obsažených v objektu Hashtable.
EqualityComparer	Získá k IEqualityComparer použití pro Hashtable.
hcp	Zastaralé. Získá nebo nastaví objekt, který může vydávat hash kódy.
IsFixedSize	Získá hodnotu označující, zda Hashtable má pevnou velikost.
IsReadOnly	Získá hodnotu, která určuje, zda je Hashtable určena jen pro čtení.
IsSynchronized	Získá hodnotu označující, zda je přístup k Hashtable je synchronizován (bez vláken).
Item[Object]	Získá nebo nastaví hodnotu přidruženou k zadanému klíči.
Keys	Získá obsahující ICollection klíče v .Hashtable
SyncRoot	Získá objekt, který lze použít k synchronizaci přístupu k Hashtable.
Values	Získá hodnotu ICollection obsahující hodnoty v objektu Hashtable.

Metody

Add(Object, Object)	Přidá prvek se zadaným klíčem a hodnotou do objektu Hashtable.
Clear()	Odebere všechny elementy z kolekce Hashtable.
Clone()	Vytvoří mělkou kopii souboru Hashtable.
Contains(Object)	Určuje, zda obsahuje Hashtable konkrétní klíč.
ContainsKey(Object)	Určuje, zda obsahuje Hashtable konkrétní klíč.
ContainsValue(Object)	Určuje, zda obsahuje Hashtable konkrétní hodnotu.
CopyTo(Array, Int32)	Zkopíruje elementy Hashtable do jednorozměrné Array instance v zadaném indexu.
Equals(Object)	Určí, zda se zadaný objekt rovná aktuálnímu objektu. (Zděděno od Object)
GetEnumerator()	Vrátí hodnotu IDictionaryEnumerator , která iteruje přes Hashtable.
GetHash(Object)	Vrátí kód hash pro zadaný klíč.
GetHashCode()	Slouží jako výchozí hashovací funkce. (Zděděno od Object)
GetObjectData(SerializationInfo, StreamingContext)	Zastaralé. Implementuje ISerializable rozhraní a vrátí data potřebná k serializaci Hashtable.
GetType()	Získá aktuální Type instanci. (Zděděno od Object)
KeyEquals(Object, Object)	Porovná konkrétní Object klíč s konkrétním klíčem v .Hashtable
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Objectsouboru . (Zděděno od Object)
OnDeserialization(Object)	Implementuje ISerializable rozhraní a vyvolá událost deserializace po dokončení deserializace.
Remove(Object)	Odebere prvek se zadaným klíčem z objektu Hashtable.
Synchronized(Hashtable)	Vrátí synchronizovanou obálku (bezpečnou Hashtablepro vlákna) pro .
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)

Explicitní implementace rozhraní

IEnumerable.GetEnumerator()

Vrací enumerátor procházející kolekci.

Metody rozšíření

Cast<TResult>(IEnumerable)	Přetypuje prvky objektu na IEnumerable zadaný typ.
OfType<TResult>(IEnumerable)	Filtruje prvky objektu IEnumerable na základě zadaného typu.
AsParallel(IEnumerable)	Umožňuje paralelizaci dotazu.
AsQueryable(IEnumerable)	Převede objekt na IEnumerableIQueryable.

Bezpečný přístup z více vláken

Hashtable je bezpečný pro více vláken čtečky a jedno vlákno pro zápis. Je bezpečný pro vícevláknové použití, když pouze jedno z vláken provádí operace zápisu (aktualizace), což umožňuje čtení bez uzamčení za předpokladu, že zapisovače jsou serializovány na Hashtable. Pro podporu více zapisovačů musí být všechny operace na objektu Hashtable provedeny prostřednictvím obálky vrácené metodou Synchronized(Hashtable) za předpokladu, že objekt nečtou Hashtable žádná vlákna.

Výčet prostřednictvím kolekce není vnitřně procedurou bezpečnou pro přístup z více vláken. I v případě, že jde o synchronizovanou kolekci, mohou úpravy provádět i ostatní vlákna, což způsobuje vyvolání výjimky enumerátorem. K zaručení bezpečnosti přístupu z více vláken můžete buďto zamknout kolekci na celou dobu práce s výčtem, nebo zachycovat výjimky vzniklé v důsledku změn prováděných ostatními vlákny.

Viz také

• IDictionary
• IHashCodeProvider
• GetHashCode()
• Equals(Object)
• DictionaryEntry
• Dictionary<TKey,TValue>
• IEqualityComparer