ConcurrentDictionary<TKey,TValue> Classe

Definizione

Rappresenta una raccolta thread-safe di coppie chiave/valore a cui è possibile accedere contemporaneamente da più thread.Represents a thread-safe collection of key/value pairs that can be accessed by multiple threads concurrently.

generic <typename TKey, typename TValue>
public ref class ConcurrentDictionary : System::Collections::Generic::ICollection<System::Collections::Generic::KeyValuePair<TKey, TValue>>, System::Collections::Generic::IDictionary<TKey, TValue>, System::Collections::Generic::IEnumerable<System::Collections::Generic::KeyValuePair<TKey, TValue>>, System::Collections::Generic::IReadOnlyCollection<System::Collections::Generic::KeyValuePair<TKey, TValue>>, System::Collections::Generic::IReadOnlyDictionary<TKey, TValue>, System::Collections::IDictionary
[System.Runtime.InteropServices.ComVisible(false)]
[System.Serializable]
public class ConcurrentDictionary<TKey,TValue> : System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IDictionary<TKey,TValue>, System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IReadOnlyCollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>, System.Collections.Generic.IReadOnlyDictionary<TKey,TValue>, System.Collections.IDictionary
type ConcurrentDictionary<'Key, 'Value> = class
    interface IDictionary<'Key, 'Value>
    interface IDictionary
    interface IReadOnlyDictionary<'Key, 'Value>
    interface ICollection<KeyValuePair<'Key, 'Value>>
    interface seq<KeyValuePair<'Key, 'Value>>
    interface IEnumerable
    interface ICollection
    interface IReadOnlyCollection<KeyValuePair<'Key, 'Value>>
Public Class ConcurrentDictionary(Of TKey, TValue)
Implements ICollection(Of KeyValuePair(Of TKey, TValue)), IDictionary, IDictionary(Of TKey, TValue), IEnumerable(Of KeyValuePair(Of TKey, TValue)), IReadOnlyCollection(Of KeyValuePair(Of TKey, TValue)), IReadOnlyDictionary(Of TKey, TValue)

Parametri di tipo

TKey

Tipo di chiavi nel dizionario.The type of the keys in the dictionary.

TValue

Tipo di valori nel dizionario.The type of the values in the dictionary.

Ereditarietà
ConcurrentDictionary<TKey,TValue>
Attributi
Implementazioni

Esempi

Nell'esempio seguente viene illustrato come costruire un ConcurrentDictionary<TKey,TValue> oggetto.The following example shows how to construct a ConcurrentDictionary<TKey,TValue> object.


class CD_Ctor
{
        // Demonstrates:
        //      ConcurrentDictionary<TKey, TValue> ctor(concurrencyLevel, initialCapacity)
        //      ConcurrentDictionary<TKey, TValue>[TKey]
        static void Main()
        {
            // We know how many items we want to insert into the ConcurrentDictionary.
            // So set the initial capacity to some prime number above that, to ensure that
            // the ConcurrentDictionary does not need to be resized while initializing it.
            int NUMITEMS = 64;
            int initialCapacity = 101;

            // The higher the concurrencyLevel, the higher the theoretical number of operations
            // that could be performed concurrently on the ConcurrentDictionary.  However, global
            // operations like resizing the dictionary take longer as the concurrencyLevel rises. 
            // For the purposes of this example, we'll compromise at numCores * 2.
            int numProcs = Environment.ProcessorCount;
            int concurrencyLevel = numProcs * 2;

            // Construct the dictionary with the desired concurrencyLevel and initialCapacity
            ConcurrentDictionary<int, int> cd = new ConcurrentDictionary<int, int>(concurrencyLevel, initialCapacity);

            // Initialize the dictionary
            for (int i = 0; i < NUMITEMS; i++) cd[i] = i * i;

            Console.WriteLine("The square of 23 is {0} (should be {1})", cd[23], 23 * 23);
        }
}
Imports System.Collections.Concurrent
Imports System.Threading.Tasks

