c# - IEnumerable.Max() 是最快的方法吗？

Question

我正在开发软件的一部分，其中有一个样本列表(目前为 List<Sample>)，如下所示:

public class Sample
{
    //...
    public double ValueChannel1 { get; set; }
    public double ValueChannel2 { get; set; }
    //...
}

这些列表包含约 100 到数千个样本，每秒约有 10 万个样本。
现在我需要从每个列表中找出最大值和最小值，目前我按以下方式进行操作:

var Ch1Max = task.Samples.Max<Sample>(s => s.ValueChannel1);
var Ch1Min = task.Samples.Min<Sample>(s => s.ValueChannel1);
var Ch2Max = task.Samples.Max<Sample>(s => s.ValueChannel2);
var Ch2Min = task.Samples.Min<Sample>(s => s.ValueChannel2);

毫不奇怪，这不是很快，所以我问自己是否有更快的方法可以做到这一点，但我想不出也找不到？

有人知道更快的方法吗？ 也许有一种方法可以通过“一个循环”而不是一个用于最小值和一个用于最大值来查找最小值和最大值？

编辑:
我用以下结果分析了当前代码:
731 个任务，每个任务都包含这些列表之一需要 845 毫秒来处理，其中 95% 的任务用于最小/最大搜索。
我没有具体的“目标时间”，但由于它一直在我的应用程序中运行(因为它正在捕获测量数据)，它应该尽可能少地占用 CPU，以尽可能降低硬件要求......

找到的最佳解决方案:
最后我选择了 Tim 的解决方案，因为它比 Konrad 的解决方案更快:
Tim 的解决方案导致了约 53% 的加速，而 Konrads 的“仅”导致了约 43% 的加速。

最终解决方案(目前):

double Ch1Max = Double.MinValue, Ch1Min = Double.MaxValue;
double Ch2Max = Double.MinValue, Ch2Min = Double.MaxValue;

var samples = task.Samples.ToArray();
int count = samples.Length;
for (int i = 0; i < count; ++i)
{
    var valueChannel1 = samples[i].ValueChannel1; // get only once => faster
    if (valueChannel1 > Ch1Max) Ch1Max = valueChannel1;
    if (valueChannel1 < Ch1Min) Ch1Min = valueChannel1;

    var valueChannel2 = samples[i].ValueChannel2;
    if (valueChannel2 > Ch2Max) Ch2Max = valueChannel2;
    if (valueChannel2 < Ch2Min) Ch2Min = valueChannel2;
}

与我最初的解决方案相比，这总计提高了约 70% 的速度...

Answer 1

如果您可以控制您的 List<Sample>对象(我的意思是你不是从第三方代码等得到它)，你可以把它包装在你自己的类中，当你向它添加元素时，它会动态跟踪最大值和最小值。

只需查找新的 Sample 是否可用即可。如果是这样，不会“设置新记录”并相应地调整您缓存的最大值/最小值。

如果列表是向前的，这种方法会非常有效，例如。您没有从列表中删除元素。

编辑:

这是一个示例实现(这是一个“概念证明”，肯定有很多改进空间):

public class Sample
{
    public double ValueChannel1
    {
        get;
        set;
    }

    public double ValueChannel2
    {
        get;
        set;
    }

    // etc.
}

public class SampleList
{
    /* that's the list we're enwrapping. 
     * SampleList could also be inherited from List<Sample>, but in general this approach is less recommended -
     * read up on "composition over inheritance". */
    private List<Sample> _samples = new List<Sample>();

    /// <summary>
    /// Caches the lowest known value of ValueChannel1 property
    /// </summary>
    public double? ValueChannel1Minimum // it's a nullable double, because while the list is still empty, minimums and maximums have no value yet
    {
        get;
        private set;
    }
    public double? ValueChannel1Maximum { get; private set; }
    public double? ValueChannel2Minimum { get; private set; } 
    public double? ValueChannel2Maximum { get; private set; }

    public void Add(Sample sample)
    {
        if (sample == null)
        {
            throw new ArgumentNullException("sample");
        }
        // have you beat the record?
        if (sample.ValueChannel1 <= (ValueChannel1Minimum ?? double.MaxValue))
        {                
            // note: the essence of the trick with ?? operator is: if there's no minimum set yet, pretend the minimum to be the biggest value there is.
            // practically speaking, it ensures that the first element added to the list
            // sets the new minimum, whatever value that element had.
            ValueChannel1Minimum = sample.ValueChannel1;
        }
        if (sample.ValueChannel1 >= (ValueChannel1Maximum ?? double.MinValue))
        {
            ValueChannel1Maximum = sample.ValueChannel1;
        }

        // etc. for other properties

        _samples.Add(sample);
    }

    public List<Sample> ToList()
    {
        return _samples;
    }
}