Wie ändere ich einen KeyValuePair-Wert?

Ich habe ein Problem, wenn ich versuche, den Wert eines Elements zu ändern, da es nur ein schreibgeschütztes Feld ist.

KeyValuePair<Tkey, Tvalue>

Ich habe verschiedene Alternativen ausprobiert wie:

Dictionary<Tkey, Tvalue>

aber da habe ich das gleiche problem. Gibt es eine Möglichkeit, das Wertefeld auf einen neuen Wert zu setzen?

Sie können es nicht ändern, Sie können es durch ein neues ersetzen.

var newEntry = new KeyValuePair<Tkey, Tvalue>(oldEntry.Key, newValue);

oder für Wörterbuch:

dictionary[oldEntry.Key] = newValue;

Hier, wenn Sie KeyValuePair veränderbar machen möchten.

Erstellen Sie eine benutzerdefinierte Klasse.

public class KeyVal<Key, Val>
{
    public Key Id { get; set; }
    public Val Text { get; set; }

    public KeyVal() { }

    public KeyVal(Key key, Val val)
    {
        this.Id = key;
        this.Text = val;
    }
}

So können wir es überall in KeyValuePair verwenden.

KeyValuePair<TKey, TValue>ist unveränderlich. Sie müssen einen neuen mit dem geänderten Schlüssel oder Wert erstellen. Was Sie als Nächstes tun, hängt von Ihrem Szenario ab und was genau Sie tun möchten ...

KeyValuePair ist unveränderlich,

namespace System.Collections.Generic
{
  [Serializable]
  public struct KeyValuePair<TKey, TValue>
  {
    public KeyValuePair(TKey key, TValue value);
    public TKey Key { get; }
    public TValue Value { get; }
    public override string ToString();
  }
}

Wenn in KeyValuePair ein Wert vorhanden ist, den Sie aktualisieren möchten, können Sie versuchen, den vorhandenen Wert zu entfernen und dann den geänderten Wert hinzuzufügen

Zum Beispiel:

var list = new List<KeyValuePair<string, int>>();
list.Add(new KeyValuePair<string, int>("Cat", 1));
list.Add(new KeyValuePair<string, int>("Dog", 2));
list.Add(new KeyValuePair<string, int>("Rabbit", 4));

int removalStatus = list.RemoveAll(x => x.Key == "Rabbit");

if (removalStatus == 1)
{
    list.Add(new KeyValuePair<string, int>("Rabbit", 5));
}

Das KeyValuePair<TKey, TValue>ist eine Struktur und Struktur in C # ist ein Werttyp und wird als unveränderlich erwähnt. Der Grund liegt auf der Hand, es Dictionary<TKey,TValue>sollte sich um eine Hochleistungsdatenstruktur handeln. Die Verwendung eines Referenztyps anstelle eines Werttyps würde zu viel Speicheraufwand verursachen. Im Gegensatz zu einem direkt gespeicherten Werttyp in einem Wörterbuch würden zusätzlich die 32-Bit- oder 64-Bit-Referenzen für jeden Eintrag im Wörterbuch zugewiesen. Diese Verweise würden auf den Heap für die Eintragsinstanz verweisen. Die Gesamtleistung würde schnell abnehmen.

Die Microsoft-Regeln für die Auswahl von struct anstelle von class erfüllen folgende Kriterien Dictionary<TKey,TValue>:

✔️ BEACHTEN SIE, dass eine Struktur anstelle einer Klasse definiert wird, wenn Instanzen des Typs klein und häufig von kurzer Dauer sind oder häufig in andere Objekte eingebettet sind.

❌ Vermeiden Sie das Definieren einer Struktur, es sei denn, der Typ weist alle folgenden Merkmale auf:

• Es stellt logischerweise einen einzelnen Wert dar, ähnlich wie primitive Typen (int, double usw.).
• Es hat eine Instanzgröße unter 16 Bytes.
• Es ist unveränderlich.
• Es muss nicht häufig verpackt werden.

Sie können ein KeyValuePair nicht ändern, aber Sie können Ihre Wörterbuchwerte wie folgt ändern:

foreach (KeyValuePair<String, int> entry in dict.ToList())
{
    dict[entry.Key] = entry.Value + 1;
}

oder so:

foreach (String entry in dict.Keys.ToList())
{
    dict[entry] = dict[entry] + 1;
};

Dictionary<long, int> _rowItems = new Dictionary<long, int>();
  _rowItems.Where(x => x.Value > 1).ToList().ForEach(x => { _rowItems[x.Key] = x.Value - 1; });

Für Dictionary können wir Werte unter bestimmten Bedingungen auf diese Weise aktualisieren.