Class CD_Ctor
    ' Demonstrates:
    ' ConcurrentDictionary<TKey, TValue> ctor(concurrencyLevel, initialCapacity)
    ' ConcurrentDictionary<TKey, TValue>[TKey]
    Shared Sub Main()
        ' We know how many items we want to insert into the ConcurrentDictionary.
        ' So set the initial capacity to some prime number above that, to ensure that
        ' the ConcurrentDictionary does not need to be resized while initializing it.
        Dim NUMITEMS As Integer = 64
        Dim initialCapacity As Integer = 101

        ' The higher the concurrencyLevel, the higher the theoretical number of operations
        ' that could be performed concurrently on the ConcurrentDictionary. However, global
        ' operations like resizing the dictionary take longer as the concurrencyLevel rises. 
        ' For the purposes of this example, we'll compromise at numCores * 2.
        Dim numProcs As Integer = Environment.ProcessorCount
        Dim concurrencyLevel As Integer = numProcs * 2

        ' Construct the dictionary with the desired concurrencyLevel and initialCapacity
        Dim cd As New ConcurrentDictionary(Of Integer, Integer)(concurrencyLevel, initialCapacity)

        ' Initialize the dictionary
        For i As Integer = 0 To NUMITEMS - 1
            cd(i) = i * i
        Next

        Console.WriteLine("The square of 23 is {0} (should be {1})", cd(23), 23 * 23)
    End Sub
End Class

Commenti

Per gli oggetti ConcurrentDictionary<TKey,TValue> di grandi dimensioni, è possibile aumentare la dimensione massima della matrice a 2 gigabyte (GB) in un sistema a 64 bit <gcAllowVeryLargeObjects> impostando l' true elemento di configurazione su nell'ambiente di Runtime.For very large ConcurrentDictionary<TKey,TValue> objects, you can increase the maximum array size to 2 gigabytes (GB) on a 64-bit system by setting the <gcAllowVeryLargeObjects> configuration element to true in the run-time environment.

Nota

ConcurrentDictionary<TKey,TValue>implementa le IReadOnlyCollection<T> interfacce IReadOnlyDictionary<TKey,TValue> e che iniziano con .NET Framework 4.6.NET Framework 4.6; nelle versioni precedenti del .NET Framework, la ConcurrentDictionary<TKey,TValue> classe non ha implementato tali interfacce.ConcurrentDictionary<TKey,TValue> implements the IReadOnlyCollection<T> and IReadOnlyDictionary<TKey,TValue> interfaces starting with the .NET Framework 4.6.NET Framework 4.6; in previous versions of the .NET Framework, the ConcurrentDictionary<TKey,TValue> class did not implement these interfaces.

Analogamente System.Collections.Generic.Dictionary<TKey,TValue> alla classe ConcurrentDictionary<TKey,TValue> , implementa IDictionary<TKey,TValue> l'interfaccia.Like the System.Collections.Generic.Dictionary<TKey,TValue> class, ConcurrentDictionary<TKey,TValue> implements the IDictionary<TKey,TValue> interface. In sono inoltre ConcurrentDictionary<TKey,TValue> disponibili diversi metodi per l'aggiunta o l'aggiornamento di coppie chiave/valore nel dizionario, come descritto nella tabella seguente.In addition, ConcurrentDictionary<TKey,TValue> provides several methods for adding or updating key/value pairs in the dictionary, as described in the following table.

Operazione da eseguireTo do this Usa questo metodoUse this method Note sull'utilizzoUsage notes
Aggiungere una nuova chiave al dizionario, se non esiste già nel dizionarioAdd a new key to the dictionary, if it doesn't already exist in the dictionary TryAdd Questo metodo aggiunge la coppia chiave/valore specificata, se la chiave non esiste attualmente nel dizionario.This method adds the specified key/value pair, if the key doesn't currently exist in the dictionary. Il metodo restituisce true o false a seconda che la nuova coppia sia stata aggiunta o meno.The method returns true or false depending on whether the new pair was added.
Aggiornare il valore di una chiave esistente nel dizionario, se tale chiave ha un valore specificoUpdate the value for an existing key in the dictionary, if that key has a specific value TryUpdate Questo metodo controlla se la chiave ha un valore specificato e, in tal caso, aggiorna la chiave con un nuovo valore.This method checks whether the key has a specified value, and if it does, updates the key with a new value. È simile al metodo, CompareExchange con la differenza che viene usato per gli elementi del dizionario.It's similar to the CompareExchange method, except that it's used for dictionary elements.
Archiviare una coppia chiave/valore nel dizionario in modo incondizionato e sovrascrivere il valore di una chiave già esistenteStore a key/value pair in the dictionary unconditionally, and overwrite the value of a key that already exists Set dell'indicizzatore:dictionary[key] = newValueThe indexer's setter: dictionary[key] = newValue
Aggiungere una coppia chiave/valore al dizionario oppure, se la chiave esiste già, aggiornare il valore della chiave in base al valore esistente della chiave.Add a key/value pair to the dictionary, or if the key already exists, update the value for the key based on the key's existing value AddOrUpdate(TKey, Func<TKey,TValue>, Func<TKey,TValue,TValue>)

