c# - 使用 LINQ 对当前和下一个对象进行一些计算

Question

是否有一个优雅的解决方案来遍历有序列表以对当前和下一个对象进行一些计算？LINQ 必须有一种更智能的方式来执行以下操作：

public static List<double> GetHoursBetweenDates(List<DateTime> aDates)
{
    List<double> lst = new List<double>();
    var olst = aDates.OrderByDescending(d => d).ToList();
    for (int i = 0; i < olst.Count - 1; i++)
    {
        lst.Add(olst[i].Subtract(olst[i+1]).TotalHours);
    }
    return lst;
}

Answer 1

比较列表中每个连续元素的最简单方法是：

var sorted = aDates.OrderByDescending(d => d);
var results = 
    sorted.Zip(sorted.Skip(1), (a, b) => a.Subtract(b).TotalHours);

或者，您可以这样做：

var sorted = aDates.OrderByDescending(d => d).ToArray();
var results = 
    from i in Enumerable.Range(0, sorted.Length - 1)
    select sorted[i].Subtract(sorted[i + 1]).TotalHours;

但是这第二种方法只能工作List<T>，T[]或者任何支持数组样式索引器的类型。

Answer 2

作为使用 LINQZip枚举器的解决方案的替代方案，这需要您对列表进行两次迭代，这是一个自定义 LINQ 运算符，它迭代一个序列并返回一个“移动的对”元素：

static IEnumerable<Tuple<T, T>> Pairwise<T>(this IEnumerable<T> xs)
{
    using (IEnumerator<T> enumerator = xs.GetEnumerator())
    {
        if (!enumerator.MoveNext()) yield break;
        T current = enumerator.Current;
        while (enumerator.MoveNext())
        {
            T previous = current;
            current = enumerator.Current;
            yield return Tuple.Create(previous, current);
        }
    }
}

然后，您可以将其应用于您的DateTime序列，如下所示：

dates.Pairwise().Select(_ => _.Item2.Subtract(_.Item1).TotalHours);

Answer 3

其他选项是使用聚合函数，并将当前元素作为聚合返回。这还有一个额外的好处，即您只对集合进行一次迭代：

 public static List<double> GetHoursBetweenDates(List<DateTime> aDates)
 {
     List<double> lst = new List<double>();
     aDates.OrderByDescending(d => d).Aggregate((prev, curr) => { lst.Add(prev.Subtract(curr).TotalHours); return curr; });
     return lst;
 }

Answer 4

您可以使用moreLINQ库中Incremental的扩展方法：

public static List<double> GetHoursBetweenDates(List<DateTime> aDates)
{
    return aDates.OrderByDescending(d => d)
                 .Incremental((p,n) => p.Subtract(n).TotalHours)
                 .ToList();
}

它完全符合您的需要：

/// <summary>
/// Computes an incremental value between every adjacent element in a sequence: {N,N+1}, {N+1,N+2}, ...
/// </summary>
/// <remarks>
/// The projection function is passed the previous and next element (in that order) and may use
/// either or both in computing the result.<
/// If the sequence has less than two items, the result is always an empty sequence.
/// The number of items in the resulting sequence is always one less than in the source sequence.
/// </remarks>