How do I get the nth element from a Dictionary?

Question

cipher = new Dictionary<char,int>;
cipher.Add( 'a', 324 );
cipher.Add( 'b', 553 );
cipher.Add( 'c', 915 );

How to get the 2nd element? For example, I'd like something like:

KeyValuePair pair = cipher[1]

Where pair contains ( 'b', 553 )

---

Based on the coop's suggestion using a List, things are working:

List<KeyValuePair<char, int>> cipher = new List<KeyValuePair<char, int>>();
cipher.Add( new KeyValuePair<char, int>( 'a', 324 ) );
cipher.Add( new KeyValuePair<char, int>( 'b', 553 ) );
cipher.Add( new KeyValuePair<char, int>( 'c', 915 ) );

KeyValuePair<char, int> pair = cipher[ 1 ];

Assuming that I'm correct that the items stay in the list in the order they are added, I believe that I can just use a List as opposed to a SortedList as suggested.

Ineffable

For those reading this question, I would strongly question if you need to access elements in a dictionary by index. It's worth examining your paradigm. in the same way, one doesn't ask for the 5th record of a DataReader. It's possible you just need to enumerate through the items. If it's not foreach, then use the MoveNext() and Current of the Dictionary.GetEnumerator(). Else use a different, indexible collection object, like the SortedDictionary or an array. Sometimes this Q gets asked from coders from other languages w/o foreach functionality so there's an adaption phase. – Tabaret

Answer 1

The problem is a Dictionary isn't sorted. What you want is a SortedList, which allows you to get values by index as well as key, although you may need to specify your own comparer in the constructor to get the sorting you want. You can then access an ordered list of the Keys and Values, and use various combinations of the IndexOfKey/IndexOfValue methods as needed.

Gerous

You can use the ElementAt(int) extension method, but like thecoop said, it's not ordered so there's not even a guarantee that it'll be the same result between two consecutive calls. – Fleur

It doesn't matter whether the dictionary is sorted or not, you only need a guarantee that the nth key will return the nth value consistently and it does. see my answer below. – Paphlagonia

@Gavimoss: Nope. The Keys and Values properties return IList<T> – Gerous

If using a sorted list, a much easier way is to just use Cipher.GetKey(n) for the nth key and Cipher.GetByIndex(n) for the nth value. – Hedvige

Answer 2

like this:

int n = 0;
int nthValue = cipher[cipher.Keys.ToList()[n]];

note that you will also need a reference to Linq at the top of your page...

using System.Linq;

Paphlagonia

I think that while this might work at the moment, it is worth noting that it might not always work. Correct me if I am wrong grenade, but MSDN says "The order of the keys in the Dictionary<TKey, TValue>.KeyCollection is unspecified". Which means there is no guarantee that the order in this collection will stay consistent. Similarly, iterating over the dictionary MSDN says "The order in which the items are returned is undefined". – Margo

Best to use the new Ordered Dictionary if you can. – Margo

You are absolutely right Ben. However, this is one of those pragmatic approaches that worked back when I wrote it in 2009 and it still works now in 2016. There are lots of smarter people than myself who will explain all the good reasons why this method shouldn't work and shouldn't be used. Please feel free to study all those responses and learn all about it. Alternatively, you can just paste in this code, watch it magically do exactly what I said it would do and go back to doing awesome things with your life. – Paphlagonia

@Paphlagonia With much appreciation for your code and fine prose I'm sorry to say that your method has lost the battle with MSDN - at least with respect to ConcurrentDictionary<T>. As Ben has observed the order in which the items are returned is undefined. – Ballyrag

Answer 3

Do you actually need to look up by the key? If not, use a List<KeyValuePair<char, int>> (or better yet, create a type to encapsulate the char and the int).

Dictionaries aren't inherently sorted - the dictionary implementations which are sorted in .NET are sorted by key, not by insertion order.

If you need to access the collection by both insertion order and key, I'd recommend encapsulating a List and a Dictionary in a single collection type.

Alternatively, if the list is going to be quite short, allow lookup by index just by doing a linear search...

Zounds

I came to this question because I am trying to implement accessibility on a control that's using a dictionary as the collection of the items it needs to draw. So the control does in fact need to look up items by their key, but I also need to be able to look items up by index to override AccessibleObject.GetChild(index As Integer). – Philbo