-oppure--or-

AddOrUpdate(TKey, TValue, Func<TKey,TValue,TValue>)
AddOrUpdate(TKey, Func<TKey,TValue>, Func<TKey,TValue,TValue>)accetta la chiave e due delegati.AddOrUpdate(TKey, Func<TKey,TValue>, Func<TKey,TValue,TValue>) accepts the key and two delegates. Usa il primo delegato se la chiave non esiste nel dizionario; accetta la chiave e restituisce il valore da aggiungere per la chiave.It uses the first delegate if the key doesn't exist in the dictionary; it accepts the key and returns the value that should be added for the key. Usa il secondo delegato se la chiave esiste; accetta la chiave e il relativo valore corrente e restituisce il nuovo valore che deve essere impostato per la chiave.It uses the second delegate if the key does exist; it accepts the key and its current value, and it returns the new value that should be set for the key.

AddOrUpdate(TKey, TValue, Func<TKey,TValue,TValue>)accetta la chiave, un valore da aggiungere e il delegato dell'aggiornamento.AddOrUpdate(TKey, TValue, Func<TKey,TValue,TValue>) accepts the key, a value to add, and the update delegate. Equivale all'overload precedente, ad eccezione del fatto che non usa un delegato per aggiungere una chiave.This is the same as the previous overload, except that it doesn't use a delegate to add a key.
Ottenere il valore per una chiave nel dizionario, aggiungendo il valore al dizionario e restituendo il valore se la chiave non esiste.Get the value for a key in the dictionary, adding the value to the dictionary and returning it if the key doesn't exist GetOrAdd(TKey, TValue)

-oppure--or-

GetOrAdd(TKey, Func<TKey,TValue>)
Questi overload forniscono l'inizializzazione differita per una coppia chiave/valore nel dizionario, aggiungendo il valore solo se non è presente.These overloads provide lazy initialization for a key/value pair in the dictionary, adding the value only if it's not there.

GetOrAdd(TKey, TValue)accetta il valore da aggiungere se la chiave non esiste.GetOrAdd(TKey, TValue) takes the value to be added if the key doesn't exist.

GetOrAdd(TKey, Func<TKey,TValue>)accetta un delegato che genererà il valore se la chiave non esiste.GetOrAdd(TKey, Func<TKey,TValue>) takes a delegate that will generate the value if the key doesn't exist.

Tutte queste operazioni sono atomiche e sono thread-safe per quanto riguarda tutte le altre operazioni sulla ConcurrentDictionary<TKey,TValue> classe.All these operations are atomic and are thread-safe with regards to all other operations on the ConcurrentDictionary<TKey,TValue> class. Le uniche eccezioni sono i metodi che accettano un delegato, ovvero AddOrUpdate e. GetOrAddThe only exceptions are the methods that accept a delegate, that is, AddOrUpdate and GetOrAdd. Per le modifiche e le operazioni di scrittura nel ConcurrentDictionary<TKey,TValue> dizionario, usa un blocco con granularità fine per garantire thread safety.For modifications and write operations to the dictionary, ConcurrentDictionary<TKey,TValue> uses fine-grained locking to ensure thread safety. Le operazioni di lettura sul dizionario vengono eseguite in modo senza blocco. Tuttavia, i delegati per questi metodi vengono chiamati all'esterno dei blocchi per evitare i problemi che possono derivare dall'esecuzione di codice sconosciuto in un blocco.(Read operations on the dictionary are performed in a lock-free manner.) However, delegates for these methods are called outside the locks to avoid the problems that can arise from executing unknown code under a lock. Pertanto, il codice eseguito da questi delegati non è soggetto all'atomicità dell'operazione.Therefore, the code executed by these delegates is not subject to the atomicity of the operation.

Costruttori

ConcurrentDictionary<TKey,TValue>()

Inizializza una nuova istanza vuota della classe ConcurrentDictionary<TKey,TValue>, con il livello di concorrenza e la capacità iniziale predefiniti e che usa l'operatore di confronto predefinito per il tipo di chiave.Initializes a new instance of the ConcurrentDictionary<TKey,TValue> class that is empty, has the default concurrency level, has the default initial capacity, and uses the default comparer for the key type.

ConcurrentDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>)

Inizializza una nuova istanza della classe ConcurrentDictionary<TKey,TValue> che contiene elementi copiati dall'oggetto IEnumerable<T>, dispone del livello di concorrenza e della capacità iniziale predefiniti e utilizza l'operatore di confronto predefinito per il tipo di chiave.Initializes a new instance of the ConcurrentDictionary<TKey,TValue> class that contains elements copied from the specified IEnumerable<T>, has the default concurrency level, has the default initial capacity, and uses the default comparer for the key type.

ConcurrentDictionary<TKey,TValue>(IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>)

Inizializza una nuova istanza della classe ConcurrentDictionary<TKey,TValue> che contiene elementi copiati dall'oggetto IEnumerable specificato, con il livello di concorrenza e la capacità iniziale predefiniti e che usa l'oggetto IEqualityComparer<T> specificato.Initializes a new instance of the ConcurrentDictionary<TKey,TValue> class that contains elements copied from the specified IEnumerable has the default concurrency level, has the default initial capacity, and uses the specified IEqualityComparer<T>.

ConcurrentDictionary<TKey,TValue>(IEqualityComparer<TKey>)

Inizializza una nuova istanza vuota della classe ConcurrentDictionary<TKey,TValue>, con il livello di concorrenza e la capacità predefiniti e che usa l'oggetto IEqualityComparer<T> specificato.Initializes a new instance of the ConcurrentDictionary<TKey,TValue> class that is empty, has the default concurrency level and capacity, and uses the specified IEqualityComparer<T>.

ConcurrentDictionary<TKey,TValue>(Int32, IEnumerable<KeyValuePair<TKey,TValue>>, IEqualityComparer<TKey>)

Inizializza una nuova istanza della classe ConcurrentDictionary<TKey,TValue> che contiene gli elementi copiati dall'interfaccia IEnumerable specificata e che usa l'interfaccia IEqualityComparer<T> indicata.Initializes a new instance of the ConcurrentDictionary<TKey,TValue> class that contains elements copied from the specified IEnumerable, and uses the specified IEqualityComparer<T>.

ConcurrentDictionary<TKey,TValue>(Int32, Int32)

Inizializza una nuova istanza vuota della classe ConcurrentDictionary<TKey,TValue>, con il livello di concorrenza e la capacità specificati e che usa l'operatore di confronto predefinito per il tipo di chiave.Initializes a new instance of the ConcurrentDictionary<TKey,TValue> class that is empty, has the specified concurrency level and capacity, and uses the default comparer for the key type.

ConcurrentDictionary<TKey,TValue>(Int32, Int32, IEqualityComparer<TKey>)

Inizializza una nuova istanza vuota della classe ConcurrentDictionary<TKey,TValue>, con il livello di concorrenza e la capacità iniziale specificati e che utilizza l'oggetto IEqualityComparer<T> specificato.Initializes a new instance of the ConcurrentDictionary<TKey,TValue> class that is empty, has the specified concurrency level, has the specified initial capacity, and uses the specified IEqualityComparer<T>.

Proprietà

Count

Ottiene il numero di coppie chiave/valore contenute in ConcurrentDictionary<TKey,TValue>.Gets the number of key/value pairs contained in the ConcurrentDictionary<TKey,TValue>.

IsEmpty

Ottiene un valore che indica se ConcurrentDictionary<TKey,TValue> è vuoto.Gets a value that indicates whether the ConcurrentDictionary<TKey,TValue> is empty.

Item[TKey]

Ottiene o imposta il valore associato alla chiave specificata.Gets or sets the value associated with the specified key.

Keys

Ottiene una raccolta contenente le chiavi della classe Dictionary<TKey,TValue>.Gets a collection containing the keys in the Dictionary<TKey,TValue>.

Values

Ottiene una raccolta contenente i valori presenti in Dictionary<TKey,TValue>.Gets a collection that contains the values in the Dictionary<TKey,TValue>.

Metodi

AddOrUpdate(TKey, Func<TKey,TValue>, Func<TKey,TValue,TValue>)

