Parallel.For Method (Int32, Int32, Action<Int32>)

Previous code snippet by Luke Puppett is nice, but suffers with one drawback: locking. It is very resource expensive and inefficient, and should be used in cases where there is absolutely no other way to achieve thread safety. In this case you could achieve maintaining the original order and do away without locking like this:

            int from = 0;
            int to = 200000;

            int[] array = new int[to];
            Parallel.For(from, to, index =>
            {
                array[index] = index;
            });
            List<int> list = array.ToList();

In other words, declare an array with certain upper boundary, and then keep inserting desired items at their original collection's positional index: "to" variable is a count of the items in the original collection. Here is unit test for checking whether or not some items made in the list in the wrong order:


            Parallel.For(from, to, item =>
            {
                Assert.IsTrue(list.IndexOf(item) == item, string.Format("Item {0} is placed at index {1} while should have been placed at index {2}",
                     item, list.IndexOf(item), item));
            });

The Unit test as shown above validates whether or not any items occupy wrong position and it runs somewhat slow: I guess the Assert is not very fast part. The original Parallel loop is very fast even with 200K iterations.

Note in the example how the range is inclusive and exclusive, i.e. for an entire collection of 3 items it would be For(0, 3, ...) and not For(0, 2, ...) as it would be for a normal For loop.

This example gets entities from a collection of database ids, while maintaining the original order of ids. It's a good candidate for using a Semaphore to prevent calls rinsing the database pool and I would add the code but this comment editor is so abysmal I am unable to.

var sortedByIndex = new SortedDictionary<int, T>();
System.Threading.Tasks.Parallel.For(0, entityIds.Count(), i =>
    {
        var k = entityIds[i];
        try
        {
            var entity = (new EntityGetter()).Get(k);
            if (entity != null)
            {
                lock (sortedByIndex)
                {
                    sortedByIndex.Add(i, entity);
                }
            }
        }
        catch (Exception e)
        {
            // handle
        }
    });