11

現在のオブジェクトと次のオブジェクトでいくつかの計算を行うために、順序付けられたリストをたどるエレガントなソリューションはありますか? 次のことを行うには、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;
}
4

4 に答える 4

9

Zipリストを 2 回反復処理する必要があるLINQ の列挙子を使用するソリューションの代わりに、シーケンスを反復処理して要素の "移動ペア" を返すカスタム 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);
于 2013-07-29T19:59:30.270 に答える
9

その他のオプションは、Aggregate 関数を使用して、現在の要素を集計として返すことです。これには、コレクションを 1 回だけ反復するという追加の利点があります。

 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;
 }
于 2013-07-29T20:12:06.483 に答える
5

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>
于 2013-07-29T19:43:26.953 に答える