Utilizza le funzioni specificate per aggiungere una coppia chiave/valore a ConcurrentDictionary<TKey,TValue>, se la chiave non esiste già, oppure per aggiornare una coppia chiave/valore in ConcurrentDictionary<TKey,TValue> se la chiave esiste già.Uses the specified functions to add a key/value pair to the ConcurrentDictionary<TKey,TValue> if the key does not already exist, or to update a key/value pair in the ConcurrentDictionary<TKey,TValue> if the key already exists.

AddOrUpdate(TKey, TValue, Func<TKey,TValue,TValue>)

Aggiunge una coppia chiave/valore a ConcurrentDictionary<TKey,TValue>, se la chiave non esiste già, oppure aggiorna una coppia chiave/valore in ConcurrentDictionary<TKey,TValue> usando la funzione specificata, se la chiave esiste già.Adds a key/value pair to the ConcurrentDictionary<TKey,TValue> if the key does not already exist, or updates a key/value pair in the ConcurrentDictionary<TKey,TValue> by using the specified function if the key already exists.

AddOrUpdate<TArg>(TKey, Func<TKey,TArg,TValue>, Func<TKey,TValue,TArg,TValue>, TArg)

Usa le funzioni e l'argomento specificati per aggiungere una coppia chiave/valore a ConcurrentDictionary<TKey,TValue>, se la chiave non esiste già, oppure per aggiornare una coppia chiave/valore in ConcurrentDictionary<TKey,TValue> se la chiave esiste già.Uses the specified functions and argument to add a key/value pair to the ConcurrentDictionary<TKey,TValue> if the key does not already exist, or to update a key/value pair in the ConcurrentDictionary<TKey,TValue> if the key already exists.

Clear()

Rimuove tutte le chiavi e i valori della raccolta ConcurrentDictionary<TKey,TValue>.Removes all keys and values from the ConcurrentDictionary<TKey,TValue>.

ContainsKey(TKey)

Determina se la raccolta ConcurrentDictionary<TKey,TValue> contiene la chiave specificata.Determines whether the ConcurrentDictionary<TKey,TValue> contains the specified key.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Ereditato da Object)
GetEnumerator()

Restituisce un enumeratore che esegue l'iterazione di ConcurrentDictionary<TKey,TValue>.Returns an enumerator that iterates through the ConcurrentDictionary<TKey,TValue>.

GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Ereditato da Object)
GetOrAdd(TKey, Func<TKey,TValue>)

Aggiunge una coppia chiave/valore a ConcurrentDictionary<TKey,TValue> usando la funzione specificata se la chiave non esiste già.Adds a key/value pair to the ConcurrentDictionary<TKey,TValue> by using the specified function if the key does not already exist. Restituisce il nuovo valore, oppure, se la chiave esiste, restituisce il valore esistente.Returns the new value, or the existing value if the key exists.

GetOrAdd(TKey, TValue)

Aggiunge una coppia chiave/valore a ConcurrentDictionary<TKey,TValue> se la chiave non esiste già.Adds a key/value pair to the ConcurrentDictionary<TKey,TValue> if the key does not already exist. Restituisce il nuovo valore, oppure, se la chiave esiste, restituisce il valore esistente.Returns the new value, or the existing value if the key exists.

GetOrAdd<TArg>(TKey, Func<TKey,TArg,TValue>, TArg)

Aggiunge una coppia chiave/valore a ConcurrentDictionary<TKey,TValue> usando la funzione specificata e un argomento se la chiave non esiste ancora, oppure, se la chiave esiste già, restituisce il valore esistente.Adds a key/value pair to the ConcurrentDictionary<TKey,TValue> by using the specified function and an argument if the key does not already exist, or returns the existing value if the key exists.

GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
ToArray()

Copia le coppie chiave/valore archiviate in ConcurrentDictionary<TKey,TValue> in una nuova matrice.Copies the key and value pairs stored in the ConcurrentDictionary<TKey,TValue> to a new array.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Ereditato da Object)
TryAdd(TKey, TValue)

Tenta di aggiungere la chiave e il valore specificati a ConcurrentDictionary<TKey,TValue>.Attempts to add the specified key and value to the ConcurrentDictionary<TKey,TValue>.

TryGetValue(TKey, TValue)

Tenta di ottenere il valore associato alla chiave specificata da ConcurrentDictionary<TKey,TValue>.Attempts to get the value associated with the specified key from the ConcurrentDictionary<TKey,TValue>.

TryRemove(TKey, TValue)

