C # Linq-Anweisungen oder ein foreach () für Teilmengen in Höhe von?

Question

Welche dieser Lösungen wird bevorzugt?

Für eine Liste:

List<ExampleInfo> exampleList = new List<ExampleInfo>();

public class ExampleInfo
{
    internal ExampleInfo()
    { }
    /* Business Properties */
    public int Id { get; set; }
    public string Type { get; set; }
    public decimal Total { get; set; }
}

Ich wünsche Teilsummen erhalten basierend aus der ‚Total‘ Wert.

Option 1:

var subtotal1 = exampleList.Where(x => x.Type == "Subtype1").Sum(x => x.Total);
var subtotal2 = exampleList.Where(x => x.Type == "Subtype2").Sum(x => x.Total);

Option 2:

decimal subtotal1 = 0m;
decimal subtotal2 = 0m;
foreach (ExampleInfo example in exampleList)
{
    switch (example.Type)
    {
        case "Subtype1":
            subtotal1 += example.Total;
             break;
        case "Subtype2":
             subtotal2 += example.Total;
             break;
        default:
             break;

    }
}

Die Liste wird <10 Artikel in den meisten Fällen sein.

Bearbeiten: Chris einen sehr guten Punkt hob ich nicht erwähnt. Das Programm ist bereits mit .NET Framework 3.5 SP1 so Kompatibilität hier nicht ein wichtiger Aspekt ist.

Answer 1

Beide Beispiele haben Code dupliziert, und beide sind für einen Wechsel auf Type nicht bereit - was ist, wenn es drei Werte hatten? Was passiert, wenn es 30 hatte?
Sie könnten Linq zu gruppieren, indem sie es verwenden und die Gesamt bekommen:

var totals = from p in exampleList
             group p by p.Type into g
             select new { Type = g.Key, Total = g.Sum(p => p.Total ) };

So totals ist eine Sammlung von Objekten mit den Eigenschaften Type und Total

Answer 2

Unabhängig von Listengröße, wenn Sie 3,5 Targeting sind .NET ich mit LINQ gehen würde, wenn auch nur für die Lesbarkeit.

Ich bin ein großer Fan des Schreibens, was Sie meinen, nicht wie es gemacht wird und LINQ macht dies sehr einfach in solchen Fällen.

Sie können sich wahrscheinlich sogar die Berechnungen in einer einzigen LINQ-Anweisung, Gruppierung nach Typ ziehen. Auf diese Weise werden Sie nicht zwei Schleifen für LINQ haben aber nur eine, wie im zweiten Beispiel:

var subtotals = from x in exampleList
                group x by x.Type into g
                select new { Type = x.Key, SubTotal = g.Sum(x => x.Total) };

(nicht ganz sicher, ob der Code wie es funktioniert, es ist nur eine schnelle Anpassung von einem der 101 LINQ Samples . Syntax ok sein sollte, though.)

Answer 3

Option 3

var groupings = exampleList
    .GroupBy(x => x.Type, x => x.Total)
    .Select(x => new { Type = x.Key, SubTotal = x.Sum() } );

Sie erhalten eine Liste von Klassen wie folgt:

class <Anonymous>
{
    public string Type { get; }    
    public decimal SubTotal { get; }  
}

auf den entsprechenden Wert Auflisten und zuweisen, obwohl es viel des Guten für eine so kleine Menge sein könnte.

Answer 4

Ich glaube nicht, es würde vielen Unterschied in der Leistung für solche kleine Listen sein.

Option 1 wird durch die Liste iterieren zweimal während Option 2 nur einmal in der Liste durchläuft. Das kann wichtiger sein für größere Listen als kleine Anmerkung.

Option 1 ist besser lesbar, aber ich würde auf jeden Fall stellen Sie sicher, um einen Kommentar zu machen, dass es zweimal durch die Liste durchläuft.

Der offensichtliche Vorteil zu Option 2 ist, dass der Code funktioniert in .NET Framework 2.0. Mit LINQ bedeutet, dass Ihre Anwendung erfordert .NET Framework 3.5.

Answer 5

Für option1 wird intern die foreach-Schleife zweimal durch die env-C # Laufzeit ausgeführt werden. Daher wird die Verarbeitung Typ mehr sein. Aber für <10 Stück, macht es kaum einen Unterschied, und die Option 1 scheint besser lesbar. Ich würde mit der Option gehe 1 für <10 Stück.