using System;

using System.Linq;

using System.Linq.Expressions;

using System.Collections.Generic;

​

using NUnit.Framework;

​

//https://stackoverflow.com/questions/77422314/c-sharp-merge-combine-expressions

​

class Package

{

    public string Name { get; set; }

    public decimal Price { get; set; }

    public bool Enabled { get; set; }

​

    public static Expression<Func<Package, bool>> IsActive =>

        x => x.Enabled;

}

​

class Schedule

{

    public DateTimeOffset Start { get; set; }

    public DateTimeOffset End { get; set; }

    public bool Enabled { get; set; }

​

    public static Expression<Func<Schedule, bool>> IsActive =>

        x => x.Enabled && x.Start > DateTimeOffset.Now;

}

​

class SchedulePackage

{

    public Package Package { get; init; }

    public Schedule Schedule { get; init; }

​

    static Lazy<Expression<Func<SchedulePackage, bool>>> IsActiveExpression = new(static () => {

        var left = Package.IsActive.Compose((SchedulePackage sp) => sp.Package);

        var right = Schedule.IsActive.Compose((SchedulePackage sp) => sp.Schedule);

        Expression<Func<bool, bool, bool>> binary = (b1, b2) => b1 && b2;

        return binary.Compose(left, right);

    });

    public static Expression<Func<SchedulePackage, bool>> IsActive => IsActiveExpression.Value;

}

​

#nullable enable

​

​

public static partial class ExpressionExtensions

{

    // Compose two Func<Tx, Ty> expressions with compatible generic parameters into a third.

    public static Expression<Func<T1, TResult>> Compose<T1, T2, TResult>(this Expression<Func<T2, TResult>> outer, Expression<Func<T1, T2>> inner) =>

        Expression.Lambda<Func<T1, TResult>>(

            new ParameterReplacer((outer.Parameters[0], inner.Body)).Visit(outer.Body), 

            false, inner.Parameters[0]);    

​

    // Compose a Func<T2, T3, TResult> expression with compatible Func<T1, T2> and Func<T1, T3> expressions to obtain a Func<T1, TResult> expression.

    public static Expression<Func<T1, TResult>> Compose<T1, T2, T3, TResult>(this Expression<Func<T2, T3, TResult>> outer, Expression<Func<T1, T2>> inner1, Expression<Func<T1, T3>> inner2)

    {

        var inner2body = new ParameterReplacer((inner2.Parameters[0], (Expression)inner1.Parameters[0])).Visit(inner2.Body);

        return Expression.Lambda<Func<T1, TResult>>(

            new ParameterReplacer((outer.Parameters[0], inner1.Body), (outer.Parameters[1], inner2body)).Visit(outer.Body), 

            false, inner1.Parameters[0]);   

    }

}

​

class ParameterReplacer : ExpressionVisitor

{

    // Replace formal parameters (e.g. of a lambda body) with some containing expression in scope.

    readonly Dictionary<ParameterExpression, Expression> parametersToReplace;

    public ParameterReplacer(params (ParameterExpression parameter, Expression replacement) [] parametersToReplace) =>

        this.parametersToReplace = parametersToReplace.ToDictionary(p => p.parameter, p => p.replacement);

    protected override Expression VisitParameter(ParameterExpression p) => 

        parametersToReplace.TryGetValue(p, out var e) ? e : base.VisitParameter(p);

}

​

/***/

​

public class Program

{

    public static void Main()

    {

        Console.WriteLine($"Schedule.IsActive: {Schedule.IsActive}");

        Console.WriteLine($"Package.IsActive : {Package.IsActive}");

        Console.WriteLine($"SchedulePackage.IsActive: {SchedulePackage.IsActive}");

        Console.WriteLine();

        Assert.That(!SchedulePackage.IsActive.ToString().Contains("Invoke("));

        Test2();

        Test1();

    }

    static void Test2()

    {

        var schedulePackages = new [] { true, false }

            .SelectMany(b => new [] { true, false }, (b1, b2) => (b1, b2))

            .Select(p => 

                    new SchedulePackage { Schedule = new () { Enabled = p.b1, Start = DateTime.Now.AddDays(4) }, Package = new () { Enabled = p.b2 } })

            .AsQueryable();

        var items = schedulePackages.Where(SchedulePackage.IsActive);

        Console.WriteLine(items.Count());

        Assert.AreEqual(1, items.Count());

    }

    static void Test1()

    {

        var isActive = SchedulePackage.IsActive.Compile();

        foreach (var enabled1 in new [] { true, false } )

            foreach (var enabled2 in new [] { true, false } )

            {

                Test(new () { Enabled = enabled1 }, new () { Enabled = enabled2, Start = DateTime.Now.AddDays(4) }, isActive);

            }

    }

    static void Test(Package p, Schedule s, Func<SchedulePackage, bool> isActive)

    {

        var schedulePackage = new SchedulePackage { Schedule = s, Package = p };

        Console.WriteLine($"isActive(schedulePackage) = {isActive(schedulePackage)}");

        Assert.AreEqual(Package.IsActive.Compile()(p) && Schedule.IsActive.Compile()(s), isActive(schedulePackage));

    }

}

​