Maybe now that 5 years have passed, I can finally admit that I cast the downvote purely to make my answer look like it had a better score than yours, in a blatant attempt at rep-grab. In my defense, I was new to SO and also quite a prick. SO doesn't let one correct the error of their ways when a vote gets old either, so I live with my shame. – Paphlagonia

@grenade, I just noticed your heartfelt admission of guilt! I don't know if Jon noticed it or not, but in your honor (and not that he needs another 10 rep points), I have now upvoted his answer to help compensate for your downvote. And simultaneously, by so doing I've now further reduced my own hopes of getting more upvotes on an answer to a question than Jon Skeet! – Ordinate

Answer 4

You can use ElementAt() like this:

cipher.ElementAt(index);

Its better than than the Select option because this way you don't have to loop through the dictionary:

documentation

/// <summary>Returns the element at a specified index in a sequence.</summary>
/// <returns>The element at the specified position in the source sequence.</returns>
/// <param name="source">An <see cref="T:System.Collections.Generic.IEnumerable`1" /> to return an element from.</param>
/// <param name="index">The zero-based index of the element to retrieve.</param>
/// <typeparam name="TSource">The type of the elements of <paramref name="source" />.</typeparam>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="source" /> is null.</exception>
/// <exception cref="T:System.ArgumentOutOfRangeException">
/// <paramref name="index" /> is less than 0 or greater than or equal to the number of elements in <paramref name="source" />.</exception>

Microhenry

can you please explain why this is a better answer than the others posted? it could help someone else later on! – Stadium

@Stadium Invoking ElementAt exploits the built in functionality of the Dictionary class to retrieve the element. The other methods either rely on traversing the IEnumerable or creating a whole new List with all of the elements just to pick up one. – Durston

Answer 5

Just to cling to your original spec for a Dictionary, I slung some code and came up with:

Dictionary<string, string> d = new Dictionary<string, string>();

d.Add("a", "apple");
d.Add("b", "ball");
d.Add("c", "cat");
d.Add("d", "dog");

int t = 0;
foreach (string s in d.Values)
{
    t++;
    if (t == 2) Console.WriteLine(s);
}

and it does seem to write the second item ("ball") to the console repeatably. If you wrapped it into a method call to get the nth element, it would probably work. This is pretty ugly, though. If you could do a SortedList instead, as @thecoop suggests, you'd be better off.

Ordinate

Answer 6

There was a dupe of this question asked here: How to retrieve Nth item in dictionary?. It should be closed soon, but I noticed that the answers here are missing the new OrderedDictionary class.

There is now (as of .NET 4), an OrderedDictionary class. This allows fast lookups while providing ordering. The Item(Int32) method returns the nth element.

Tenuis

Answer 7

You can apply the following LINQ query on your 'cipher' Dictionary

        var cipher = new Dictionary<char, int>();
        cipher.Add('a', 324);
        cipher.Add('b', 553);
        cipher.Add('c', 915);

        var nThValue = cipher.Select((Val, Index) => new { Val, Index })
            .Single(viPair => viPair.Index == 1)   //Selecting dictionary item with it's index using index
            .Val                                   //Extracting KeyValuePair from dictionary item
            .Value;                                //Extracting Value from KeyValuePair

Phobos

Answer 8

This is an old question, but it was helpful to me. Here's an implementation that I used. I wanted the nth element to be based on the insertion order.

public class IndexedDictionary<TKey, TValue> : IEnumerable<TValue> {
  private List<TValue> list = new List<TValue>();
  private Dictionary<TKey, TValue> dict = new Dictionary<TKey, TValue>();

  public TValue this[int index] { get { return list[index]; } }
  public TValue this[TKey key] { get { return dict[key]; } }

  public Dictionary<TKey, TValue>.KeyCollection Keys { get { return dict.Keys; } }

  public int Count { get { return list.Count; } }

  public int IndexOf(TValue item) { return list.IndexOf(item);  }
  public int IndexOfKey(TKey key) { return list.IndexOf(dict[key]); } 

  public void Add(TKey key, TValue value) {
    list.Add(value);
    dict.Add(key, value);
  }

  IEnumerator<TValue> IEnumerable<TValue>.GetEnumerator() {
    return list.GetEnumerator();
  }

  IEnumerator IEnumerable.GetEnumerator() {
    return list.GetEnumerator();
  }
}

Endocarditis