CODEWITHSUNDEEP
c#.netgenericscollectionsdictionary
user200783
user200783

Reputation: 14346

Getting a KeyValuePair<> directly from a Dictionary<>

I have System.Collections.Generic.Dictionary<A, B> dict where A and B are classes, and an instance A a (where dict.ContainsKey(a) is true).

Is it possible to get the KeyValuePair containing a directly from the Dictionary?
Or do I need to create a new KeyValuePair: new KeyValuePair<A, B>(a, dict[a])?

Upvotes: 48

Views: 78814

Answers (5)

Bob Bryan
Bob Bryan

Reputation: 3847

The accepted answer probably is not going to be too helpful for some common scenarios. Keep in mind that the key is a class. So, in order to access the value object for that key, a key object must already exist. So, what if you have an older key object and the dictionary contains newer information in that key object (but still using the same key fields within that key object)? Or, another quite plausible scenario is what if only the fields used as the key are available and a temporary key object is then created that incorporates those key fields?

The accepted answer uses an extension method to return a KeyValuePair that contains the old key, not the actual key object within the dictionary. As such, it is not going to work for these common cases.

So, Supercat's idea of using a KeyValuePair for the value that includes the key is the only approach that will work in O(1) time. The drawback is that this approach is not only more complex, but it also requires an extra 8 bytes (for a 64-bit OS) for each entry in the dictionary, which is usually not a concern. Looks like Microsoft missed the boat on this one, because they really should provide a method that returns the key in a dictionary.

Here is an example of how to create a dictionary with a KeyValuePair as the value:

    var dict = new Dictionary<a, KeyValuePair<a, b>>();

Then to access it:

    var kvp = dict[key]; // key is of type a.
    a itemKey = kvp.key;
    b itemVal = kvp.value;

So, code like this will work if you have control over the dictionary definition. If you are using 3rd party software, or it is too much trouble to change, then you have to iterate over the entire collection - which is an O(n) operation.

Upvotes: 0

Jon Skeet
Jon Skeet

Reputation: 1504122

You need to create a new KeyValuePair1 - but bear in mind that KVP is a value type (a struct) anyway, so it's not like you're introducing a new inefficiency by doing this. Any method returning a KVP would be creating a copy anyway - you're just creating the instance directly.

You could always add an extension method to IDictionary<TKey, TValue> if you wanted:

public static KeyValuePair<TKey, TValue> GetEntry<TKey, TValue>
    (this IDictionary<TKey, TValue> dictionary,
     TKey key)
{
    return new KeyValuePair<TKey, TValue>(key, dictionary[key]);
}

As noted in comments, it's entirely possible that the key which is stored in the dictionary is not the same as the one provided, just semantically equal - by some semantics which could be customized by an IEqualityComparer (as with a case-insensitive dictionary, for example.) In that case, the code above would not return the actual entry in the dictionary, but an entry with the key you provided to look up. Unfortunately there's no efficient way of finding the original key - you'd have to iterate over the dictionary :(

1 I was aware that you could iterate over the dictionary entries and find the appropriate entry that way, but I can see no reason why you'd ever want to do so when you've got a perfectly good indexer which is O(1) instead of O(N).

Upvotes: 50

Silvan Hofer
Silvan Hofer

Reputation: 1421

For me myDict.AsEnumerable does it...

Upvotes: 0

Oliver Hanappi
Oliver Hanappi

Reputation: 12346

As Dictionary<TKey, TValue> implements IEnumerable<KeyValuePair<TKey, TValue>>, you could use linq:

var pair = _dictionary.SingleOrDefault(p => p.Key == myKey);

Upvotes: 21

johv
johv

Reputation: 4594

We can't get to "IPHone" this way:

var dict = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
               {
                   { "IPHone", "TCP/IP honing tools" }
               };

Console.WriteLine(dict["iPhone"]); // "TCP/IP honing tools"
Console.WriteLine( ??? ); // "IPHone"

There's seems to be no O(1) solution with the current API, but looping through all entries works:

var keyValue = dict.First(p => dict.Comparer.Equals(p.Key, "iPhone"));

Console.WriteLine(keyValue.Key); // "IPHone"
Console.WriteLine(keyValue.Value); // "TCP/IP honing tools"

Or as an extension for the lazy:

[Pure]
public static KeyValuePair<TKey, TValue> GetEntry<TKey, TValue>(this Dictionary<TKey, TValue> dictionary, TKey key)
{
    var comparer = dictionary.Comparer;
    return dictionary.FirstOrDefault(p => comparer.Equals(p.Key, key));
}

Upvotes: 3

Related Questions