ConcurrentDictionary<TKey,TValue>.AddOrUpdate Metodo

Riferimento

Definizione

Spazio dei nomi:: System.Collections.Concurrent

Assembly:: System.Collections.Concurrent.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

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>, se la chiave esiste già.

Overload

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à.
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à.
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à.

Esempio

Nell'esempio seguente viene illustrato come chiamare il AddOrUpdate metodo :

class CD_GetOrAddOrUpdate
{
    // Demonstrates:
    //      ConcurrentDictionary<TKey, TValue>.AddOrUpdate()
    //      ConcurrentDictionary<TKey, TValue>.GetOrAdd()
    //      ConcurrentDictionary<TKey, TValue>[]
    static void Main()
    {
        // Construct a ConcurrentDictionary
        ConcurrentDictionary<int, int> cd = new ConcurrentDictionary<int, int>();

        // Bombard the ConcurrentDictionary with 10000 competing AddOrUpdates
        Parallel.For(0, 10000, i =>
        {
            // Initial call will set cd[1] = 1.
            // Ensuing calls will set cd[1] = cd[1] + 1
            cd.AddOrUpdate(1, 1, (key, oldValue) => oldValue + 1);
        });

        Console.WriteLine("After 10000 AddOrUpdates, cd[1] = {0}, should be 10000", cd[1]);

        // Should return 100, as key 2 is not yet in the dictionary
        int value = cd.GetOrAdd(2, (key) => 100);
        Console.WriteLine("After initial GetOrAdd, cd[2] = {0} (should be 100)", value);

        // Should return 100, as key 2 is already set to that value
        value = cd.GetOrAdd(2, 10000);
        Console.WriteLine("After second GetOrAdd, cd[2] = {0} (should be 100)", value);
    }
}

// Demonstrates:
//      ConcurrentDictionary<TKey, TValue>.AddOrUpdate()
//      ConcurrentDictionary<TKey, TValue>.GetOrAdd()
//      ConcurrentDictionary<TKey, TValue>[]

// Construct a ConcurrentDictionary
let cd = ConcurrentDictionary<int, int>()

// Bombard the ConcurrentDictionary with 10000 competing AddOrUpdates
Parallel.For(
    0,
    10000,
    fun i ->

        // Initial call will set cd[1] = 1.
        // Ensuing calls will set cd[1] = cd[1] + 1
        cd.AddOrUpdate(1, 1, (fun key oldValue -> oldValue + 1)) |> ignore
)
|> ignore

printfn $"After 10000 AddOrUpdates, cd[1] = {cd[1]}, should be 10000"

// Should return 100, as key 2 is not yet in the dictionary
let value = cd.GetOrAdd(2, (fun key -> 100))
printfn $"After initial GetOrAdd, cd[2] = {value} (should be 100)"

// Should return 100, as key 2 is already set to that value2
let value2 = cd.GetOrAdd(2, 10000)
printfn $"After second GetOrAdd, cd[2] = {value2} (should be 100)"

' Imports System.Collections.Concurrent
' Imports System.Threading.Tasks

Class CD_GetOrAddOrUpdate

    ' Demonstrates:
    ' ConcurrentDictionary<TKey, TValue>.AddOrUpdate()
    ' ConcurrentDictionary<TKey, TValue>.GetOrAdd()
    ' ConcurrentDictionary<TKey, TValue>[]
    Shared Sub Main()
        ' Construct a ConcurrentDictionary
        Dim cd As New ConcurrentDictionary(Of Integer, Integer)()

        ' Bombard the ConcurrentDictionary with 10000 competing AddOrUpdates
        Parallel.For(0, 10000,
                       Sub(i)
                           ' Initial call will set cd[1] = 1. 
                           ' Ensuing calls will set cd[1] = cd[1] + 1
                           cd.AddOrUpdate(1, 1, Function(key, oldValue) oldValue + 1)
                       End Sub)

        Console.WriteLine("After 10000 AddOrUpdates, cd[1] = {0}, should be 10000", cd(1))

        ' Should return 100, as key 2 is not yet in the dictionary
        Dim value As Integer = cd.GetOrAdd(2, Function(key) 100)
        Console.WriteLine("After initial GetOrAdd, cd[2] = {0} (should be 100)", value)

        ' Should return 100, as key 2 is already set to that value
        value = cd.GetOrAdd(2, 10000)
        Console.WriteLine("After second GetOrAdd, cd[2] = {0} (should be 100)", value)
    End Sub
End Class

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

Source:: ConcurrentDictionary.cs

Source:: ConcurrentDictionary.cs

Source:: ConcurrentDictionary.cs

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à.

public:
 TValue AddOrUpdate(TKey key, Func<TKey, TValue> ^ addValueFactory, Func<TKey, TValue, TValue> ^ updateValueFactory);

