如何实现C#方法同时接受Func或Expression<Func>参数？

针对你遇到的编译器歧义问题，有几种可行的解决思路，以下是具体实现方式：

方案一：添加标记参数引导重载匹配 #

给其中一个重载增加一个带默认值的冗余参数，让编译器能明确区分语句lambda和表达式lambda的匹配目标：

class ClassName
{
    // 处理表达式lambda的重载
    void SelectItems(Expression<Func<Thing, bool>> filterExpression)
    {
        string filterDesc = PrettyPrintCSharpCode(filterExpression);
        // 执行筛选逻辑，无匹配时抛出带filterDesc的异常
        var matchedItems = collection.Where(filterExpression.Compile()).ToList();
        if (!matchedItems.Any())
        {
            var itemsList = string.Join(", ", collection.Select(t => t.ToString()));
            throw new InvalidOperationException($"Item matching filter \"{filterDesc}\" was not found. Items found: {itemsList}");
        }
        // ... 后续处理逻辑
    }

    // 处理语句lambda的重载，增加一个默认值参数
    void SelectItems(Func<Thing, bool> filterFunc, object _ = null)
    {
        // 原逻辑，无法获取筛选器描述
        var matchedItems = collection.Where(filterFunc).ToList();
        if (!matchedItems.Any())
        {
            var itemsList = string.Join(", ", collection.Select(t => t.ToString()));
            throw new InvalidOperationException($"No item matching filter was found. Items found: {itemsList}");
        }
        // ... 后续处理逻辑
    }
}

效果说明： #

• 语句lambda无法转换为Expression<Func<Thing, bool>>，因此编译器只能匹配带默认参数的Func重载，不会出现歧义。
• 表达式lambda可以转换为Expression<Func<Thing, bool>>，编译器会优先选择无冗余参数的精确匹配重载，自动跳过Func重载。

方案二：自定义包装类统一处理（推荐） #

创建一个支持隐式转换的包装类，同时兼容Func和Expression类型，让SelectItems只接受这个包装类参数，彻底消除歧义：

// 自定义筛选器包装类
public class ThingFilter
{
    public Func<Thing, bool> FilterFunc { get; }
    public Expression<Func<Thing, bool>> FilterExpression { get; }
    public bool HasExpression => FilterExpression != null;

    private ThingFilter(Func<Thing, bool> func)
    {
        FilterFunc = func;
    }

    private ThingFilter(Expression<Func<Thing, bool>> expression)
    {
        FilterExpression = expression;
        FilterFunc = expression.Compile();
    }

    // 支持从Expression隐式转换为ThingFilter
    public static implicit operator ThingFilter(Expression<Func<Thing, bool>> expression)
    {
        return new ThingFilter(expression);
    }

    // 支持从Func隐式转换为ThingFilter
    public static implicit operator ThingFilter(Func<Thing, bool> func)
    {
        return new ThingFilter(func);
    }
}

class ClassName
{
    void SelectItems(ThingFilter filter)
    {
        string filterDesc = null;
        if (filter.HasExpression)
        {
            filterDesc = PrettyPrintCSharpCode(filter.FilterExpression);
        }

        // 执行筛选
        var matchedItems = collection.Where(filter.FilterFunc).ToList();
        if (!matchedItems.Any())
        {
            var itemsList = string.Join(", ", collection.Select(t => t.ToString()));
            string errorMsg = filterDesc != null 
                ? $"Item matching filter \"{filterDesc}\" was not found. Items found: {itemsList}"
                : $"No item matching filter was found. Items found: {itemsList}";
            throw new InvalidOperationException(errorMsg);
        }
        // ... 后续处理逻辑
    }
}

效果说明： #

• 现有所有调用代码无需修改，隐式转换会自动将语句lambda转为Func包装，表达式lambda转为Expression包装。
• 统一在包装类中处理两种筛选器类型，代码逻辑更集中，后续扩展也更方便。

方案三：重命名方法区分类型（简单直接） #

如果允许修改部分调用代码，可以给接受Expression的方法单独命名，比如：

class ClassName
{
    // 原方法，处理语句lambda
    void SelectItems(Func<Thing, bool> filterFunc)
    {
        // 原逻辑
    }

    // 新方法，处理表达式lambda
    void SelectItemsWithExpression(Expression<Func<Thing, bool>> filterExpression)
    {
        // 带筛选器描述的逻辑
    }
}

效果说明： #

• 完全消除歧义，但需要手动修改所有传入表达式lambda的调用，改为调用SelectItemsWithExpression。适合调用点较少的场景。

内容的提问来源于stack exchange，提问作者Blarghedy