C#

Error	2	Non-invocable member 'WindowsInput.InputSimulator.Keyboard' cannot be used like a method.

public sealed class ExpressionParameterModificationVisitor<TFrom, TTo> : ExpressionVisitor
{
    private readonly Stack<Dictionary<ParameterExpression, ParameterExpression>> _parameterMaps = new Stack<Dictionary<ParameterExpression, ParameterExpression>>();
    
    protected override Expression VisitLambda<T>(Expression<T> node)
    {
        var parameters = VisitAndConvert<ParameterExpression>(node.Parameters, "VisitLambda");
        var parameterMap = node.Parameters.Zip(parameters, (source, dest) => new { source, dest }).ToDictionary(p => p.source, p => p.dest);
        _parameterMaps.Push(parameterMap);
        try
        {
            var body = Visit(node.Body);
            return Expression.Lambda(body, parameters);
        }
        finally
        {
            _parameterMaps.Pop();
        }
    }
    
    protected override Expression VisitParameter(ParameterExpression expression)
    {
        if (typeof(TFrom) != expression.Type) return expression;
        return Expression.Parameter(typeof(TTo), expression.Name);
    }
    
    private Expression MapParameter(Expression expression)
    {
        var param = expression as ParameterExpression;
        if (param != null)
        {
            ParameterExpression result;
            if (_parameterMaps.Count != 0 && _parameterMaps.Peek().TryGetValue(param, out result))
            {
                expression = result;
            }
        }
        
        return expression;
    }
    
    protected override Expression VisitMember(MemberExpression node)
    {
        if (typeof(TFrom) != node.Expression.Type) return node.Update(Visit(node.Expression));
        
        var expression = MapParameter(node.Expression);
        var member = typeof(TTo).GetProperty(node.Member.Name);
        return Expression.MakeMemberAccess(expression, member);
    }
    
    public static Expression<Func<TTo, TResult>> Modify<TResult>(Expression<Func<TFrom, TResult>> expression)
    {
        if (expression == null) throw new ArgumentNullException(nameof(expression));
        
        var visitor = new ExpressionParameterModificationVisitor<TFrom, TTo>();
        var result = visitor.Visit(expression);
        return (Expression<Func<TTo, TResult>>)result;
    }
}

foo => foo.SomeCollection.Count(bar => bar.SomeFlag)

public static Expression<Func<TTo, TResult>> Modify<TResult>(Expression<Func<TFrom, TResult>> expression)
                                                                        ^^^^

RamboSp wrote:

However, it does not seem to work.

RamboSp wrote:

Can you please point me out to doing it the proper way?

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]

if (t.IsEnum) {
    TypeCode underlyingTypeCode = Type.GetTypeCode(Enum.GetUnderlyingType(t));

    // Depending on the enum type, we need to special case the comparers so that we avoid boxing
    // Note: We have different comparers for Short and SByte because for those types we need to make sure we call GetHashCode on the actual underlying type as the 
    // implementation of GetHashCode is more complex than for the other types.
    switch (underlyingTypeCode) {
        case TypeCode.Int16: // short
            return (EqualityComparer<T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(ShortEnumEqualityComparer<short>), t);
        case TypeCode.SByte:
            return (EqualityComparer<T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(SByteEnumEqualityComparer<sbyte>), t);
        case TypeCode.Int32:
        case TypeCode.UInt32:
        case TypeCode.Byte:
        case TypeCode.UInt16: //ushort
            return (EqualityComparer<T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(EnumEqualityComparer<int>), t);
        case TypeCode.Int64:
        case TypeCode.UInt64:
            return (EqualityComparer<T>)RuntimeTypeHandle.CreateInstanceForAnotherGenericParameter((RuntimeType)typeof(LongEnumEqualityComparer<long>), t);
    }
}