C# Snippet - Shuffling a Dictionary [Beginner]

Randomizing something can be a daunting task, especially with all the algorithms out there. However, sometimes you just need to shuffle things up, in a simple, yet effective manner. Today we are going to take a quick look at an easy and simple way to randomize a dictionary, which is most likely something that you may be using in a complex application.

The tricky thing about ordering dictionaries is that...well they are not ordered to begin with. Typically they are a chaotic collection of key/value pairs. There is no first element or last element, just elements. This is why it is a little tricky to randomize them.

Before we get started, we need to build a quick dictionary. For this tutorial, we will be doing an extremely simple string/int dictionary, but rest assured the steps we take can be used for any kind of dictionary you can come up with, no matter what object types you use.

Dictionary<String, int> origin = new Dictionary<string, int>();

for (int i = 0; i < 100; i++)
{
  origin.Add("Item " + i.ToString(), i);
}

// "Item 0" -> 0
// "Item 1" -> 1
// "Item 2" -> 2
// ...

So now we have a quick and dirty 100-element dictionary that we can use.

Most collections in .Net implement the IEnumerable interface. Among other useful things, this interface allows us to use the OrderBy extension method provided by the System.Linq namespace. As you may have guessed, this takes a collection and orders it. To make things even easier, this function allows some pretty fancy Lamda functions, so we can actually order our Dictionary with just one line of code.

However, we want to shuffle our Dictionary. To do this, we have to order it by a random value. To do this we basically pass in a function that chooses a random number for the index. When we combine the ordering and random index together, our code looks something like so:

using System.Linq;

...

Random rand = new Random();
origin = origin.OrderBy(x => rand.Next())
  .ToDictionary(item => item.Key, item => item.Value);

It's actually not that difficult. You just pass in a lambda function that chooses a random number, then convert the reordered collection back into a dictionary. With just two lines we can shuffle our Dictionary. It may seem a little silly that we need to "reconvert" our object back to a Dictionary, but there is a reason why we do this.

The OrderBy function returns an IEnumerable of the original type - in this case KeyValuePair. So once we order our collection, it needs to be converted from a collection of KeyValuePairs to an actual Dictionary object.

So now, in order to make life even easier, I have created a simple extension method that will allow us to just call Shuffle() on our Dictionary. It is a generic function as well, so you will be able to use it on any type of Dictionary you might have:

public static class DictionaryExtensions
{
   public static Dictionary<TKey, TValue> Shuffle<TKey, TValue>(
      this Dictionary<TKey, TValue> source)
   {
      Random r = new Random();
      return source.OrderBy(x => r.Next())
         .ToDictionary(item => item.Key, item => item.Value);
   }
}

...

Dictionary<string, int> source = new Dictionary<string, int>();
for (int i = 0; i < 5; i++)
{
   source.Add("Item " + i, i);
}

// "Item 0" -> 0
// "Item 1" -> 1
// "Item 2" -> 2
// "Item 3" -> 3
// "Item 4" -> 4

Dictionary<string, int> shuffled = source.Shuffle();

// "Item 4" -> 4
// "Item 2" -> 2
// "Item 0" -> 0
// "Item 1" -> 1
// "Item 3" -> 3

And there we have it, a simple extension method that will allow you to shuffle any Dictionary you may have. It's not a terrible complicated method, but hey, it is pretty useful.