LINQ query and sub-query enumeration count in C#?

.net, .net-4.0, c#, linq

Solution

It will be iterated 6 times. Once for the `Where` and once per element for the `Max`.

The code to demonstrate this:

private static int count = 0;
public static IEnumerable<int> Regurgitate(IEnumerable<int> source)
{
    count++;
    Console.WriteLine("Iterated sequence {0} times", count);
    foreach (int i in source)
        yield return i;
}

int[] Numbers = new int[5] { 5, 2, 3, 4, 5 };

IEnumerable<int> sequence = Regurgitate(Numbers);

var query = from a in sequence
            where a == sequence.Max(n => n)
            select a;

It will print "Iterated sequence 6 times".

We could make a more general purpose wrapper that is more flexible, if you're planning to use this to experiment with other cases:

public class EnumerableWrapper<T> : IEnumerable<T>
{
    private IEnumerable<T> source;
    public EnumerableWrapper(IEnumerable<T> source)
    {
        this.source = source;
    }

    public int IterationsStarted { get; private set; }
    public int NumMoveNexts { get; private set; }
    public int IterationsFinished { get; private set; }

    public IEnumerator<T> GetEnumerator()
    {
        IterationsStarted++;

        foreach (T item in source)
        {
            NumMoveNexts++;
            yield return item;
        }

        IterationsFinished++;
    }

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

    public override string ToString()
    {
        return string.Format(
@"Iterations Started: {0}
Iterations Finished: {1}
Number of move next calls: {2}"
, IterationsStarted, IterationsFinished, NumMoveNexts);

    }
}

This has several advantages over the other function:

- It records both the number of iterations started, the number of iterations that were completed, and the total number of times all of the sequences were incremented.

- You can create different instances to wrap different underlying sequences, thus allowing you to inspect multiple sequences per program, instead of just one when using a static variable.

Problem

suppose I have this query : ``` int[] Numbers= new int[5]{5,2,3,4,5}; var query = from a in Numbers where a== Numbers.Max (n => n) //notice MAX he should also get his value somehow select a; foreach (var element in query) Console.WriteLine (element); ``` How many times does `Numbers` is enumerated when running the `foreach` ? how can I test it ( I mean , writing a code which tells me the number of iterations)

Original source