ConcurrentDictionary<TKey,TValue>.TryRemove Metoda

Definicja

Przestrzeń nazw:

System.Collections.Concurrent

Zestaw:

System.Collections.Concurrent.dll

Przeciążenia

TryRemove(TKey, TValue)	Próbuje usunąć i zwrócić wartość, która ma określony klucz z .ConcurrentDictionary<TKey,TValue>
TryRemove(KeyValuePair<TKey,TValue>)	Usuwa klucz i wartość ze słownika.

TryRemove(TKey, TValue)

Źródło:

ConcurrentDictionary.cs

Próbuje usunąć i zwrócić wartość, która ma określony klucz z .ConcurrentDictionary<TKey,TValue>

public:
 bool TryRemove(TKey key, [Runtime::InteropServices::Out] TValue % value);

public bool TryRemove (TKey key, out TValue value);

member this.TryRemove : 'Key * 'Value -> bool

Public Function TryRemove (key As TKey, ByRef value As TValue) As Boolean

Parametry

key

TKey

Klucz elementu do usunięcia i zwrócenia.

value

TValue

Gdy ta metoda zwraca wartość , zawiera obiekt usunięty z ConcurrentDictionary<TKey,TValue>obiektu lub wartość TValue domyślną typu, jeśli key nie istnieje.

Zwraca

Boolean

true jeśli obiekt został pomyślnie usunięty; w przeciwnym razie , false.

Wyjątki

ArgumentNullException

key to null.

Przykłady

W poniższym przykładzie pokazano, jak wywołać metodę ConcurrentDictionary<TKey,TValue>.TryRemove :

class CD_TryXYZ
{
        // Demonstrates:
        //      ConcurrentDictionary<TKey, TValue>.TryAdd()
        //      ConcurrentDictionary<TKey, TValue>.TryUpdate()
        //      ConcurrentDictionary<TKey, TValue>.TryRemove()
        static void Main()
        {
            int numFailures = 0; // for bookkeeping

            // Construct an empty dictionary
            ConcurrentDictionary<int, String> cd = new ConcurrentDictionary<int, string>();

            // This should work
            if (!cd.TryAdd(1, "one"))
            {
                Console.WriteLine("CD.TryAdd() failed when it should have succeeded");
                numFailures++;
            }

            // This shouldn't work -- key 1 is already in use
            if (cd.TryAdd(1, "uno"))
            {
                Console.WriteLine("CD.TryAdd() succeeded when it should have failed");
                numFailures++;
            }

            // Now change the value for key 1 from "one" to "uno" -- should work
            if (!cd.TryUpdate(1, "uno", "one"))
            {
                Console.WriteLine("CD.TryUpdate() failed when it should have succeeded");
                numFailures++;
            }

            // Try to change the value for key 1 from "eine" to "one"
            //    -- this shouldn't work, because the current value isn't "eine"
            if (cd.TryUpdate(1, "one", "eine"))
            {
                Console.WriteLine("CD.TryUpdate() succeeded when it should have failed");
                numFailures++;
            }

            // Remove key/value for key 1.  Should work.
            string value1;
            if (!cd.TryRemove(1, out value1))
            {
                Console.WriteLine("CD.TryRemove() failed when it should have succeeded");
                numFailures++;
            }

            // Remove key/value for key 1.  Shouldn't work, because I already removed it
            string value2;
            if (cd.TryRemove(1, out value2))
            {
                Console.WriteLine("CD.TryRemove() succeeded when it should have failed");
                numFailures++;
            }

            // If nothing went wrong, say so
            if (numFailures == 0) Console.WriteLine("  OK!");
        }
}

// Demonstrates:
//      ConcurrentDictionary<TKey, TValue>.TryAdd()
//      ConcurrentDictionary<TKey, TValue>.TryUpdate()
//      ConcurrentDictionary<TKey, TValue>.TryRemove()

let mutable numFailures = 0 // for bookkeeping

// Construct an empty dictionary
let cd = ConcurrentDictionary<int, string>()

// This should work
if cd.TryAdd(1, "one") |> not then
    printfn "CD.TryAdd() failed when it should have succeeded"
    numFailures <- numFailures + 1

// This shouldn't work -- key 1 is already in use
if cd.TryAdd(1, "uno") then
    printfn "CD.TryAdd() succeeded when it should have failed"
    numFailures <- numFailures + 1

// Now change the value for key 1 from "one" to "uno" -- should work
if cd.TryUpdate(1, "uno", "one") |> not then
    printfn "CD.TryUpdate() failed when it should have succeeded"
    numFailures <- numFailures + 1