public TValue AddOrUpdate (TKey key, Func<TKey,TValue> addValueFactory, Func<TKey,TValue,TValue> updateValueFactory);

member this.AddOrUpdate : 'Key * Func<'Key, 'Value> * Func<'Key, 'Value, 'Value> -> 'Value

Public Function AddOrUpdate (key As TKey, addValueFactory As Func(Of TKey, TValue), updateValueFactory As Func(Of TKey, TValue, TValue)) As TValue

Parametri

key: TKey

Chiave da aggiungere o di cui aggiornare il valore.

addValueFactory: Func<TKey,TValue>

Funzione usata per generare un valore per una chiave assente.

updateValueFactory: Func<TKey,TValue,TValue>

Funzione usata per generare un nuovo valore per una chiave esistente in base al valore esistente della chiave.

Restituisce

TValue

Nuovo valore della chiave. Sarà il risultato di addValueFactory se la chiave è assente o il risultato di updateValueFactory se la chiave è presente.

Eccezioni

ArgumentNullException

key, addValueFactory o updateValueFactory è null.

OverflowException

Il dizionario contiene troppi elementi.

Commenti

Se si chiama AddOrUpdate contemporaneamente su thread diversi, addValueFactory può essere chiamato più volte, ma la relativa coppia chiave/valore potrebbe non essere aggiunta al dizionario per ogni chiamata.

Per le modifiche e le operazioni di scrittura nel dizionario, ConcurrentDictionary<TKey,TValue> usa il blocco con granularità fine per garantire la thread safety (le operazioni di lettura nel dizionario vengono eseguite in modo senza blocco). I addValueFactory delegati e updateValueFactory possono essere eseguiti più volte per verificare che il valore sia stato aggiunto o aggiornato come previsto. Tuttavia, vengono chiamati all'esterno dei blocchi per evitare i problemi che possono verificarsi dall'esecuzione di codice sconosciuto in un blocco. Pertanto, AddOrUpdate non è atomico per quanto riguarda tutte le altre operazioni sulla ConcurrentDictionary<TKey,TValue> classe .

Vedi anche

Si applica a

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

Source:: ConcurrentDictionary.cs

Source:: ConcurrentDictionary.cs

Source:: ConcurrentDictionary.cs

public:
 TValue AddOrUpdate(TKey key, TValue addValue, Func<TKey, TValue, TValue> ^ updateValueFactory);

public TValue AddOrUpdate (TKey key, TValue addValue, Func<TKey,TValue,TValue> updateValueFactory);

member this.AddOrUpdate : 'Key * 'Value * Func<'Key, 'Value, 'Value> -> 'Value

Public Function AddOrUpdate (key As TKey, addValue As TValue, updateValueFactory As Func(Of TKey, TValue, TValue)) As TValue

Parametri

key: TKey

Chiave da aggiungere o di cui aggiornare il valore.

addValue: TValue

Valore da aggiungere per una chiave assente.

updateValueFactory: Func<TKey,TValue,TValue>

Funzione usata per generare un nuovo valore per una chiave esistente in base al valore esistente della chiave.

Restituisce

TValue

Nuovo valore della chiave. Sarà addValue se la chiave è assente o il risultato di updateValueFactory se la chiave è presente.

Eccezioni

ArgumentNullException

key o updateValueFactory è null.

OverflowException

Il dizionario contiene troppi elementi.

Esempio

Nell'esempio di codice seguente viene illustrato come inizializzare ConcurrentDictionary<TKey,TValue> e come utilizzare il metodo AddOrUpdate per aggiungere un elemento aggiuntivo nella raccolta e aggiornare gli elementi esistenti.

using System;
using System.Collections.Concurrent;

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 HIGHNUMBER = 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 = 1; i <= HIGHNUMBER; i++) cd[i] = i * i;

        Console.WriteLine("The square of 23 is {0} (should be {1})", cd[23], 23 * 23);

        // Now iterate through, adding one to the end of the list. Existing items should be updated to be divided by their
        // key  and a new item will be added that is the square of its key.
        for (int i = 1; i <= HIGHNUMBER + 1; i++)
          cd.AddOrUpdate(i, i * i, (k,v) => v / i);

        Console.WriteLine("The square root of 529 is {0} (should be {1})", cd[23], 529 / 23);
        Console.WriteLine("The square of 65 is {0} (should be {1})", cd[HIGHNUMBER + 1], ((HIGHNUMBER + 1) * (HIGHNUMBER + 1)));
    }
}

open System
open System.Collections.Concurrent

// Demonstrates:
//      ConcurrentDictionary<TKey, TValue> ctor(concurrencyLevel, initialCapacity)
//      ConcurrentDictionary<TKey, TValue>[TKey]

// 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.
let HIGHNUMBER = 64
let 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.
let numProcs = Environment.ProcessorCount
let concurrencyLevel = numProcs * 2

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

// Initialize the dictionary
for i = 1 to HIGHNUMBER do
    cd[i] <- i * i

