¿Cómo modificar un valor de KeyValuePair?

Tengo un problema cuando intento modificar el valor de un elemento porque es solo un campo de solo lectura.

KeyValuePair<Tkey, Tvalue>

He probado diferentes alternativas como:

Dictionary<Tkey, Tvalue>

pero ahí tengo el mismo problema. ¿Hay alguna forma de establecer el campo de valor en un nuevo valor?

No puede modificarlo, puede reemplazarlo por uno nuevo.

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

o para diccionario:

dictionary[oldEntry.Key] = newValue;

Aquí, si desea hacer que KeyValuePair sea mutable.

Haz una clase personalizada.

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

para que podamos usarlo en cualquier lugar de KeyValuePair.

KeyValuePair<TKey, TValue>es inmutable. Debe crear uno nuevo con la clave o el valor modificado. Lo que hagas a continuación depende de tu escenario y de lo que quieras hacer exactamente ...

KeyValuePair es inmutable,

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

Si tiene algún valor existente en KeyValuePair que desea actualizar, puede intentar eliminar el valor existente y luego agregar el valor modificado

Para un ejemplo:

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

El KeyValuePair<TKey, TValue>es un struct y struct en C # es tipo de valor y se menciona a ser inmutable. La razón es obvia, Dictionary<TKey,TValue>debería ser una estructura de datos de alto rendimiento. Usar un tipo de referencia en lugar de un tipo de valor usaría demasiada sobrecarga de memoria. A diferencia de un tipo de valor almacenado directamente en un diccionario, además se asignarían las referencias de 32 bits o 64 bits para cada entrada en el diccionario. Estas referencias se apuntarían al montón como instancia de entrada. El rendimiento general se reduciría rápidamente.

Las reglas de Microsoft para elegir estructura sobre clase que Dictionary<TKey,TValue>satisfaga:

✔️ CONSIDERE definir una estructura en lugar de una clase si las instancias del tipo son pequeñas y, por lo general, de corta duración o están habitualmente incrustadas en otros objetos.

❌ EVITE definir una estructura a menos que el tipo tenga todas las siguientes características:

• Representa lógicamente un valor único, similar a los tipos primitivos (int, double, etc.).
• Tiene un tamaño de instancia inferior a 16 bytes.
• Es inmutable.
• No tendrá que empaquetarse con frecuencia.

No puede modificar un KeyValuePair, pero puede modificar los valores de su diccionario de esta manera:

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

o así:

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

Para el Diccionario, podemos actualizar los valores de esta manera en función de algunas condiciones.