Black Art – LINQ expressions reuse

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using EF_ReuseLinq.Model;
using LinqExpressionProjection;

namespace EF_ReuseLinq
{
    public class Utilities
    {
        public static Expression<Func<Subproject, bool>> mainSubprojectSelector = sp =>
                                                                                   sp.Area ==
                                                                                   sp.Project.Subprojects.Where(spi => spi.Area < 1000)
                                                                                       .Max(spii => spii.Area);

        public static Expression<Func<Project, Subproject>> projectMainSubprojSelectorSingle =
            proj => proj.Subprojects.AsQueryable().Single(mainSubprojectSelector);

        public static Expression<Func<Project, Subproject>> projectMainSubprojSelectorSingleOrDefault =
            proj => proj.Subprojects.AsQueryable().SingleOrDefault(mainSubprojectSelector);

        public static Expression<Func<Project, Subproject>> projectMainSubprojSelectorFirst =
            proj => proj.Subprojects.AsQueryable().First(mainSubprojectSelector);

        public static Expression<Func<Project, Subproject>> projectMainSubprojSelectorFirstOrDefault =
            proj => proj.Subprojects.AsQueryable().FirstOrDefault(mainSubprojectSelector);

        public static Expression<Func<Project, double>> projectAverageEffectiveAreaSelector =
            proj => proj.Subprojects.Where(sp => sp.Area < 1000).Average(sp => sp.Area);
    }

    class Program
    {
        // will not run - Single can only be the last query operator:

        // will not run - SingleOrDefault can only be the last query operator:


        // will not run - First can only be the last query operator:

        static void Main(string[] args)
        {
            // Run this once to poulate your DB:
            // PopulateDb();

            using (var ctx = new ProjectsDbContext())
            {
                // Commented lines will not run - reffere to article

                var mainsSbprojects = ctx.Subprojects
                    .Where(sp =>
                        sp.Area ==
                        sp.Project.Subprojects.Where(spi => spi.Area < 1000)
                        .Max(spii => spii.Area)).ToArray();

                var mainsSbprojectsBySelector = ctx.Subprojects
                    .Where(Utilities.mainSubprojectSelector).ToArray();

                var proj1MainSubProj = ctx.Subprojects
                    .Where(Utilities.mainSubprojectSelector).Single(sp => sp.Project.ID == 1);

                //var proj1MainSubprojByProj = ctx.Projects.Where(p => p.ID == 1).Select(projectMainSubprojSelectorSingle).Single();
                //var proj1MainSubprojByProj = ctx.Projects.Where(p => p.ID == 1).Select(projectMainSubprojSelectorFirst).Single();
                //var proj1MainSubprojByProj = ctx.Projects.Where(p => p.ID == 1).Select(projectMainSubprojSelectorSingleOrDefault).Single();
                var proj1MainSubprojByProj = ctx.Projects.Where(p => p.ID == 1).Select(Utilities.projectMainSubprojSelectorFirstOrDefault).Single();

                var projAndMainSubprojAreaBySubproj =
                    ctx.Projects.Where(p => p.ID == 1)
                    .Select(Utilities.projectMainSubprojSelectorFirstOrDefault)
                    .Select(sp => new { ProjectID = sp.Project.ID, MainSpArea = sp.Area })
                    .Single();


                var proj1Aea =
                    ctx.Projects.Where(p => p.ID == 1)
                    .Select(Utilities.projectAverageEffectiveAreaSelector)
                    .Single();

                var proj1AndAea =
                   ctx.Projects.AsExpressionProjectable()
                   .Where(p => p.ID == 1)
                   .Select(p => new
                            {
                                Project = p,
                                AEA = Utilities.projectAverageEffectiveAreaSelector.Project<double>()
                            }
                   ).Single();

            }
        }

        private static Expression<Func<Project, Subproject>> GetProjectMainSubprojectSelector()
        {
            return Utilities.projectMainSubprojSelectorFirstOrDefault;
        }


        private static Expression<Func<Project, Subproject>> SwitchSelector(bool retriveLargest)
        {
            return retriveLargest
                ? (Expression<Func<Project, Subproject>>)((Project p) => p.Subprojects.Where(x => x.Area == p.Subprojects.Max(y => y.Area)).FirstOrDefault())
                : (Expression<Func<Project, Subproject>>)((Project p) => p.Subprojects.Where(x => x.Area == p.Subprojects.Min(y => y.Area)).FirstOrDefault());
        }

        private static void PopulateDb()
        {
            using (var ctx = new ProjectsDbContext())
            {
                Project p1 = ctx.Projects.Add(new Project());
                Project p2 = ctx.Projects.Add(new Project());

                ctx.Subprojects.Add(new Subproject() { Area = 100, Project = p1 });
                ctx.Subprojects.Add(new Subproject() { Area = 200, Project = p1 });
                ctx.Subprojects.Add(new Subproject() { Area = 350, Project = p2 });
                ctx.Subprojects.Add(new Subproject() { Area = 450, Project = p2 });
                ctx.Subprojects.Add(new Subproject() { Area = 10000, Project = p2 });

                ctx.SaveChanges();
            }
        }
    }

    class MyClass
    {
        public Subproject Subproject { get; set; }
    }
}