printfn $"The square of 23 is {cd[23]} (should be {23 * 23})"

// Now iterate through, adding one to the end of the list. Existing items should be updated to be divided by their
// key  and a new item will be added that is the square of its key.
for i = 1 to HIGHNUMBER + 1 do
    cd.AddOrUpdate(i, i * i, (fun k v -> v / i)) |> ignore

printfn $"The square root of 529 is {cd[23]} (should be {529 / 23})"
printfn $"The square of 65 is {cd[HIGHNUMBER + 1]} (should be {(HIGHNUMBER + 1) * (HIGHNUMBER + 1)})"

Imports System.Collections.Concurrent

Class CD_Ctor
    ' Demonstrates: 
    '      ConcurrentDictionary<TKey, TValue> ctor(concurrencyLevel, initialCapacity) 
    '      ConcurrentDictionary<TKey, TValue>[TKey] 
    Public 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 HIGHNUMBER 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 = 1 To HIGHNUMBER
            cd(i) = i * i
        Next

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

        ' Now iterate through, adding one to the end of the list. Existing items should be updated to be divided by their 
        ' key  and a new item will be added that is the square of its key.
        For i As Integer = 1 To HIGHNUMBER + 1

            cd.AddOrUpdate(i, i * i, Function(k, v)
                                         Return v / i
                                     End Function)
        Next

        Console.WriteLine("The square root of 529 is {0} (should be {1})", cd(23), 529 / 23)
        Console.WriteLine("The square of 65 is {0} (should be {1})", cd(HIGHNUMBER + 1), ((HIGHNUMBER + 1) * (HIGHNUMBER + 1)))

    End Sub
End Class

Per le modifiche e le operazioni di scrittura nel dizionario, ConcurrentDictionary<TKey,TValue> usa il blocco con granularità fine per garantire la thread safety. Le operazioni di lettura nel dizionario vengono eseguite in modo senza blocco. I addValueFactory delegati e updateValueFactory possono essere eseguiti più volte per verificare che il valore sia stato aggiunto o aggiornato come previsto. Tuttavia, vengono chiamati all'esterno dei blocchi per evitare i problemi che possono verificarsi dall'esecuzione di codice sconosciuto in un blocco. Pertanto, AddOrUpdate non è atomico per quanto riguarda tutte le altre operazioni sulla ConcurrentDictionary<TKey,TValue> classe .

Vedi anche

Si applica a

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

Source:: ConcurrentDictionary.cs

Source:: ConcurrentDictionary.cs

Source:: ConcurrentDictionary.cs

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à.

public:
generic <typename TArg>
 TValue AddOrUpdate(TKey key, Func<TKey, TArg, TValue> ^ addValueFactory, Func<TKey, TValue, TArg, TValue> ^ updateValueFactory, TArg factoryArgument);

public TValue AddOrUpdate<TArg> (TKey key, Func<TKey,TArg,TValue> addValueFactory, Func<TKey,TValue,TArg,TValue> updateValueFactory, TArg factoryArgument);

member this.AddOrUpdate : 'Key * Func<'Key, 'Arg, 'Value> * Func<'Key, 'Value, 'Arg, 'Value> * 'Arg -> 'Value

Public Function AddOrUpdate(Of TArg) (key As TKey, addValueFactory As Func(Of TKey, TArg, TValue), updateValueFactory As Func(Of TKey, TValue, TArg, TValue), factoryArgument As TArg) As TValue

Parametri di tipo

TArg

Tipo di argomento da passare a addValueFactory e updateValueFactory.

Parametri

key: TKey

Chiave da aggiungere o di cui aggiornare il valore.

addValueFactory: Func<TKey,TArg,TValue>

Funzione usata per generare un valore per una chiave assente.

updateValueFactory: Func<TKey,TValue,TArg,TValue>

Funzione usata per generare un nuovo valore per una chiave esistente in base al valore esistente della chiave.

factoryArgument: TArg

Argomento da passare in addValueFactory e updateValueFactory.

Restituisce

TValue

Nuovo valore della chiave. Sarà il risultato di addValueFactory se la chiave è assente o il risultato di updateValueFactory se la chiave è presente.

Eccezioni

ArgumentNullException

key, addValueFactory o updateValueFactory è un riferimento Null (Nothing in Visual Basic).

OverflowException

Il dizionario contiene troppi elementi.

Commenti

Si applica a

ConcurrentDictionary<TKey,TValue>.AddOrUpdate Metodo

Definizione

Overload

Esempio

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

Parametri

Restituisce

Eccezioni

Commenti

Vedi anche

Si applica a

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

Parametri

Restituisce

Eccezioni

Esempio

Vedi anche

Si applica a

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

Parametri di tipo

Parametri

Restituisce

Eccezioni

Commenti

Si applica a

Commenti e suggerimenti

Risorse aggiuntive