How to enumerate list items randomly in C#?

Question

I have a challenging question for you big experts. This has not yet a practical usage in my code, but comes from an idea I just had.

If I have an IList<T>, how do I implement an enumerator that randomly walks the list and that can be used by multiple threads simultaneously?

For example, if I have elements A, B, C, D, E, F and two concurrent threads performing a for-each loop on the list with a ReaderLock acquired (so I'm sure nobody else will touch the list thus causing an exception), I would like their respective cycles to return, for example, B, E, C, D, A, F and E, B, D, C, A, F.

The reason why I need this is because I need to place locks on List<SslStream> elements to send data to clients, because SslStream is not thread-safe. Picking elements randomly (but making sure I pick them all) reduces the lock conflict probabilities and is supposed to improve I/O-bound operations performance.

Please keep in mind that even if I told you why I need such an enumerator, I still like challenge. There can be other ways of sending the same data to multiple clients, but my question remains the same :) :)

Answer 1

Something like this (obviously needs to be productionized):

class RandomList<T> : IEnumerable<T> {
     private readonly IList<T> list;
     private readonly Random rg;
     private readonly object sync = new Object();
     public RandomList(IList<T> list) : this(list, new Random()) { }

     public RandomList(IList<T> list, Random rg) {
         Contract.Requires<ArgumentNullException>(list != null);
         Contract.Requires<ArgumentNullException>(rg != null);
         this.list = list;
         this.rg = rg;
     }

     public IEnumerator<T> GetEnumerator() {
         List<int> indexes;
         // Random.Next is not guaranteed to be thread-safe
         lock (sync) {
             indexes = Enumerable
                 .Range(0, this.list.Count)
                 .OrderBy(x => this.rg.Next())
                 .ToList();
         }
         foreach (var index in indexes) {
             yield return this.list[index];
         }
     }
}
      IEnumerator IEnumerable.GetEnumerator() {
          return GetEnumerator();
      }
}

Answer 2

Create an array of the same size as your list, initially populate it as a[i] = i and then shuffle using a Fisher Yates algorithm.

Your enumerator can then iterate over this array, returning elements from your source list at the random index provided.

Answer 3

This should do it:

public static IEnumerable<T> YieldRandom<T>(this IList<T> items) {
    Random random = new Random();
    HashSet<int> yielded = new HashSet<int>(items.Count);

    for (int i=0; i<items.Count; i++) {
        // find an index we haven't yielded yet
        int yieldIndex;
        do {
            yieldIndex = random.Next(items.Count);
        }
        while (yielded.Contains(yieldIndex));

        yielded.Add(yieldIndex);
        yield return items[yieldIndex];
    }
}

I'm sure more LINQ could be used in places :)