// Try to change the value for key 1 from "eine" to "one"
//    -- this shouldn't work, because the current value isn't "eine"
if cd.TryUpdate(1, "one", "eine") then
    printfn "CD.TryUpdate() succeeded when it should have failed"
    numFailures <- numFailures + 1

// Remove key/value for key 1.  Should work.
let mutable value1 = ""

if cd.TryRemove(1, &value1) |> not then
    printfn "CD.TryRemove() failed when it should have succeeded"
    numFailures <- numFailures + 1

// Remove key/value for key 1.  Shouldn't work, because I already removed it
let mutable value2 = ""

if cd.TryRemove(1, &value2) then
    printfn "CD.TryRemove() succeeded when it should have failed"
    numFailures <- numFailures + 1

// If nothing went wrong, say so
if numFailures = 0 then
    printfn "  OK!"

'Imports System.Collections.Concurrent

Class CD_TryXYZ

    ' Demonstrates:
    ' ConcurrentDictionary<TKey, TValue>.TryAdd()
    ' ConcurrentDictionary<TKey, TValue>.TryUpdate()
    ' ConcurrentDictionary<TKey, TValue>.TryRemove()
    Shared Sub Main()
        Dim numFailures As Integer = 0
        ' for bookkeeping
        ' Construct an empty dictionary
        Dim cd As ConcurrentDictionary(Of Integer, [String]) = New ConcurrentDictionary(Of Integer, String)()

        ' This should work
        If Not cd.TryAdd(1, "one") Then
            Console.WriteLine("CD.TryAdd() failed when it should have succeeded")
            numFailures += 1
        End If

        ' This shouldn't work -- key 1 is already in use
        If cd.TryAdd(1, "uno") Then
            Console.WriteLine("CD.TryAdd() succeeded when it should have failed")
            numFailures += 1
        End If

        ' Now change the value for key 1 from "one" to "uno" -- should work
        If Not cd.TryUpdate(1, "uno", "one") Then
            Console.WriteLine("CD.TryUpdate() failed when it should have succeeded")
            numFailures += 1
        End If

        ' Try to change the value for key 1 from "eine" to "one" 
        ' -- this shouldn't work, because the current value isn't "eine"
        If cd.TryUpdate(1, "one", "eine") Then
            Console.WriteLine("CD.TryUpdate() succeeded when it should have failed")
            numFailures += 1
        End If

        ' Remove key/value for key 1. Should work.
        Dim value1 As String = ""
        If Not cd.TryRemove(1, value1) Then
            Console.WriteLine("CD.TryRemove() failed when it should have succeeded")
            numFailures += 1
        End If

        ' Remove key/value for key 1. Shouldn't work, because I already removed it
        Dim value2 As String = ""
        If cd.TryRemove(1, value2) Then
            Console.WriteLine("CD.TryRemove() succeeded when it should have failed")
            numFailures += 1
        End If

        ' If nothing went wrong, say so
        If numFailures = 0 Then
            Console.WriteLine(" OK!")
        End If
    End Sub
End Class

Zobacz też

• Kolekcje bezpieczne wątkowo
• Instrukcje: Dodawanie elementów do kolekcji ConcurrentDictionary i ich usuwanie

TryRemove(KeyValuePair<TKey,TValue>)

Źródło:

ConcurrentDictionary.cs

Usuwa klucz i wartość ze słownika.

public:
 bool TryRemove(System::Collections::Generic::KeyValuePair<TKey, TValue> item);

public bool TryRemove (System.Collections.Generic.KeyValuePair<TKey,TValue> item);

member this.TryRemove : System.Collections.Generic.KeyValuePair<'Key, 'Value> -> bool

Public Function TryRemove (item As KeyValuePair(Of TKey, TValue)) As Boolean

Parametry

item

KeyValuePair<TKey,TValue>

Reprezentujący KeyValuePair<TKey,TValue> klucz i wartość do usunięcia.

Zwraca

Boolean

truejeśli klucz i wartość reprezentowana przez element item zostaną pomyślnie znalezione i usunięte; w przeciwnym razie . false

Wyjątki

ArgumentNullException

Właściwość Key właściwości item to null.

Uwagi

Zarówno spekulowany klucz, jak i wartość muszą być zgodne z wpisem w słowniku, który ma zostać usunięty.

Klucz jest porównywany przy użyciu modułu porównującego słownika (lub domyślnego modułu porównującego TKey , jeśli nie podano modułu porównującego do słownika podczas jego konstruowania). Wartość jest porównywana przy użyciu domyślnego porównującego dla elementu TValue.