ConcurrentDictionary<TKey,TValue>.AddOrUpdate Metod

Definition

Namnområde:: System.Collections.Concurrent

Sammansättningar:: mscorlib.dll, System.Collections.Concurrent.dll

Sammansättningar:: netstandard.dll, System.Collections.Concurrent.dll

Sammansättning:: System.Collections.Concurrent.dll

Sammansättning:: mscorlib.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Lägger till ett nyckel/värde-par i ConcurrentDictionary<TKey,TValue> om nyckeln inte redan finns eller uppdaterar ett nyckel/värde-par i ConcurrentDictionary<TKey,TValue> om nyckeln redan finns.

Överlagringar

Name	Description
AddOrUpdate(TKey, Func<TKey,TValue>, Func<TKey,TValue,TValue>)	Använder de angivna funktionerna för att lägga till ett nyckel/värde-par i ConcurrentDictionary<TKey,TValue> om nyckeln inte redan finns, eller för att uppdatera ett nyckel/värde-par i ConcurrentDictionary<TKey,TValue> om nyckeln redan finns.
AddOrUpdate(TKey, TValue, Func<TKey,TValue,TValue>)	Lägger till ett nyckel/värde-par i ConcurrentDictionary<TKey,TValue> om nyckeln inte redan finns, eller uppdaterar ett nyckel/värde-par i ConcurrentDictionary<TKey,TValue> med hjälp av den angivna funktionen om nyckeln redan finns.
AddOrUpdate<TArg>(TKey, Func<TKey,TArg,TValue>, Func<TKey,TValue,TArg,TValue>, TArg)	Använder de angivna funktionerna och argumentet för att lägga till ett nyckel/värde-par i ConcurrentDictionary<TKey,TValue> om nyckeln inte redan finns, eller för att uppdatera ett nyckel/värde-par i ConcurrentDictionary<TKey,TValue> om nyckeln redan finns.

Exempel

I följande exempel visas hur du anropar AddOrUpdate metoden:

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

Källa:: ConcurrentDictionary.cs

Källa:: ConcurrentDictionary.cs

Källa:: ConcurrentDictionary.cs

Källa:: ConcurrentDictionary.cs

Källa:: ConcurrentDictionary.cs

Använder de angivna funktionerna för att lägga till ett nyckel/värde-par i ConcurrentDictionary<TKey,TValue> om nyckeln inte redan finns, eller för att uppdatera ett nyckel/värde-par i ConcurrentDictionary<TKey,TValue> om nyckeln redan finns.

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

Parametrar

key: TKey

Den nyckel som ska läggas till eller vars värde ska uppdateras.

addValueFactory: Func<TKey,TValue>

Funktionen som används för att generera ett värde för en frånvarande nyckel.

updateValueFactory: Func<TKey,TValue,TValue>

Funktionen som används för att generera ett nytt värde för en befintlig nyckel baserat på nyckelns befintliga värde.

Returer

TValue

Det nya värdet för nyckeln. Detta är antingen resultatet av addValueFactory (om nyckeln var frånvarande) eller resultatet av updateValueFactory (om nyckeln fanns).

Undantag

ArgumentNullException

key, addValueFactory, eller updateValueFactory är null.

OverflowException

Ordlistan innehåller för många element.

Kommentarer

Om du anropar AddOrUpdate samtidigt i olika trådar addValueFactory kan det anropas flera gånger, men dess nyckel/värde-par kanske inte läggs till i ordlistan för varje anrop.

För ändringar och skrivåtgärder i ordlistan ConcurrentDictionary<TKey,TValue> använder finkornig låsning för att säkerställa trådsäkerhet (läsåtgärder i ordlistan utförs på ett låsfritt sätt). Ombuden addValueFactory och updateValueFactory kan köras flera gånger för att verifiera att värdet har lagts till eller uppdaterats som förväntat. De anropas dock utanför låsen för att undvika de problem som kan uppstå vid körning av okänd kod under ett lås. AddOrUpdate Är därför inte atomisk när det gäller alla andra åtgärder i ConcurrentDictionary<TKey,TValue> klassen.

