Berechnen Sie Unterschied sich von vorherigen Element, das mit LINQ

Einer option (für LINQ to Objects) sein würde, zu erstellen Sie Ihre eigenen LINQ-Betreiber:

//I don't like this name :(
public static IEnumerable<TResult> SelectWithPrevious<TSource, TResult>
    (this IEnumerable<TSource> source,
     Func<TSource, TSource, TResult> projection)
{
    using (var iterator = source.GetEnumerator())
    {
        if (!iterator.MoveNext())
        {
             yield break;
        }
        TSource previous = iterator.Current;
        while (iterator.MoveNext())
        {
            yield return projection(previous, iterator.Current);
            previous = iterator.Current;
        }
    }
}

Dies ermöglicht Ihnen, Ihre Projektion mit nur einem einzigen Durchlauf des Quell-Sequenz, das ist immer ein bonus (mir läuft es über eine große log-Datei).

Beachten Sie, dass es Projekt eine Sequenz der Länge n in einer Sequenz der Länge n-1 - möchten Sie vielleicht voranstellen eines "dummy" - erstes element, zum Beispiel. (Oder ändern Sie die Methode, um eine.)

Hier ist ein Beispiel, wie Sie möchten, verwenden Sie:

var query = list.SelectWithPrevious((prev, cur) =>
     new { ID = cur.ID, Date = cur.Date, DateDiff = (cur.Date - prev.Date).Days) });

Beachten Sie, dass dies umfasst das endgültige Ergebnis ist eine ID, mit der das erste Ergebnis der nächsten ID... möchten Sie vielleicht, um Ihre Sequenz-ID-ersten.

In C#4 können Sie die Zip-Methode, um zwei Elemente zu einem Zeitpunkt. Wie diese:

        var list1 = list.Take(list.Count() - 1);
        var list2 = list.Skip(1);
        var diff = list1.Zip(list2, (item1, item2) => ...);

Noch eine andere mod auf Jon Skeet ist version (danke für deine Lösung +1). Ausgenommen hiervon ist die Rückgabe einer aufzählbaren von Tupeln.

public static IEnumerable<Tuple<T, T>> Intermediate<T>(this IEnumerable<T> source)
{
    using (var iterator = source.GetEnumerator())
    {
        if (!iterator.MoveNext())
        {
            yield break;
        }
        T previous = iterator.Current;
        while (iterator.MoveNext())
        {
            yield return new Tuple<T, T>(previous, iterator.Current);
            previous = iterator.Current;
        }
    }
}

Dies ist NICHT Rücksendung der ersten, weil es über die Rückkehr der intermediate zwischen den Elementen.

verwenden Sie es wie:

public class MyObject
{
    public int ID { get; set; }
    public DateTime Date { get; set; }
    public int Value { get; set; }
}

var myObjectList = new List<MyObject>();

//don't forget to order on `Date`

foreach(var deltaItem in myObjectList.Intermediate())
{
    var delta = deltaItem.Second.Offset - deltaItem.First.Offset;
    //..
}

ODER

var newList = myObjectList.Intermediate().Select(item => item.Second.Date - item.First.Date);

ODER (wie jon zeigt)

var newList = myObjectList.Intermediate().Select(item => new 
{ 
    ID = item.Second.ID, 
    Date = item.Second.Date, 
    DateDiff = (item.Second.Date - item.First.Date).Days
});