Calculate Percent Change From IGrouping Count in Linq/C#-CodePudding

I would like to have a "percent change for 'Investigations' and 'Breaches' by each quarter. I'm currently grouping by quarter and getting counts but I cannot figure out how to add percent change.

This is what I want to have a IEnumerable/List of:

public class StatusCountDto
{
    public string Quarter { get; set; }
    public int Investigations { get; set; }
    public double InvestigationsChange { get; set; }
    public int Breaches { get; set; }
    public double BreachesChange { get; set; }
}

Currently I am grouping by the Quarter and getting counts but I cannot figure out how to get the percent change of Investigation counts and Breaches counts from the previous quarter. The data is already sorted by Quarter. If the previous value doesn't exit (first index) then it should be 0.

This is what I have so far.

Metrics.GroupBy(m => m.Quarter )
    .Select((g, index) => new StatusCountDto 
    { 
        Quarter = g.Key, 
        Investigations = g.Count(), 
        Breaches = g.Where(a => a.Breach == "Yes").Count() 
    })
    .ToList();

Is there a way to use the index to calculate the percent change?

CodePudding user response：

Using an extension method based on the APL scan operator, which is like Aggregate but returns the intermediate results, you can run through the data and refer back to previous counts.

// TRes combineFn(TRes PrevResult, T CurItem)
// First PrevResult is TRes seedFn(T FirstItem)
// FirstItem = items.First()
// First CurItem = items.Skip(1).First()
// output is seedFn(items.First()), combineFn(PrevResult, CurItem), ...
public static IEnumerable<TRes> Scan<T, TRes>(this IEnumerable<T> items, Func<T, TRes> seedFn, Func<TRes, T, TRes> combineFn) {
    using (var itemsEnum = items.GetEnumerator()) {
        if (itemsEnum.MoveNext()) {
            var prev = seedFn(itemsEnum.Current);

            for (; ; ) {
                yield return prev;
                if (!itemsEnum.MoveNext())
                    yield break;
                prev = combineFn(prev, itemsEnum.Current);
            }
        }
    }
}

Given this variation of Scan that uses a lambda to seed the result stream, you can use it to compute the whole stream:

var ans = Metrics
        .GroupBy(m => m.Quarter)
        .Select(g => new {
            Quarter = g.Key,
            Investigations = g.Count(),
            Breaches = g.Count(a => a.Breach == "Yes")
        })
        .Scan(f => new StatusCountDto { // first result
                Quarter = f.Quarter,
                Investigations = f.Investigations,
                Breaches = f.Breaches
            },
            (prev, cur) => new StatusCountDto { // subsequent results
                Quarter = cur.Quarter,
                Investigations = cur.Investigations,
                InvestigationsChange = 100.0 * (cur.Investigations - prev.Investigations) / prev.Investigations,
                Breaches = cur.Breaches,
                BreachesChange = 100.0 * (cur.Breaches - prev.Breaches) / prev.Breaches
            }
        )
        .ToList();