The property KeyValuePair.Value has no setter

Question

I'm using a Dictionary<int, KeyValuePair<bool, int>> to hold data.

From time to time I need to increment the int in the KeyValuePair, but it won't let me, because it has no setter. Is there a way to increment it?

Code sample:

Dictionary<int, KeyValuePair<bool, int>> mDictionary = 
    new Dictionary<int, KeyValuePair<bool, int>>();

mDictionary[trapType].Value++;
//Error: The property KeyValuePair<TKey, Tvalue>>.Value has no setter

score 22 · Accepted Answer · answered May 14 '12 at 08:47

22

Is there a way to increment it?

No. KeyValuePair is immutable - it's also a value type, so changing the value of the Value property after creating a copy wouldn't help anyway.

You'd have to write something like this:

var existingValue = mDictionary[trapType];
var newValue = new KeyValuePair<bool, int>(existingValue.Key,
                                           existingValue.Value + 1);
mDictionary[trapType] = newValue;

It's pretty ugly though - do you really need the value to be a KeyValuePair?

answered May 14 '12 at 08:47

Jon Skeet

1,421,763
867
9,128
9,194

3

I'd suggest `Tuple`. Shortest way to create one would be `Tuple.Create(existingValue.Key, existingValue.Value + 1)`. Although creating a class, if logical, would be better to avoid unnecessary `new()`'s. – SimpleVar May 14 '12 at 08:50
@YoryeNathan: Yes, that would probably be appropriate - or a separate type with property names which reflect the real meanings of the `bool` and `int`. (I see you've edited your comment for that too :) – Jon Skeet May 14 '12 at 08:52
Yes, although I can imagine cases where this would be used in a small scope for some quirky algorithm, in which case I would personally prefer an anonymous type. – SimpleVar May 14 '12 at 08:55

score 0 · Answer 2 · answered May 14 '12 at 08:47

0

mDictionary[trapType] = new KeyValuePair<bool, int>(mDictionary[trapType].Key, mDictionary[trapType].Value+1)

answered May 14 '12 at 08:47

Tilak

30,108
19
83
131

score 0 · Answer 3 · answered May 14 '12 at 08:50

0

KeyValuePair tends just to be used as an iterator value for dictionaries. You're better off defining your own type if you want it to be mutable.

answered May 14 '12 at 08:50

Tim Rogers

21,297
6
52
68

score 0 · Answer 4 · edited Jun 08 '18 at 14:18

You will need to construct a new key value pair.

mDictionary[trapType] = new KeyValuePair<bool,int>(mDictionary[trapType].Key,mDictionary[trapType].Value +1);

However if you are on .NET 4, I'd suggest you use a Tuple instead of a key value pair if what you are trying to do is simply to have an object that holds two other values. Ie if there's no key-value relationship between the two. Then code would then be:

mDictionary[trapType] = Tuple.Create(mDictionary[trapType].Item1,mDictionary[trapType].Item2 +1);

score 0 · Answer 5 · answered Jun 19 '12 at 16:23

0

another solution is to create a new dictionary and pass the new values and keys to it:

foreach (var d in existingDic)
                    newDic.Add(d.Key, d.Value + 1);

answered Jun 19 '12 at 16:23

mashta gidi

849
1
10
30

score 0 · Answer 6 · answered Dec 12 '12 at 19:52

Conceptually, KeyValuePair<TKey,TValue> is just a pair of variables, Key and Value. Had Microsoft implemented it with exposed public fields Key and Value, the semantics of it would have been perfect; when used as a ForEach control variable it would have been immutable, but one could have updated the Key or Value field of an ordinary variable or array element without having to update the other.

Unfortunately, Microsoft seems to have been unwilling to have framework types expose any public fields, even for types like KeyValuePair<TKey,TValue> or Drawing.Rectangle whose semantics dictate that (1) the type must be a struct; (2) its entire state is visible in a fixed set of properties (there may be other computed properties beyond those which define an object's state), and (3) those properties may be assigned any combination of values suitable for their types. Consequently, Microsoft only considered the possibilities of exposing the members comprising the types' state as read-only properties, or as read-write properties. Using read-write properties would mean that code like:

for each (var item in myDictionary)
    item.Value += 1;

or

...assuming MyList is a List<Drawing.Rectangle>
MyList[3].Width += 9;

would be interpreted by the existing C# compiler as either

for each (var item in myDictionary)
{ var temp = item; temp .Value += 1; }

or

...assuming MyList is a List<Drawing.Rectangle>
{ temp = MyList[3]; temp.Width += 9; }

both of yield horrible behavior which is almost certainly not what the programmer intended. The implementers of .net decided that the value of having the members of KeyValuePair<TKey,TValue> be individually mutable did not justify the danger posed by the former, but the usefulness of modifying individual members of Rectangle was sufficient to justify the danger posed by second. Note that neither example would have had to pose any danger had the types used exposed fields rather than properties, since writing to a field of a temporary struct has never been permissible, even when calling property setters was.

score 0 · Answer 7 · answered Sep 15 '17 at 10:54

As previously mentioned, the KeyValuePair is immutable. I thought it was worth adding here a mutable implementation:

public class MutableKeyValuePair<KeyType, ValueType>
    {
        public KeyType Key { get; set; }
        public ValueType Value { get; set; }

        public MutableKeyValuePair() { }

        public MutableKeyValuePair(KeyType key, ValueType val)
        {
            Key = key;
            Value = val;
        }
    }

The property KeyValuePair.Value has no setter

7 Answers7

Linked