Операторы c# Linq или foreach() для суммирования подмножеств?

какое из этих решений предпочтительнее?

список:

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; }
}

Я хочу получить промежуточные итоги на основе "общего" значения.

Вариант 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);

Вариант 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;

    }
}

список будет

Edit: Крис поднял очень хороший вопрос, о котором я не упомянул. Программа уже использует .NET Framework 3.5 SP1, поэтому совместимость не является важным фактором здесь.

6
c# foreach linq

5 ответов

оба этих примера имеют дублированный код, и оба не готовы к изменению на Type - что, если бы у него было три значения? А если бы их было 30?
Вы можете использовать linq для группировки по нему и получить общее:

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

так totals представляет собой набор объектов со свойствами Type и Total

4

независимо от размера списка, если вы нацелены на .NET 3.5, я бы пошел с LINQ, хотя бы для удобства чтения.

Я большой поклонник написания того, что вы имеете в виду, а не как это делается, и LINQ делает это очень легко в таких случаях.

вы, вероятно, даже можете вытащить вычисления в один оператор LINQ, группируя по типу. Таким образом, у вас не будет двух циклов для LINQ, а только один, как во втором примере:

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

(Не совсем уверен, работает ли код, как это, это просто быстрая адаптация от одного из 101 LINQ Samples. Синтаксис должен быть в порядке.)

5

3

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

у вас будет список таких классов:

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

перечислить и присвоить соответствующее значение, хотя это может быть излишним для такого небольшого набора.

4

Я не думаю, что для таких маленьких списков будет большая разница в производительности.

опция 1 повторит список дважды, в то время как опция 2 повторяет список только один раз. Это может быть более важно отметить для больших списков, чем для небольших.

Вариант 1 более удобочитаем, но я бы обязательно сделал комментарий, который он повторяет через список дважды.

очевидным преимуществом варианта 2 является то, что код работает в .NET Framework версии 2.0. Использование LINQ означает, что вашему приложению требуется .NET Framework 3.5.

2

для option1 внутренний цикл foreach будет выполняться дважды env времени выполнения C#. Следовательно, тип обработки будет больше. Но для

1