ConcurrentDictionary<TKey,TValue>.AddOrUpdate Metode

Referensi

Definisi

Ruang nama:: System.Collections.Concurrent

Rakitan:: System.Collections.Concurrent.dll

Rakitan:: mscorlib.dll

Rakitan:: netstandard.dll

Penting

Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.

Menambahkan pasangan kunci/nilai ke ConcurrentDictionary<TKey,TValue> jika kunci belum ada, atau memperbarui pasangan kunci/nilai di ConcurrentDictionary<TKey,TValue> jika kunci sudah ada.

Overload

AddOrUpdate(TKey, Func<TKey,TValue>, Func<TKey,TValue,TValue>)	Menggunakan fungsi yang ditentukan untuk menambahkan pasangan kunci/nilai ke ConcurrentDictionary<TKey,TValue> jika kunci belum ada, atau untuk memperbarui pasangan kunci/nilai di ConcurrentDictionary<TKey,TValue> jika kunci sudah ada.
AddOrUpdate(TKey, TValue, Func<TKey,TValue,TValue>)	Menambahkan pasangan kunci/nilai ke ConcurrentDictionary<TKey,TValue> jika kunci belum ada, atau memperbarui pasangan kunci/nilai di ConcurrentDictionary<TKey,TValue> dengan menggunakan fungsi yang ditentukan jika kunci sudah ada.
AddOrUpdate<TArg>(TKey, Func<TKey,TArg,TValue>, Func<TKey,TValue,TArg,TValue>, TArg)	Menggunakan fungsi dan argumen yang ditentukan untuk menambahkan pasangan kunci/nilai ke ConcurrentDictionary<TKey,TValue> jika kunci belum ada, atau untuk memperbarui pasangan kunci/nilai dalam ConcurrentDictionary<TKey,TValue> jika kunci sudah ada.

Contoh

Contoh berikut menunjukkan cara memanggil AddOrUpdate metode :

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

Sumber:: ConcurrentDictionary.cs

Sumber:: ConcurrentDictionary.cs

Sumber:: ConcurrentDictionary.cs

Menggunakan fungsi yang ditentukan untuk menambahkan pasangan kunci/nilai ke ConcurrentDictionary<TKey,TValue> jika kunci belum ada, atau untuk memperbarui pasangan kunci/nilai di ConcurrentDictionary<TKey,TValue> jika kunci sudah ada.

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

Parameter

key: TKey

Kunci yang akan ditambahkan atau yang nilainya harus diperbarui.

addValueFactory: Func<TKey,TValue>

Fungsi yang digunakan untuk menghasilkan nilai untuk kunci yang tidak ada.

updateValueFactory: Func<TKey,TValue,TValue>

Fungsi yang digunakan untuk menghasilkan nilai baru untuk kunci yang ada berdasarkan nilai kunci yang ada.

Mengembalikan

TValue

Nilai baru untuk kunci. Ini akan menjadi hasil ( addValueFactory jika kunci tidak ada) atau hasilnya updateValueFactory (jika kunci ada).

Pengecualian

ArgumentNullException

key, addValueFactory, atau updateValueFactory adalah null.

OverflowException

Kamus berisi terlalu banyak elemen.

Keterangan

Jika Anda memanggil AddOrUpdate secara bersamaan pada utas yang berbeda, addValueFactory dapat dipanggil beberapa kali, tetapi pasangan kunci/nilainya mungkin tidak ditambahkan ke kamus untuk setiap panggilan.

Untuk modifikasi dan operasi tulis pada kamus, ConcurrentDictionary<TKey,TValue> gunakan penguncian mendetail untuk memastikan keamanan utas (operasi baca pada kamus dilakukan dengan cara bebas kunci). Delegasi addValueFactory dan updateValueFactory dapat dijalankan beberapa kali untuk memverifikasi nilai ditambahkan atau diperbarui seperti yang diharapkan. Namun, mereka dipanggil di luar kunci untuk menghindari masalah yang dapat timbul dari mengeksekusi kode yang tidak diketahui di bawah kunci. Oleh karena itu, AddOrUpdate tidak atomik sehubungan dengan semua operasi lain di ConcurrentDictionary<TKey,TValue> kelas .

Lihat juga

Berlaku untuk

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