Tenta di rimuovere e restituire il valore con la chiave specificata da ConcurrentDictionary<TKey,TValue>.Attempts to remove and return the value that has the specified key from the ConcurrentDictionary<TKey,TValue>.

TryUpdate(TKey, TValue, TValue)

Aggiorna il valore associato a key impostandolo su newValue se il valore esistente con key è uguale a comparisonValue.Updates the value associated with key to newValue if the existing value with key is equal to comparisonValue.

Implementazioni dell'interfaccia esplicita

ICollection.CopyTo(Array, Int32)

Copia gli elementi dell'interfaccia ICollection in una matrice, iniziando dall'indice di matrice specificato.Copies the elements of the ICollection to an array, starting at the specified array index.

ICollection.IsSynchronized

Ottiene un valore che indica se l'accesso a ICollection è sincronizzato con SyncRoot.Gets a value that indicates whether access to the ICollection is synchronized with the SyncRoot.

ICollection.SyncRoot

Ottiene un oggetto che può essere usato per sincronizzare l'accesso a ICollection.Gets an object that can be used to synchronize access to the ICollection. Questa proprietà non è supportata.This property is not supported.

ICollection<KeyValuePair<TKey,TValue>>.Add(KeyValuePair<TKey,TValue>)

Aggiunge un elemento alla raccolta.Adds an item to the collection.

ICollection<KeyValuePair<TKey,TValue>>.Contains(KeyValuePair<TKey,TValue>)

Ottiene un valore che indica se ICollection<T> contiene un elemento con la chiave specificata.Gets whether the ICollection<T> contains an element with the specified key.

ICollection<KeyValuePair<TKey,TValue>>.CopyTo(KeyValuePair<TKey,TValue>[], Int32)

Copia gli elementi dell'interfaccia ICollection in una matrice, iniziando dall'indice di matrice specificato.Copies the elements of the ICollection to an array, starting at the specified array index.

ICollection<KeyValuePair<TKey,TValue>>.IsReadOnly

Ottiene un valore che indica se ICollection è di sola lettura.Gets a value that indicates whether the ICollection is read-only.

ICollection<KeyValuePair<TKey,TValue>>.Remove(KeyValuePair<TKey,TValue>)

Rimuove la coppia chiave/valore specificata dalla raccolta.Removes the specified key/value pair from the collection.

IDictionary.Add(Object, Object)

Aggiunge la chiave e il valore specificati al dizionario.Adds the specified key and value to the dictionary.

IDictionary.Contains(Object)

Ottiene un valore che indica se IDictionary<TKey,TValue> contiene un elemento con la chiave specificata.Gets a value that indicates the IDictionary<TKey,TValue> contains an element with the specified key.

IDictionary.GetEnumerator()

Fornisce un oggetto IDictionaryEnumerator per l'oggetto IDictionary<TKey,TValue>.Provides a IDictionaryEnumerator for the IDictionary<TKey,TValue>.

IDictionary.IsFixedSize

Ottiene un valore che indica se le dimensioni dell'oggetto IDictionary<TKey,TValue> sono fisse.Gets a value that indicates whether the IDictionary<TKey,TValue> has a fixed size.

IDictionary.IsReadOnly

Ottiene un valore che indica se IDictionary<TKey,TValue> è di sola lettura.Gets a value that indicates whether the IDictionary<TKey,TValue> is read-only.

IDictionary.Item[Object]

Ottiene o imposta il valore associato alla chiave specificata.Gets or sets the value associated with the specified key.

IDictionary.Keys

Ottiene un oggetto ICollection che contiene le chiavi di IDictionary<TKey,TValue>.Gets an ICollection that contains the keys of the IDictionary<TKey,TValue>.

IDictionary.Remove(Object)

Rimuove l'elemento con la chiave specificata da IDictionary.Removes the element with the specified key from the IDictionary.

IDictionary.Values

Ottiene un oggetto ICollection contenente i valori di IDictionary.Gets an ICollection that contains the values in the IDictionary.

IDictionary<TKey,TValue>.Add(TKey, TValue)

Aggiunge a IDictionary<TKey,TValue> la chiave e il valore specificati.Adds the specified key and value to the IDictionary<TKey,TValue>.

IDictionary<TKey,TValue>.Remove(TKey)

Rimuove l'elemento con la chiave specificata da IDictionary<TKey,TValue>.Removes the element with the specified key from the IDictionary<TKey,TValue>.

