ConcurrentDictionary<TKey,TValue>.AddOrUpdate Metoda

Odwołanie

Definicja

Przestrzeń nazw:: System.Collections.Concurrent

Zestaw:: System.Collections.Concurrent.dll

Zestaw:: mscorlib.dll

Zestaw:: netstandard.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Dodaje parę klucz/wartość do ConcurrentDictionary<TKey,TValue> pary, jeśli klucz jeszcze nie istnieje, lub aktualizuje parę klucz/wartość w ConcurrentDictionary<TKey,TValue> przypadku, gdy klucz już istnieje.

Przeciążenia

AddOrUpdate(TKey, Func<TKey,TValue>, Func<TKey,TValue,TValue>)	Używa określonych funkcji, aby dodać parę klucz/wartość do ConcurrentDictionary<TKey,TValue> elementu , jeśli klucz jeszcze nie istnieje, lub zaktualizować parę klucz/wartość w przypadku ConcurrentDictionary<TKey,TValue> , gdy klucz już istnieje.
AddOrUpdate(TKey, TValue, Func<TKey,TValue,TValue>)	Dodaje parę klucz/wartość do ConcurrentDictionary<TKey,TValue> pary, jeśli klucz jeszcze nie istnieje, lub aktualizuje parę klucz/wartość w ConcurrentDictionary<TKey,TValue> obiekcie przy użyciu określonej funkcji, jeśli klucz już istnieje.
AddOrUpdate<TArg>(TKey, Func<TKey,TArg,TValue>, Func<TKey,TValue,TArg,TValue>, TArg)	Używa określonych funkcji i argumentu, aby dodać parę klucz/wartość do ConcurrentDictionary<TKey,TValue> pary, jeśli klucz jeszcze nie istnieje, lub zaktualizować parę klucz/wartość w ConcurrentDictionary<TKey,TValue> przypadku, gdy klucz już istnieje.

Przykłady

W poniższym przykładzie pokazano, jak wywołać metodę AddOrUpdate :

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>)

Źródło:: ConcurrentDictionary.cs

Źródło:: ConcurrentDictionary.cs

Źródło:: ConcurrentDictionary.cs

Używa określonych funkcji, aby dodać parę klucz/wartość do ConcurrentDictionary<TKey,TValue> elementu , jeśli klucz jeszcze nie istnieje, lub zaktualizować parę klucz/wartość w przypadku ConcurrentDictionary<TKey,TValue> , gdy klucz już istnieje.

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

Parametry

key: TKey

Klucz do dodania lub którego wartość należy zaktualizować.

addValueFactory: Func<TKey,TValue>

Funkcja używana do generowania wartości dla nieobecnego klucza.

updateValueFactory: Func<TKey,TValue,TValue>

Funkcja używana do generowania nowej wartości dla istniejącego klucza na podstawie istniejącej wartości klucza.

Zwraca

TValue

Nowa wartość klucza. Będzie to wynik addValueFactory (jeśli klucz był nieobecny) lub wynik updateValueFactory (jeśli klucz był obecny).

Wyjątki

ArgumentNullException

key, addValueFactorylub updateValueFactory to null.

OverflowException

Słownik zawiera zbyt wiele elementów.

Uwagi

Jeśli wywołasz jednocześnie AddOrUpdate różne wątki, może być wywoływana wiele razy, addValueFactory ale jej para klucz/wartość może nie zostać dodana do słownika dla każdego wywołania.

W przypadku modyfikacji i operacji zapisu w słowniku używa precyzyjnego blokowania w ConcurrentDictionary<TKey,TValue> celu zapewnienia bezpieczeństwa wątków (operacje odczytu w słowniku są wykonywane w sposób wolny od blokady). Delegaty addValueFactory i updateValueFactory mogą być wykonywane wiele razy, aby sprawdzić, czy wartość została dodana lub zaktualizowana zgodnie z oczekiwaniami. Są one jednak wywoływane poza blokadami, aby uniknąć problemów, które mogą wystąpić podczas wykonywania nieznanego kodu pod blokadą. AddOrUpdate W związku z tym nie jest niepodzielna w odniesieniu do wszystkich innych operacji w ConcurrentDictionary<TKey,TValue> klasie.

