How to modify a KeyValuePair value?

I got a problem when I try to modify the value of an item because its only a read only field.

KeyValuePair<Tkey, Tvalue>

I've tried different alternatives like:

Dictionary<Tkey, Tvalue>

but there I have the same problem. Is there a way to set the value field to an new value?

You can't modify it, you can replace it with a new one.

var newEntry = new KeyValuePair<TKey, TValue>(oldEntry.Key, newValue);

or for dictionary:

dictionary[oldEntry.Key] = newValue;

Here, if you want to make KeyValuePair mutable.

Make a custom class.

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 we can make it use in wherever in KeyValuePair.

KeyValuePair<TKey, TValue> is immutable. You need to create a new one with the modifified key or value. What you actually do next depends on your scenario, and what exactly you want to do...

KeyValuePair is immutable,

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();
  }
}

If you have any existing value in KeyValuePair that you want to update, then You can try to remove the existing value and then add the modified value

For an example:

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

You cannot modify a KeyValuePair, but you can modify your dictionary values like this:

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

or like this:

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

The KeyValuePair<TKey, TValue> is a struct and struct in C# is value type and mentioned to be immutable. The reason is obvious, the Dictionary<TKey,TValue> should be a high-performance data structure. Using a reference type instead of value type would use too much memory overhead. Unlike a directly stored value type in a dictionary, in addition the 32bit or 64bit references for each entry in the dictionary would be allocated. These references would be pointed to heap for entry instance. Overall performance would be decreased rapidly.

The Microsoft rules for choosing struct over class which Dictionary<TKey,TValue> satisfies:

✔️ CONSIDER defining a struct instead of a class if instances of the type are small and commonly short-lived or are commonly embedded in other objects.

❌ AVOID defining a struct unless the type has all of the following characteristics:

• It logically represents a single value, similar to primitive types (int, double, etc.).
• It has an instance size under 16 bytes.
• It is immutable.
• It will not have to be boxed frequently.

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

> For Dictionary we can update values in this way based on some conditions.