¿Puedo obtener el delta de dos IEnumerables en LINQ?

Question

No es el delta agregado sino el delta de cada elemento. Aquí hay un código para explicar lo que quiero decir:

var deltaTotals = _deltaEnumerable.Select(a => a.Amount).ToList(); 
var oldTotals = _totalsEnumerable.Select(d => d.Amount).ToList(); 

// trigger change in _totalsEnumerable 

// ** can LINQ do the lines below 
var newTotals = totalsEnumerable.Select(d => d.Amount); 
for (var i = 0; i < 7; i++) { 
    var newAmount = oldTotals[i] - deltaTotals[i]; 
    Assert.That(newTotals.ElementAt(i), Is.EqualTo(newAmount)); 
} 

Es las últimas cuatro líneas de código que parece como que podría haber una forma más elegante de hacerlo en LINQ alguna manera.

Cheers,
Berryl

Answer 1

Lo que desea es el método de extensión Enumerable.Zip.

Un ejemplo de uso sería:

var delta = oldTotals.Zip(newTotals, (o, n) => n.Amount - o.Amount); 

Tenga en cuenta que esto es nuevo para .NET 4.0. En .NET 3.5, deberías escribir tu propia extensión. Algo como esto:

public static IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(
    this IEnumerable<TFirst> first, 
    IEnumerable<TSecond> second, 
    Func<TFirst, TSecond, TResult> resultSelector) 
{ 
    using (var firstEnumerator = first.GetEnumerator()) 
    using (var secondEnumerator = second.GetEnumerator()) 
    { 
     while ((firstEnumerator.MoveNext() && secondEnumerator.MoveNext())) 
     { 
      yield return resultSelector(firstEnumerator.Current, 
       secondEnumerator.Current); 
     } 
    } 
} 

Answer 2

Este post está relacionada y proporciona una answer.

Answer 3

Como dijo Aaronaught en su respuesta, usted debe utilizar el método Zip; sin embargo, no está disponible en .NET 3.5, solo en 4.0. Aquí hay una implementación personalizada:

public static IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> selector) 
    { 
     if (first == null) 
      throw new ArgumentNullException("first"); 
     if (second == null) 
      throw new ArgumentNullException("second"); 
     if (selector == null) 
      throw new ArgumentNullException("selector"); 

     return first.ZipIterator(second, selector); 
    } 

    private static IEnumerable<TResult> ZipIterator<TFirst, TSecond, TResult>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> selector) 
    { 
     using (var enum1 = first.GetEnumerator()) 
     using (var enum2 = second.GetEnumerator()) 
     { 
      while (enum1.MoveNext() && enum2.MoveNext()) 
      { 
       yield return selector(enum1.Current, enum2.Current); 
      } 
     } 
    }