Question

I’ve written some code to try and describe my concern:

static void Main(string[] args)
{
    IEnumerable<decimal> marks = GetClassMarks();
    IEnumerable<Person> students = GetStudents();

    students.AsParallel().ForAll(p => GenerateClassReport(p, marks));

    Console.ReadKey();
}

GetClassMarks uses yield return in it from my weird data source. Assume that GenerateClassReport does basically a marks.Sum()/marks.Count() to get the class average.

From what I understand, students.AsParallel().ForAll is a parallel foreach.

My worry is what is going to happen inside the GetClassMarks method.

• Is it going to be enumerated once or many times?
• What order is the enumeration going to happen in?
• Do I need to do a .ToList() on marks to make sure it is only hit once?

Answer 1

Is it going to be enumerated once or many times?

Assuming that GenerateClassReport() enumerates marks once, then marks will be enumerated once for each element in students.

What order is the enumeration going to happen in?

Each thread will enumerate the collection in its default order, but several threads will do so concurrently. The concurrent enumeration order is generally unpredictable. Also, you should note that the number of threads is limited and variable, so most likely not all of the enumerations will occur concurrently.

Do I need to do a .ToList() on marks to make sure it is only hit once?

If GetClassMarks() is an iterator (i.e. it uses the yield construct), then its execution will be deferred and it will be called once for each time marks is enumerated (i.e. once for each element in students). If you use IEnumerable<decimal> marks = GetClassMarks().ToList() or if GetClassMarks() internally returns a concrete list or array, then GetClassMarks() will be executed immediately and the results will be stored and enumerated in each of the parallel threads without calling GetClassMarks() again.