Czy można przeciążać Sum, aby dodać typy niestandardowe?

Question

Mam strukturę pieniężną z walutą i kwotą. Chciałbym móc podsumować listę za pomocą linq.

public struct Money 
{ 
    public string Currency { get; set; } 
    public decimal Amount { get; set; } 

    public static Money operator +(Money m1, Money m2) 
    { 
     if (m1.Currency != m2.Currency) 
      throw new InvalidOperationException(); 

     return new Money() { Amount = m1.Amount + m2.Amount, Currency = m1.Currency }; 
    } 
} 

Biorąc pod uwagę powyższy kod, jeśli mam listę elementów, które mają obiekty wartości pieniądza jest to możliwe, aby uzyskać funkcji Sum do pracy z obiektem wartości pieniądza.

tj

Items.Sum(m => m.MoneyValue); 

Answer 1

public static class SumExtensions 
{ 
    public static Money Sum(this IEnumerable<Money> source) 
    { 
     return source.Aggregate((x, y) => x + y); 
    } 

    public static Money Sum<T>(this IEnumerable<T> source, Func<T, Money> selector) 
    { 
     return source.Select(selector).Aggregate((x, y) => x + y); 
    } 
} 

Zastosowanie:

IEnumerable<Money> moneys = ... 
Money sum = moneys.Sum(); 

i

IEnumerable<Transaction> txs = ... 
Money sum = txs.Sum(x=>x.Amount); 

Answer 2

To powinno działać, jeśli wrócisz m.MoneyValue.Amount zamiast - nie a set of Sum overloads that accept a Func.

Niestety Sum nie jest zgodny z żadnym zdefiniowanym przez użytkownika operator+. (W rzeczywistości nie można było wywołać operator+ bez użycia odbicia.)

Answer 3

Operatorzy to ból. Jednak jeśli spojrzysz na MiscUtil, zaimplementowałem ogólny , który ma względem operatorów niestandardowych. Użycie jest (celowo) identyczne - tak linia:

var moneySum = Items.Sum(m => m.MoneyValue); 

powinny działać, z oczekiwanego rezultatu - wyjątkiem, że obecnie nie obsługuje default(Money) celach kwasami. Ewentualnie, jeśli jest to tylko dla MoneyValue, wystarczy napisać metodę rozszerzenia:

public static class MoneyExtensions { 
    public static Money Sum(this IEnumerable<Money> source) { 
     Money sum = source.First(); 
     foreach(var item in source.Skip(1)) sum += item; 
     return sum; 
    } 
} 

Faktycznie, w celu uniknięcia 2 wyliczeń, mogę podkręcić do tego:

using (var iter = source.GetEnumerator()) 
{ 
    if (!iter.MoveNext()) return default(Money); 
    var sum = iter.Current; 
    while (iter.MoveNext()) sum += iter.Current; 
    return sum; 
}