CODEWITHSUNDEEP
c#lambdamonoyield
Imi
Imi

Reputation: 1579

Enumerating over lambdas does not bind the scope correctly?

consider the following C# program:

using System;
using System.Linq;
using System.Collections.Generic;

public class Test
{
    static IEnumerable<Action> Get()
    {
        for (int i = 0; i < 2; i++)
        {
            int capture = i;
            yield return () => Console.WriteLine(capture.ToString());
        }
    }

    public static void Main(string[] args)
    {
        foreach (var a in Get()) a();
        foreach (var a in Get().ToList()) a();
    }
}

When executed under Mono compiler (e.g. Mono 2.10.2.0 - paste into here), it writes the following output:

0
1
1
1

This seems totally unlogical to me. When directly iterating the yield function, the scope of the for-loop is "correctly" (to my understanding) used. But when I store the result in a list first, the scope is always the last action?!

Can I assume that this is a bug in the Mono compiler, or did I hit a mysterious corner case of C#'s lambda and yield-stuff?

BTW: When using Visual Studio compiler (and either MS.NET or mono to execute), the result is the expected 0 1 0 1

Upvotes: 12

Views: 488

Answers (2)

Anthony Mason
Anthony Mason

Reputation: 175

@Armaron - The .ToList() extension returns List of type T as ToArray() returns T[] as the naming convention implies, but I think you are on the right track with your response.

This sounds like an issuse with the compiler. I agree with Servy that it is probably a bug, however, have you tried the following?

public class Test
{
    private static int capture = 0;    

    static IEnumerable<Action> Get()
    {
        for (int i = 0; i < 2; i++)
        {
            capture++;
            yield return () => Console.WriteLine(capture.ToString());
        }
    }
}

Additionally you may want to try the static approach, perhaps this will perform a more accurate conversion as your function is static.

List<T> list = Enumerable.ToList(Get());

When calling ToList() it seems as though it is not performing a single iteration for each value but rather:

return new List<T>(Get());

The second for each in your code does not make sense to me in implementation as to why it would ever be necessary or beneficial unless you require additional actions to be added/removed to the List object. The first makes perfect sense since all you are doing is iterating through the object and performing the associated action. My understanding is that an integer within the scope of the static IEnumerbale object is being calculated during conversion by performing the entire iteration and the action is preserving the int as a static int due to scope. Also, keep in mind that IEnumerable is merely an interface that is implemented by List which implements IList, and may contain logic for the conversion built in.

That being said I am interested to see/hear your findings as this is an interesting post. I will definitely upvote the question. Please ask questions if anything I said needs clarification or if something is false say so, although I am confident in my usage of the yield keyword of IEnumerable but this is a unique issue.

Upvotes: 0

Ken Bonny
Ken Bonny

Reputation: 789

I'll give you the reason why it was 0 1 1 1:

foreach (var a in Get()) a();

Here you go into Get and it starts iterating:

i = 0 => return Console.WriteLine(i);

The yield returns with the function and executes the function, printing 0 to the screen, then returns to the Get() method and continues.

i = 1 => return Console.WriteLine(i);

The yield returns with the function and executes the function, printing 1 to the screen, then returns to the Get() method and continues (only to find that it has to stop).

But now, you're not iterating over each item when it happens, you're building a list and then iterating over that list.

foreach (var a in Get().ToList()) a();

What you are doing isn't like above, Get().ToList() returns a List or Array (not sure wich one). So now this happens:

i = 0 => return Console.WriteLine(i);

And in you Main() function, you get the following in memory:

var i = 0;
var list = new List
{
    Console.WriteLine(i)
}

You go back into the Get() function:

i = 1 => return Console.WriteLine(i);

Which returns to your Main()

var i = 1;
var list = new List
{
    Console.WriteLine(i),
    Console.WriteLine(i)
}

And then does

foreach (var a in list) a();

Which will print out 1 1

It seems like it was ignoring that you made sure you encapsulated the value before returning the function.

Upvotes: 1

Related Questions