C# Having a method call inside Select statement causes multiple method calls

When running the below code

private static IEnumerable<Tester2> Foo()
{
    Console.WriteLine("Hello world!");
    for (var i = 0; i < 10; i++)
        yield return new Tester2(i);
}

private class Tester2
{
    public int Hey { get; set; }

    public Tester2(int hey)
    {
        Hey = hey;
    }
}

private class Tester3
{
    public int Hey3 { get; set; }

    public Tester3(int hey)
    {
        Hey3 = hey + 5;
    }
}

private static IEnumerable<Tester3> Bar(IEnumerable<Tester2> lister)
{
    Console.WriteLine("Hello world2!");
    return lister.Select(Convert);
}

private static Tester3 Convert(Tester2 tester)
{
    Console.WriteLine("Hello world3!");
    var hey = "test";
    var result= hey.Map(x => new Tester3(tester.Hey)).First();
    return result;
}

public static void Main(string[] args)
{
  
    var x = Foo().ToList();

    var bar = Bar(x);
    
    foreach (var b in bar)
    {
        Console.WriteLine("Hmm2");
    }

    
    
}

I get my main thread calling the Convert method multiple times, as shown by the output:

Hello world!
Hello world2!
Hello world3!
Hmm2
Hello world3!
Hmm2
Hello world3!
Hmm2
Hello world3!
Hmm2
Hello world3!
Hmm2
Hello world3!
Hmm2
Hello world3!
Hmm2
Hello world3!
Hmm2
Hello world3!
Hmm2
Hello world3!
Hmm2

Why is this? I've only ever seen behaviour like this when using yield and deferring execution, but never on simple IEnumerable methods - I would expect the behaviour to be that it would calculate an 'IEnumerable' when we go over it in the for loop and then evaluate it once. Obviously when I introduce .ToList() the issue goes away, but I'd like to understand the behaviour beforehand. Thanks in advance!

> Why is this?

Select means "Apply this function to each element". So it should be no surprise it is called one for each element. Since Convert takes a single element this is the only possible way for it to work.

Select, and most of the functions in LINQ, uses deferred execution / lazy evaluation. That is one of the main points with LINQ. Lazy evaluation is in no way restricted to iterator blocks (i.e. yield return-methods). Consider for example:

var one = new []{1, 2, 3}.Select(i => i.ToString()).First();

.ToString() will only be called once. And that can be quite useful. The length of the original list is irrelevant, since we only need the first item. It might even be infinitely long!

However, if you are using LINQ on regular lists, and not a database, some methods will need to evaluate the entire list once at least one value is required. For example OrderBy, since it needs to know all the elements in order to sort them. But the evaluation would still happen inside the foreach loop.