Разница в выражении‹Func‹T,bool››

Эта строка:

public Item Get(Expression<Func<Item, bool>> filter) { /* ... */  }

должно быть:

public Item Get(Expression<Func<IColoredObject, bool>> filter) { /* ... */  }

В этом случае вам придется работать с интерфейсом, если вы хотите вызвать метод Get, передавая Expression<Func<IColoredObject, bool>>.

Expression<TDelegate> - это класс, поэтому он не может иметь отклонений для общих параметров. Между Delegate и Expression<Delegate> также есть большая разница. Хотя вы можете передать объект Item в Func<IColoredObject, bool> и, таким образом, преобразовать Func<IColoredObject, bool> в Func<Item, bool>, Expression<Func<Item, bool>> точно так же, как код метода, принимающего Item и возвращающего логическое значение. Вы можете анализировать и изменять этот код, добавляя Item специальные методы и свойства, очевидно, что это невозможно для кода, работающего с IColoredObject.

Возможно изменить все записи параметра IColoredObject в объекте Expression<Func<IColoredObject, bool>> на Item с помощью ExpressionVisitor. Ниже приведен посетитель, который выполняет такое преобразование в простых случаях (т.е. без явных реализаций интерфейса). Возможно, есть гораздо более простое решение вашей проблемы, но его сложно найти, не зная подробностей.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;

interface IGizmo
{
    bool Frobnicate();
}

class Gizmo : IGizmo
{
    public bool Frobnicate()
    {
        Console.WriteLine("Gizmo was frobnicated!");

        return true;
    }
}

public sealed class DelegateConversionVisitor : ExpressionVisitor
{
    IDictionary<ParameterExpression, ParameterExpression> parametersMap;

    public static Expression<Func<T2, TResult>> Convert<T1, T2, TResult>(Expression<Func<T1, TResult>> expr)
    {
        var parametersMap = expr.Parameters
            .Where(pe => pe.Type == typeof(T1))
            .ToDictionary(pe => pe, pe => Expression.Parameter(typeof(T2)));

        var visitor = new DelegateConversionVisitor(parametersMap);
        var newBody = visitor.Visit(expr.Body);

        var parameters = expr.Parameters.Select(visitor.MapParameter);

        return Expression.Lambda<Func<T2, TResult>>(newBody, parameters);
    }

    public DelegateConversionVisitor(IDictionary<ParameterExpression, ParameterExpression> parametersMap)
    {
        this.parametersMap = parametersMap;
    }

    protected override Expression VisitParameter(ParameterExpression node)
    {
        return base.VisitParameter(this.MapParameter(node));
    }

    private ParameterExpression MapParameter(ParameterExpression source)
    {
        var target = source;
        this.parametersMap.TryGetValue(source, out target);

        return target;
    }
}

class Program
{
    static void Main()
    {
        Expression<Func<IGizmo, bool>> expr = g => g.Frobnicate();

        var e2 = DelegateConversionVisitor.Convert<IGizmo, Gizmo, bool>(expr);

        var gizmo = new Gizmo();
        e2.Compile()(gizmo);
    }
}

C# имеет ковариантность и контравариантность только для типов interface и delegate. Например, это будет работать:

IEnumerable<Func<IColoredObject, bool>> ie1 = XXX;
IEnumerable<Func<Item, bool>> ie2 = ie1;                // works!

Обратите внимание, что в приведенном выше примере назначение ie2 = ie1 выполняется успешно, даже если типы не совпадают. Это связано с тем, что Func<T, TResult> является контравариантным ("in") в своем первом параметре типа T, и IEnumerable<T> является ковариантным ("out") в своем T. Здесь Func<,> — делегат, а IEnumerable<> — интерфейс.

Но Expression<TDelegate> — это класс. C# не поддерживает ковариантность/контравариантность для типов классов.

Поэтому Expression<Something> никогда не преобразуется в Expression<SomethingAlmostTheSame>.

Я всегда путаюсь, когда пытаюсь вычислить ковариантность и контравариантность. Но ваш пример кажется мне понятным. Для вашего метода Get(...) требуется выражение с типом Item. Поскольку Item является производным от IColoredObject, вы не можете использовать выражение с типом IColoredObject, только с типом Item или типами, производными от Item. IColoredObject является «более абстрактным», и поэтому все, что ожидает тип Item (или его производное), не может с ним работать.

Спросите себя: предположим на мгновение, что Item определил свойство X, которого нет у IColoredObject, тогда как выражение с типом IColoredObject будет определять свойство X?