Se även

Gäller för

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

Källa:: ConcurrentDictionary.cs

Källa:: ConcurrentDictionary.cs

Källa:: ConcurrentDictionary.cs

Källa:: ConcurrentDictionary.cs

Källa:: ConcurrentDictionary.cs

Lägger till ett nyckel/värde-par i ConcurrentDictionary<TKey,TValue> om nyckeln inte redan finns, eller uppdaterar ett nyckel/värde-par i ConcurrentDictionary<TKey,TValue> med hjälp av den angivna funktionen om nyckeln redan finns.

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

Parametrar

key: TKey

Den nyckel som ska läggas till eller vars värde ska uppdateras.

addValue: TValue

Värdet som ska läggas till för en frånvarande nyckel.

updateValueFactory: Func<TKey,TValue,TValue>

Funktionen som används för att generera ett nytt värde för en befintlig nyckel baserat på nyckelns befintliga värde.

Returer

TValue

Det nya värdet för nyckeln. Detta blir antingen addValue (om nyckeln var frånvarande) eller resultatet av updateValueFactory (om nyckeln fanns).

Undantag

ArgumentNullException

key eller updateValueFactory är null.

OverflowException

Ordlistan innehåller för många element.

Exempel

I följande kodexempel visas hur du initierar en ConcurrentDictionary<TKey,TValue> och hur du använder metoden AddOrUpdate för att lägga till ytterligare ett objekt i samlingen och uppdatera befintliga objekt.

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

För ändringar och skrivåtgärder i ordlistan ConcurrentDictionary<TKey,TValue> använder finkornig låsning för att säkerställa trådsäkerheten. (Läsåtgärder i ordlistan utförs på ett låsfritt sätt.) Ombuden addValueFactory och updateValueFactory kan köras flera gånger för att verifiera att värdet har lagts till eller uppdaterats som förväntat. De anropas dock utanför låsen för att undvika de problem som kan uppstå vid körning av okänd kod under ett lås. AddOrUpdate Är därför inte atomisk när det gäller alla andra åtgärder i ConcurrentDictionary<TKey,TValue> klassen.

Se även

Gäller för

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

Källa:: ConcurrentDictionary.cs

Källa:: ConcurrentDictionary.cs

Källa:: ConcurrentDictionary.cs

Källa:: ConcurrentDictionary.cs

Källa:: ConcurrentDictionary.cs

Använder de angivna funktionerna och argumentet för att lägga till ett nyckel/värde-par i ConcurrentDictionary<TKey,TValue> om nyckeln inte redan finns, eller för att uppdatera ett nyckel/värde-par i ConcurrentDictionary<TKey,TValue> om nyckeln redan finns.

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) where TArg : allows ref struct;

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

Typparametrar

TArg

Typen av argument som ska skickas till addValueFactory och updateValueFactory.

Parametrar

key: TKey

Den nyckel som ska läggas till eller vars värde ska uppdateras.

addValueFactory: Func<TKey,TArg,TValue>

Funktionen som används för att generera ett värde för en frånvarande nyckel.

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

Funktionen som används för att generera ett nytt värde för en befintlig nyckel baserat på nyckelns befintliga värde.

factoryArgument: TArg

Ett argument att skicka till addValueFactory och updateValueFactory.

Returer

TValue

Det nya värdet för nyckeln. Detta är antingen resultatet av addValueFactory (om nyckeln var frånvarande) eller resultatet av updateValueFactory (om nyckeln fanns).

Undantag

ArgumentNullException

key, addValueFactory eller updateValueFactory är en nullreferens (ingenting i Visual Basic).

OverflowException

Ordlistan innehåller för många element.

Kommentarer

Om du anropar AddOrUpdate samtidigt i olika trådar addValueFactory kan det anropas flera gånger, men dess nyckel/värde-par kanske inte läggs till i ordlistan för varje anrop.

Gäller för

Feedback

Var den här sidan till hjälp?