using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

​

public interface IMyQueryable<T> : IEnumerable<T>

{

    IMyQueryable<T> Where<T>(Func<T, bool> filter);

}

​

public class User

{

    public string Name { get; set; }

    public string Surname { get; set; }

    public int Age { get; set; }

}

​

public class CustomContext : IMyContextProvider

{

    private readonly User[] _Users = new User[]

    {

        new() { Name = "John", Surname = "Doe", Age = 35 },

        new(){ Name = "John", Surname = "Doe", Age = 33 },

        new() { Name = "Sarah", Surname = "Connor", Age = 30 }

    };

​

    public MyQueryable<User> Users => new MyQueryable<User>(this);

​

    public IEnumerable<User> UsersRaw => _Users;

​

    public IEnumerable<T> GetRaw<T>() =>

        typeof(T) == typeof(User)

        ? _Users.Cast<T>()

        : throw new ArgumentException($"Unknown type {typeof(T)}");

}

​

public interface IMyContextProvider

{

    IEnumerable<T> GetRaw<T>();

}

​

class MainClass

{

    public static void Main(string[] args)

    {

        var ctx = new CustomContext();

​

        var filter = ctx.Users

            .Where<User>(e => e.Name == "John");

​

        var ages =

            filter

            .Where<User>(e => e.Surname == "Doe")

            .Select(a => a.Age);

        Console.WriteLine(string.Join(", ", ages));

        Console.WriteLine(new[] { 35, 33 }.SequenceEqual(ages));

​

        var names =

            filter

            .Where<User>(e => e.Age > 0)

            .Select(a => a.Name);

        Console.WriteLine(string.Join(", ", names));

        Console.WriteLine(new[] { "John", "John" }.SequenceEqual(names));

    }

}

​

public class MyQueryable<T> : IMyQueryable<T>

{

    private readonly IMyContextProvider _Context;

​

    public MyQueryable(IMyContextProvider context)

    {

        _Context = context;

    }

​

    IEnumerator<T> IEnumerable<T>.GetEnumerator()

    {

        IEnumerator<T> Cast<T>(IEnumerator iterator)

        {

            while (iterator.MoveNext())

                yield return (T)iterator.Current;

        }

        return Cast<T>(GetEnumerator());

    }

​

    #region implement

    internal List<Func<T, bool>> Filters = new List<Func<T, bool>>();

​

    public IMyQueryable<T> Where<T>(Func<T, bool> filter)

    {

        var clone = Clone<T>();

        clone.Filters.Add(filter);

        return clone;

    }

​

    public IEnumerator GetEnumerator()

    {

        IEnumerable<T> Filter(IEnumerable<T> source, Func<T, bool> filter)

        {

            foreach (var value in source)

                if (filter(value))

                    yield return value;

        }

​

        var source = _Context.GetRaw<T>();

​

        foreach (var filter in Filters)

            source = Filter(source, filter);

​

        foreach (var value in source)

            yield return value;

    }

​

    public MyQueryable<T> Clone<T>()

    {

        var result = new MyQueryable<T>(_Context)

        {

            Filters = new List<Func<T, bool>>()

        };

​

        foreach (var filter in Filters)

            result.Filters.Add(filter as Func<T, bool>);

​

        return result;

    }

    #endregion implement

}