如何实现兼容Linq且避免多次执行无需频繁调用ToList的接口方案？

解决方案 #

方案1：内置自动物化逻辑，调用侧无需感知 #

核心思路是把ToList的逻辑封装在你自己写的扩展方法内部，自动判断输入是否已经是内存集合，避免重复转换，同时返回已物化的集合类型，后续调用天然不会重复枚举。
首先写通用的物化工具方法：

public static class EnumerableHelper
{
    public static IReadOnlyList<T> Materialize<T>(this IEnumerable<T> input)
    {
        // 已经是内存集合就直接返回，避免多余拷贝
        if (input is IReadOnlyList<T> existingList)
            return existingList;
        // 否则执行一次枚举转成内存集合
        return input.ToList();
    }
}

改造你的业务扩展方法：

public static IReadOnlyList<int> IsBiggerThan2(this IEnumerable<int> input)
{
    var source = input.Materialize();
    // 方法内部可以多次使用source，不会触发重复枚举
    return source.Where(x => x > 2).Materialize();
}

public static IReadOnlyList<int> IsMod2(this IEnumerable<int> input)
{
    var source = input.Materialize();
    return source.Where(x => x % 2 == 0).Materialize();
}

public static IReadOnlyList<int> IsMod3(this IEnumerable<int> input)
{
    var source = input.Materialize();
    return source.Where(x => x % 3 == 0).Materialize();
}

改造后调用侧代码完全不需要加ToList，直接链式调用即可：

var firstCalculation = someInput.Select(x => x+1).Materialize();
var biggerAndMod2 = firstCalculation.IsBiggerThan2().IsMod2();
var biggerAndMod2And3 = firstCalculation.IsBiggerThan2().IsMod2().IsMod3();
var biggerAndMod2Plus1= biggerAndMod2.Select(x=> x+1).IsBiggerThan2();

所有返回的IReadOnlyList<T>同时兼容IEnumerable<T>的所有Linq能力，也不存在重复执行的问题。

方案2：管道模式统一执行，仅最后一次物化 #

如果你的链式调用步骤很多，中间步骤不需要单独保留结果，可采用管道模式把所有操作串起来，最后只执行一次物化，性能损耗最低：

public class CalculationPipeline<T>
{
    private readonly IEnumerable<T> _source;
    public CalculationPipeline(IEnumerable<T> source) => _source = source;

    public CalculationPipeline<T> AddFilter(Func<IEnumerable<T>, IEnumerable<T>> filter)
    {
        return new CalculationPipeline<T>(filter(_source));
    }

    public IReadOnlyList<T> Run() => _source.ToList();
}

// 适配你的扩展方法
public static CalculationPipeline<int> IsBiggerThan2(this CalculationPipeline<int> pipeline)
{
    return pipeline.AddFilter(s => s.Where(x => x > 2));
}

public static CalculationPipeline<int> IsMod2(this CalculationPipeline<int> pipeline)
{
    return pipeline.AddFilter(s => s.Where(x => x % 2 == 0));
}

调用方式：

var result = new CalculationPipeline<int>(someInput.Select(x => x + 1))
    .IsBiggerThan2()
    .IsMod2()
    .IsMod3()
    .Run(); // 全程只执行一次枚举，无多余拷贝

关于你提到的公共接口问题 #

不存在同时兼容IEnumerable懒加载语义和List物化语义的公共接口，是因为两者的核心设计目标互斥：

• IEnumerable<T>的本质是可迭代序列的承诺，不保证元素已经生成、也不保证可重复访问，可能来自数据库查询、网络流、动态生成逻辑等。
• List<T>的本质是已加载到内存的固定集合，所有元素都已生成、支持随机访问和重复遍历。
  接口是对统一行为的抽象，不可能同时满足两种互斥的语义，因此.NET基础类库没有提供这类接口。

内容的提问来源于stack exchange，提问作者Mohammad Hossein Amri