Zobacz też

Dotyczy

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

Źródło:: ConcurrentDictionary.cs

Źródło:: ConcurrentDictionary.cs

Źródło:: 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

Parametry

key: TKey

Klucz do dodania lub którego wartość należy zaktualizować.

addValue: TValue

Wartość, która ma zostać dodana dla nieobecnego klucza.

updateValueFactory: Func<TKey,TValue,TValue>

Funkcja używana do generowania nowej wartości dla istniejącego klucza na podstawie istniejącej wartości klucza.

Zwraca

TValue

Nowa wartość klucza. Będzie to albo addValue (jeśli klucz był nieobecny) lub wynik updateValueFactory (jeśli klucz był obecny).

Wyjątki

ArgumentNullException

key lub updateValueFactory to null.

OverflowException

Słownik zawiera zbyt wiele elementów.

Przykłady

Poniższy przykład kodu pokazuje, jak zainicjować metodę ConcurrentDictionary<TKey,TValue> i jak za pomocą metody AddOrUpdate dodać dodatkowy element do kolekcji i zaktualizować istniejące elementy.

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

W przypadku modyfikacji i operacji zapisu w słowniku używa precyzyjnego blokowania w ConcurrentDictionary<TKey,TValue> celu zapewnienia bezpieczeństwa wątków. (Operacje odczytu w słowniku są wykonywane w sposób wolny od blokady). Delegaty addValueFactory i updateValueFactory mogą być wykonywane wiele razy, aby sprawdzić, czy wartość została dodana lub zaktualizowana zgodnie z oczekiwaniami. Są one jednak wywoływane poza blokadami, aby uniknąć problemów, które mogą wystąpić podczas wykonywania nieznanego kodu pod blokadą. AddOrUpdate W związku z tym nie jest niepodzielna w odniesieniu do wszystkich innych operacji w ConcurrentDictionary<TKey,TValue> klasie.

Zobacz też

Dotyczy

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

Źródło:: ConcurrentDictionary.cs

Źródło:: ConcurrentDictionary.cs

Źródło:: ConcurrentDictionary.cs

Używa określonych funkcji i argumentu, aby dodać parę klucz/wartość do ConcurrentDictionary<TKey,TValue> pary, jeśli klucz jeszcze nie istnieje, lub zaktualizować parę klucz/wartość w ConcurrentDictionary<TKey,TValue> przypadku, gdy klucz już istnieje.

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

Parametry typu

TArg

Typ argumentu, który ma być przekazywany do addValueFactory i updateValueFactory.

Parametry

key: TKey

Klucz do dodania lub którego wartość należy zaktualizować.

addValueFactory: Func<TKey,TArg,TValue>

Funkcja używana do generowania wartości dla nieobecnego klucza.

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

Funkcja używana do generowania nowej wartości dla istniejącego klucza na podstawie istniejącej wartości klucza.

factoryArgument: TArg

Argument, który ma być przekazywany do addValueFactory i updateValueFactory.

Zwraca

TValue

Nowa wartość klucza. Będzie to wynik addValueFactory (jeśli klucz był nieobecny) lub wynik updateValueFactory (jeśli klucz był obecny).

Wyjątki

ArgumentNullException

key, addValueFactorylub updateValueFactory jest odwołaniem o wartości null (Nic w Visual Basic).

OverflowException

Słownik zawiera zbyt wiele elementów.

Uwagi

Dotyczy

ConcurrentDictionary<TKey,TValue>.AddOrUpdate Metoda

Definicja

Przeciążenia

Przykłady

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

Parametry

Zwraca

Wyjątki

Uwagi

Zobacz też

Dotyczy

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

Parametry

Zwraca

Wyjątki

Przykłady

Zobacz też

Dotyczy

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

Parametry typu

Parametry

Zwraca

Wyjątki

Uwagi

Dotyczy

Opinia

Dodatkowe zasoby