IEnumerable.GetEnumerator()

Restituisce un enumeratore che esegue l'iterazione di ConcurrentDictionary<TKey,TValue>.Returns an enumerator that iterates through the ConcurrentDictionary<TKey,TValue>.

IReadOnlyDictionary<TKey,TValue>.Keys

Ottiene una raccolta contenente le chiavi della classe Dictionary<TKey,TValue>.Gets a collection containing the keys in the Dictionary<TKey,TValue>.

IReadOnlyDictionary<TKey,TValue>.Values

Ottiene una raccolta contenente i valori presenti in Dictionary<TKey,TValue>.Gets a collection that contains the values in the Dictionary<TKey,TValue>.

Metodi di estensione

GetValueOrDefault<TKey,TValue>(IReadOnlyDictionary<TKey,TValue>, TKey)

Tries to get the value associated with the specified key in the dictionary.

GetValueOrDefault<TKey,TValue>(IReadOnlyDictionary<TKey,TValue>, TKey, TValue)

Tries to get the value associated with the specified key in the dictionary.

Remove<TKey,TValue>(IDictionary<TKey,TValue>, TKey, TValue)

Tries to remove the value with the specified key from the dictionary.

TryAdd<TKey,TValue>(IDictionary<TKey,TValue>, TKey, TValue)

Tries to add the specified key and value to the dictionary.

CopyToDataTable<T>(IEnumerable<T>)

Restituisce un oggetto DataTable che contiene copie degli oggetti DataRow, dato un oggetto IEnumerable<T> di input dove il parametro generico DataRow è T.Returns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Copia gli oggetti DataRow nell'oggetto DataTable specificato, dato un oggetto IEnumerable<T> di input dove il parametro generico T è DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Copia gli oggetti DataRow nell'oggetto DataTable specificato, dato un oggetto IEnumerable<T> di input dove il parametro generico T è DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable)

Esegue il cast degli elementi di un oggetto IEnumerable nel tipo specificato.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Consente la parallelizzazione di una query.Enables parallelization of a query.

AsQueryable(IEnumerable)

Converte un oggetto IEnumerable in un oggetto IQueryable.Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>)

Restituisce una raccolta di elementi che contiene i predecessori di ciascun nodo nella raccolta di origine.Returns a collection of elements that contains the ancestors of every node in the source collection.

Ancestors<T>(IEnumerable<T>, XName)

Restituisce una raccolta di elementi filtrati che contiene i predecessori di ciascun nodo nella raccolta di origine.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Restituisce una raccolta di nodi discendenti di ciascun documento ed elemento nella raccolta di origine.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Restituisce una raccolta di elementi che contiene gli elementi discendenti di ciascun elemento e documento nella raccolta di origine.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

Descendants<T>(IEnumerable<T>, XName)

Restituisce una raccolta filtrata di elementi che contiene gli elementi discendenti di ciascun elemento e documento nella raccolta di origine.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Restituisce una raccolta di elementi figlio di ciascun elemento e documento nella raccolta di origine.Returns a collection of the child elements of every element and document in the source collection.

Elements<T>(IEnumerable<T>, XName)

Restituisce una raccolta filtrata degli elementi figlio di ciascun elemento e documento nella raccolta di origine.Returns a filtered collection of the child elements of every element and document in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Restituisce una raccolta di nodi che contiene tutti i nodi nella raccolta di origine ordinati in base all'ordine con cui sono riportati nel documento.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Restituisce una raccolta di nodi figlio di ciascun documento ed elemento nella raccolta di origine.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Rimuove ciascun nodo nella raccolta di origine dal nodo padre.Removes every node in the source collection from its parent node.

Si applica a

Thread safety

Tutti i membri pubblici e protetti ConcurrentDictionary<TKey,TValue> di sono thread-safe e possono essere usati contemporaneamente da più thread.All public and protected members of ConcurrentDictionary<TKey,TValue> are thread-safe and may be used concurrently from multiple threads. Tuttavia, i membri a cui si accede tramite una ConcurrentDictionary<TKey,TValue> delle interfacce implementate, inclusi i metodi di estensione, non sono necessariamente thread-safe e potrebbero dover essere sincronizzati dal chiamante.However, members accessed through one of the interfaces the ConcurrentDictionary<TKey,TValue> implements, including extension methods, are not guaranteed to be thread safe and may need to be synchronized by the caller.

Vedi anche