using System;

using System.Collections.Generic;

using System.Linq;

using CustomLINQExtensions;

​

public class Program

{

    public static void Main()

    {

        var collection = MakeCollection();

​

        WithoutLINQ(collection);

        WithLINQ(collection);

        CustomLINQ(collection);

    }

    static List<Item> MakeCollection()

    {

        return Enumerable.Range(0, 10).Select(v => new Item(new Foo(v))).ToList();

    }

​

    public class Item

    {

        public Foo Foo;

​

        public Item(Foo foo)

        {

            this.Foo = foo;

        }

    }

​

    public class Foo

    {

        public int Value;

​

        public Foo(int value)

        {

            this.Value = value;

        }

    }

    static void WithoutLINQ(List<Item> collection)

    {

        Console.WriteLine("Without LINQ");

​

        int totalIterationsOrCallsToMoveNext = 0;

        int selectLoopIteration = 0;

        int whereLoopIteration = 0;

        int toListLoopIteration = 0;

​

        List<Foo> foos = new List<Foo>();

        foreach (var item in collection)

        {

            Console.WriteLine("Select: " + (++selectLoopIteration) + ", Total MoveNext Calls: " + (++totalIterationsOrCallsToMoveNext));

            foos.Add(item.Foo);

        }

​

        // Where

        List<Foo> foosFiltered = new List<Foo>();

        foreach (var foo in foos)

        {

            Console.WriteLine("Where: " + (++whereLoopIteration) + ", Total MoveNext Calls: " + (++totalIterationsOrCallsToMoveNext));

            if (foo.Value >= 0)

            {

                foosFiltered.Add(foo);

            }

        }

​

        List<Foo> results = new List<Foo>();

        foreach (var item in foosFiltered)

        {

            Console.WriteLine("ToList: " + (++toListLoopIteration) + ", Total MoveNext Calls: " + (++totalIterationsOrCallsToMoveNext));

            results.Add(item);

        }

​

        Console.WriteLine();

    }

​

    static void WithLINQ(List<Item> collection)

    {

        Console.WriteLine("With LINQ");

​

        int totalIterationsOrCallsToMoveNext = 0;

        int selectLoopIteration = 0;

        int whereLoopIteration = 0;

        int toListLoopIteration = 0;

​

        List<Foo> results = new List<Foo>();

​

        var query = collection

            .Select(item =>

            {

                Console.WriteLine("Select: " + (++selectLoopIteration) + ", Total MoveNext Calls: " + (++totalIterationsOrCallsToMoveNext));

                return item.Foo;

            })

            .Where(foo =>

            {

                Console.WriteLine("Where: " + (++whereLoopIteration) + ", Total MoveNext Calls: " + (++totalIterationsOrCallsToMoveNext));

                return foo.Value >= 0;

            });

​

        foreach(var item in query)

        {

            Console.WriteLine("ToList: " + (++toListLoopIteration) + ", Total MoveNext Calls: " + (++totalIterationsOrCallsToMoveNext));

            results.Add(item);

        }

​

        Console.WriteLine();

    }

​

​

    static void CustomLINQ(IEnumerable<Item> collection)

    {

        Console.WriteLine("Custom LINQ");

​

        int totalIterationsOrCallsToMoveNext = 0;

        int selectLoopIteration = 0;

        int whereLoopIteration = 0;

        int toListLoopIteration = 0;

​

        var query = collection

            .MySelect(item =>

            {

                Console.WriteLine("Select: " + (++selectLoopIteration) + ", Total MoveNext Calls: " + (++totalIterationsOrCallsToMoveNext));

                return item.Foo;

            })

            .MyWhere(foo =>

            {

                Console.WriteLine("Where: " + (++whereLoopIteration) + ", Total MoveNext Calls: " + (++totalIterationsOrCallsToMoveNext));

                return foo.Value >= 0;

            })

            .MyToList(() =>

            {

                Console.WriteLine("ToList: " + (++toListLoopIteration) + ", Total MoveNext Calls: " + (++totalIterationsOrCallsToMoveNext));

            });

    }

}

​

namespace CustomLINQExtensions

{

    public static class CustomLINQExtensions

    {

        public static IEnumerable<TResult> MySelect<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector)

        {

            foreach (TSource item in source)

            {

                yield return selector(item);

            }

        }

​

        public static IEnumerable<TSource> MyWhere<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)

        {

            foreach (TSource item in source)

            {

                if (predicate(item))

                {

                    yield return item;

                }

            }

        }

​

        public static List<TSource> MyToList<TSource>(this IEnumerable<TSource> source, Action onItemAdded)

        {

            //this constructor also has basically a foreach loop internally, but we'll re-implement it here

            //return new List<TSource>(source);

​

            var result = new List<TSource>();

            foreach(TSource item in source)

            {

                onItemAdded();

                result.Add(item);

            }

            return result;

        }

    }

}