Manually increment an enumerator inside foreach loop

Question

I have a nested while loop inside a foreach loop where I would like to advance the enumerator indefinitately while a certain condition is met. To do this I try casting the enumerator to IEnumerator< T > (which it must be if it is in a foreach loop) then calling MoveNext() on the casted object but it gives me an error saying I cannot convert it.

Cannot convert type 'System.DateTime' to System.Collections.Generic.IEnumerator via a reference conversion, boxing conversion, unboxing conversion, wrapping conversion, or null type conversion.

        foreach (DateTime time in times)
        {
            while (condition)
            {
                // perform action
                // move to next item
                (time as IEnumerator<DateTime>).MoveNext(); // will not let me do this
            }

            // code to execute after while condition is met
         }

What is the best way to manually increment the IEnumerator inside of the foreach loop?

EDIT: Edited to show there is code after the while loop that I would like executed once the condition is met which is why I wanted to manually increment inside the while then break out of it as opposed to continue which would put me back at the top. If this isn't possible I believe the best thing is to redesign how I am doing it.

Solution 1

Many of the other answers recommend using continue, which may very well help you do what you need to do. However, in the interests of showing manually moving the enumerator, first you must have the enumerator, and that means writing your loop as a while.

using (var enumerator = times.GetEnumerator())
{
    DateTime time;
    while (enumerator.MoveNext()) 
    {
        time = enumerator.Current;
        // pre-condition code
        while (condition)
        {
            if (enumerator.MoveNext())
            {
                time = enumerator.Current;
                // condition code
            }
            else 
            {
                condition = false;
            }
        }
        // post-condition code
    }
}

From your comments:

How can the foreach loop advance it if it doesn't implement the IEnumerator interface?

In your loop, time is a DateTime. It is not the object that needs to implement an interface or pattern to work in the loop. times is a sequence of DateTime values, it is the one that must implement the enumerable pattern. This is generally fulfilled by implementing the IEnumerable<T> and IEnumerable interfaces, which simply require T GetEnumerator() and object GetEnumerator() methods. The methods return an object implementing IEnumerator<T> and IEnumerator, which define a bool MoveNext() method and a T or object Current property. But time cannot be cast to IEnumerator, because it is no such thing, and neither is the times sequence.

Solution 2

You cannot modify the enumerator from inside the for loop. The language does not permit this. You need to use the continue statement in order to advance to the next iteration of a loop.

However, I'm not convinced that your loop even needs a continue. Read on.

In the context of your code you would need to convert the while to an if in order to make the continue refer to the foreach block.

foreach (DateTime time in times)       
{    
     if (condition) 
     {
             // perform action
             continue;
     }
     // code to execute if condition is not met    
}

But written like this it is clear that the following equivalent variant is simpler still

foreach (DateTime time in times)       
{    
     if (condition) 
     {
             // perform action
     }
     else
     {
            // code to execute if condition is not met   
     } 
}

This is equivalent to your pseudo-code because the part marked code to execute after while condition is met is executed for each item for which condition is false.

My assumption in all of this is that condition is evaluated for each item in the list.

Solution 3

Perhaps you can use continue?

Solution 4

You would use the continue statement: continue;

Solution 5

This is just a guess, but it sounds like what you're trying to do is take a list of datetimes and move past all of them which meet a certain criteria, then perform an action on the rest of the list. If that's what you're trying to do, you probably want something like SkipWhile() from System.Linq. For example, the following code takes a series of datetimes and skips past all of them which are before the cutoff date; then it prints out the remaining datetimes:

var times = new List<DateTime>()
    {
        DateTime.Now.AddDays(1), DateTime.Now.AddDays(2), DateTime.Now.AddDays(3), DateTime.Now.AddDays(4)
    };

var cutoff = DateTime.Now.AddDays(2);

var timesAfterCutoff = times.SkipWhile(datetime => datetime.CompareTo(cutoff) < 1)
    .Select(datetime => datetime);

foreach (var dateTime in timesAfterCutoff)
{
    Console.WriteLine(dateTime);
}

Console.ReadLine();

Is that the sort of thing you're trying to do?

View more solutions

Comments

[Anthony Pegram]

This is not Jeopardy. Answers don't need to be phrased in the form of a question. Be confident!

[Despertar]

Thank for the excellent explanation! This answers my question as to how to manually increment the enumerator and it explains why my casting didn't work. I assumed that time WAS the enumerator, but time is actually just the variable that holds the value of the enumerators Current property (correct me if im wrong). This also explains why custom classes which never inheritted from IEnumerator work inside IEnumerable containers.

[Despertar]

Well I didn't want to skip the items that met the condition, I wanted to accumulate them into a sub-list that would be processed after the while. However your LINQ reference did encourage me to give LINQ another shot (which was what I used originally) and this solved my problem in a much simpler way (as LINQ usually does). Thanks.

[David Heffernan]

watch out for the non-terminating while (condition) at the end of the iteration

[David Heffernan]

For the life of me I cannot see how my final code snippet fails to do the job. At the very least your answer should warn against manually organising a loop like this because of all the pitfalls. Faced with the code in your answer I would assume that there must be a much clearer solution and I would start analysing and refactoring until I foud it.

[Anthony Pegram]

@David, I do not disagree. And given a choice, I would not write this code either! If anything, if we knew what he was trying to do, it would be easier to come with a definitive recommendation. This could be an example of the XY problem, focusing on the attempted solution rather than the actual problem.

[Despertar]

The reason why this snippet fails to do the job is because I used a while loop to batch all items that met the condition then process this batch after the condition failed. The if loop falls through each time which creates a completely different behavior and it doesn't answer the original question of manually incrementing the enumerator.

[David Heffernan]

Batch them up in the if and then process them in the else. The code here behaves the same as your pseudo-code. You are over-complicating a rather simple loop.

[Despertar]

I see what you mean now, that would work. Thank you for your input.

[David Heffernan]

I really don't care which answer you accept but I really hope I can convince you of the importance of making loops as simple as humanly possible. Thanks for staying with my persistent nagging!