Sumber:: ConcurrentDictionary.cs

Sumber:: ConcurrentDictionary.cs

Sumber:: ConcurrentDictionary.cs

Menambahkan pasangan kunci/nilai ke ConcurrentDictionary<TKey,TValue> jika kunci belum ada, atau memperbarui pasangan kunci/nilai di ConcurrentDictionary<TKey,TValue> dengan menggunakan fungsi yang ditentukan jika kunci sudah ada.

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

Parameter

key: TKey

Kunci yang akan ditambahkan atau yang nilainya harus diperbarui.

addValue: TValue

Nilai yang akan ditambahkan untuk kunci yang tidak ada.

updateValueFactory: Func<TKey,TValue,TValue>

Fungsi yang digunakan untuk menghasilkan nilai baru untuk kunci yang ada berdasarkan nilai kunci yang ada.

Mengembalikan

TValue

Nilai baru untuk kunci. Ini akan menjadi addValue (jika kunci tidak ada) atau hasil ( updateValueFactory jika kunci ada).

Pengecualian

ArgumentNullException

key atau updateValueFactory adalah null.

OverflowException

Kamus berisi terlalu banyak elemen.

Contoh

Contoh kode berikut menunjukkan cara menginisialisasi ConcurrentDictionary<TKey,TValue> dan cara menggunakan metode AddOrUpdate untuk menambahkan item tambahan ke koleksi, dan memperbarui item yang ada.

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

Untuk modifikasi dan operasi tulis pada kamus, ConcurrentDictionary<TKey,TValue> gunakan penguncian mendetail untuk memastikan keamanan utas. (Operasi baca pada kamus dilakukan dengan cara bebas kunci.) Delegasi addValueFactory dan updateValueFactory dapat dijalankan beberapa kali untuk memverifikasi nilai ditambahkan atau diperbarui seperti yang diharapkan. Namun, mereka dipanggil di luar kunci untuk menghindari masalah yang dapat timbul dari mengeksekusi kode yang tidak diketahui di bawah kunci. Oleh karena itu, AddOrUpdate tidak atomik sehubungan dengan semua operasi lain di ConcurrentDictionary<TKey,TValue> kelas .

Lihat juga

Berlaku untuk

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

Sumber:: ConcurrentDictionary.cs

Sumber:: ConcurrentDictionary.cs

Sumber:: ConcurrentDictionary.cs

Menggunakan fungsi dan argumen yang ditentukan untuk menambahkan pasangan kunci/nilai ke ConcurrentDictionary<TKey,TValue> jika kunci belum ada, atau untuk memperbarui pasangan kunci/nilai dalam ConcurrentDictionary<TKey,TValue> jika kunci sudah ada.

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

Jenis parameter

TArg

Jenis argumen untuk diteruskan ke addValueFactory dan updateValueFactory.

Parameter

key: TKey

Kunci yang akan ditambahkan atau yang nilainya harus diperbarui.

addValueFactory: Func<TKey,TArg,TValue>

Fungsi yang digunakan untuk menghasilkan nilai untuk kunci yang tidak ada.

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

Fungsi yang digunakan untuk menghasilkan nilai baru untuk kunci yang ada berdasarkan nilai kunci yang ada.

factoryArgument: TArg

Argumen untuk diteruskan ke addValueFactory dan updateValueFactory.

Mengembalikan

TValue

Nilai baru untuk kunci. Ini akan menjadi hasil ( addValueFactory jika kunci tidak ada) atau hasilnya updateValueFactory (jika kunci ada).

Pengecualian

ArgumentNullException

key, addValueFactory, atau updateValueFactory adalah referensi null (Tidak ada di Visual Basic).

OverflowException

Kamus berisi terlalu banyak elemen.

Keterangan

Berlaku untuk

ConcurrentDictionary<TKey,TValue>.AddOrUpdate Metode

Definisi

Overload

Contoh

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

Parameter

Mengembalikan

Pengecualian

Keterangan

Lihat juga

Berlaku untuk

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

Parameter

Mengembalikan

Pengecualian

Contoh

Lihat juga

Berlaku untuk

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

Jenis parameter

Parameter

Mengembalikan

Pengecualian

Keterangan

Berlaku untuk

Saran dan Komentar

Sumber Daya Tambahan: