Merged PR 14274: Query extensions

+semver: minor

Query extensionok a következő feladatokra:
- két Expression láncolása
- két Expression közötti logikai és/vagy műveletek

Author: László Jakab

src/AutSoft.Linq/Expressions/ChainExtension.cs

@@ -0,0 +1,28 @@
+using AutSoft.Linq.Expressions.ExpressionVisitors;
+
+using System.Linq.Expressions;
+
+namespace AutSoft.Linq.Expressions;
+
+/// <summary>
+/// Extension methods for <see cref="Expression{T}"/> with extended functionality for chaining
+/// </summary>
+public static class ChainExtension
+{
+    /// <summary>
+    /// Chaining together two <see cref="Expression{T}"/>
+    /// </summary>
+    /// <typeparam name="TIn">Type of input paramter of the result <see cref="Expression{T}"/>'s function</typeparam>
+    /// <typeparam name="TInterstitial">Type of interstitial parameter of the <see cref="Expression{T}"/> function</typeparam>
+    /// <typeparam name="TOut">Type of output paramter of the result <see cref="Expression{T}"/>'s function</typeparam>
+    /// <param name="incomingChainLink">The incoming <see cref="Expression{T}"/> to chaning</param>
+    /// <param name="outgoingChainLink">The outgoing <see cref="Expression{T}"/> to chaning</param>
+    /// <returns>The chained together <see cref="Expression{T}"/></returns>
+    public static Expression<Func<TIn, TOut>> Chain<TIn, TInterstitial, TOut>(
+        this Expression<Func<TIn, TInterstitial>> incomingChainLink,
+        Expression<Func<TInterstitial, TOut>> outgoingChainLink)
+    {
+        var visitor = new SwapVisitor(outgoingChainLink.Parameters[0], incomingChainLink.Body);
+        return Expression.Lambda<Func<TIn, TOut>>(visitor.Visit(outgoingChainLink.Body), incomingChainLink.Parameters);
+    }
+}

src/AutSoft.Linq/Expressions/ExpressionVisitors/ParameterUpdateVisitor.cs

@@ -0,0 +1,33 @@
+using System.Linq.Expressions;
+
+namespace AutSoft.Linq.Expressions.ExpressionVisitors;
+
+/// <summary>
+/// An <see cref="ExpressionVisitor"/>, which update a <see cref="ParameterExpression"/>
+/// </summary>
+internal class ParameterUpdateVisitor : ExpressionVisitor
+{
+    private readonly ParameterExpression _oldParameter;
+    private readonly ParameterExpression _newParameter;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ParameterUpdateVisitor"/> class.
+    /// </summary>
+    /// <param name="oldParameter">The <see cref="ParameterExpression"/>, with which identical ones must be replaced</param>
+    /// <param name="newParameter">The <see cref="ParameterExpression"/>, for which the matches must be exchanged</param>
+    public ParameterUpdateVisitor(ParameterExpression oldParameter, ParameterExpression newParameter)
+    {
+        _oldParameter = oldParameter;
+        _newParameter = newParameter;
+    }
+
+    /// <summary>
+    /// Visit the <see cref="ParameterExpression"/>
+    /// </summary>
+    /// <param name="node">The <see cref="ParameterExpression"/>, that we visit</param>
+    /// <returns>The <see cref="ParameterExpression"/> after the visit</returns>
+    protected override Expression VisitParameter(ParameterExpression node)
+    {
+        return ReferenceEquals(node, _oldParameter) ? _newParameter : base.VisitParameter(node);
+    }
+}

src/AutSoft.Linq/Expressions/ExpressionVisitors/SwapVisitor.cs

@@ -0,0 +1,33 @@
+using System.Linq.Expressions;
+
+namespace AutSoft.Linq.Expressions.ExpressionVisitors;
+
+/// <summary>
+/// An <see cref="ExpressionVisitor"/>, which swap the visited <see cref="Expression"/> to an other
+/// </summary>
+internal class SwapVisitor : ExpressionVisitor
+{
+    private readonly Expression _source;
+    private readonly Expression _replacement;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SwapVisitor"/> class.
+    /// </summary>
+    /// <param name="source">The <see cref="Expression"/>, with which identical ones must be replaced</param>
+    /// <param name="replacement">The <see cref="Expression"/>, for which the matches must be exchanged</param>
+    public SwapVisitor(Expression source, Expression replacement)
+    {
+        _source = source;
+        _replacement = replacement;
+    }
+
+    /// <summary>
+    /// Visit the <see cref="Expression"/>
+    /// </summary>
+    /// <param name="node">The <see cref="Expression"/>, that we visit</param>
+    /// <returns>The <see cref="Expression"/> after the visit</returns>
+    public override Expression? Visit(Expression? node)
+    {
+        return node == _source ? _replacement : base.Visit(node);
+    }
+}

src/AutSoft.Linq/Expressions/LogicalOperatorExtensions.cs

@@ -0,0 +1,47 @@
+using AutSoft.Linq.Expressions.ExpressionVisitors;
+
+using System.Linq.Expressions;
+
+namespace AutSoft.Linq.Expressions;
+
+/// <summary>
+/// Extension methods for <see cref="Expression{T}"/> with extended functionality for logical operators
+/// </summary>
+public static class LogicalOperatorExtensions
+{
+    /// <summary>
+    /// Performing an AND operation on two <see cref="Expression{T}"/>
+    /// </summary>
+    /// <typeparam name="T">Type of input paramter of the <see cref="Expression{T}"/>'s function</typeparam>
+    /// <param name="leftExp">The left sided <see cref="Expression{T}"/> of AND operation</param>
+    /// <param name="rightExp">The right sided <see cref="Expression{T}"/> of AND operation</param>
+    /// <returns>The result <see cref="Expression{T}"/> after the AND operation</returns>
+    public static Expression<Func<T, bool>> And<T>(
+        this Expression<Func<T, bool>> leftExp,
+        Expression<Func<T, bool>> rightExp)
+    {
+        var visitor = new ParameterUpdateVisitor(rightExp.Parameters[0], leftExp.Parameters[0]);
+        rightExp = (Expression<Func<T, bool>>)visitor.Visit(rightExp);
+
+        var binExp = Expression.And(leftExp.Body, rightExp.Body);
+        return Expression.Lambda<Func<T, bool>>(binExp, rightExp.Parameters);
+    }
+
+    /// <summary>
+    /// Performing an OR operation on two <see cref="Expression{T}"/>
+    /// </summary>
+    /// <typeparam name="T">Type of input paramter of the <see cref="Expression{T}"/>'s function</typeparam>
+    /// <param name="leftExp">The left sided <see cref="Expression{T}"/> of OR operation</param>
+    /// <param name="rightExp">The right sided <see cref="Expression{T}"/> of OR operation</param>
+    /// <returns>The result <see cref="Expression{T}"/> after the OR operation</returns>
+    public static Expression<Func<T, bool>> Or<T>(
+        this Expression<Func<T, bool>> leftExp,
+        Expression<Func<T, bool>> rightExp)
+    {
+        var visitor = new ParameterUpdateVisitor(rightExp.Parameters[0], leftExp.Parameters[0]);
+        rightExp = (Expression<Func<T, bool>>)visitor.Visit(rightExp);
+
+        var binExp = Expression.Or(leftExp.Body, rightExp.Body);
+        return Expression.Lambda<Func<T, bool>>(binExp, rightExp.Parameters);
+    }
+}