Question

Hi I have the following code which returns me the right data but it seems there must be a better way to combine 3 lists, based on their common field(s) and transpose the results out into a new list of a given type using LINQ, instead of resorting to the foreach at the end. Any ideas?

  public IEnumerable<StagSummaryByCflHistoricalItem> GetSummaryByCflHistorical(DateTime currentDate)
  {
     var allRecords =
        this.preGrantSummaryHistoricalRepository
           .AllWithFetch(this.preGrantSummaryHistoricalRepository.All, x => x.CaseFileLocation)
           .Where(
           x => x.Date >= currentDate.FirstDayOfQuarterFromDateTime()
           && x.Date <= currentDate.LastDayOfQuarterFromDateTime())
           .ToList();

     var summaryForQuarter =
        allRecords.GroupBy(x => new { x.CaseFileLocation.Id, x.CaseFileLocation.Name }).Select(
           x =>
           new
              {
                 CaseFileLocationId = x.Key.Id,
                 Description = x.Key.Name,
                 TotalCasesEnteredCfl = x.Sum(y => y.TotalCasesEntered),
                 TotalNetFeeEnteredCfl = x.Sum(y => y.TotalNetFeeEntered),
                 TotalCasesLeftCfl = x.Sum(y => y.TotalCasesLeft),
                 TotalNetFeeLeftCfl = x.Sum(y => y.TotalNetFeeLeft)
              })
              .OrderBy(x => x.CaseFileLocationId)
              .ToList();

     var summaryForMonth =
        allRecords.Where(x => x.Date >= currentDate.FirstDayOfMonthFromDateTime())
        .GroupBy(x => new { x.CaseFileLocation.Id, x.CaseFileLocation.Name }).Select(
           x =>
           new
              {
                 CaseFileLocationId = x.Key.Id,
                 Description = x.Key.Name,
                 TotalCasesEnteredCfl = x.Sum(y => y.TotalCasesEntered),
                 TotalNetFeeEnteredCfl = x.Sum(y => y.TotalNetFeeEntered),
                 TotalCasesLeftCfl = x.Sum(y => y.TotalCasesLeft),
                 TotalNetFeeLeftCfl = x.Sum(y => y.TotalNetFeeLeft)
              })
              .OrderBy(x => x.CaseFileLocationId)
              .ToList();

     var summaryForWeek =
        allRecords.Where(x => x.Date >= currentDate.FirstDayOfWeekFromDateTime(DayOfWeek.Monday)).GroupBy(
           x => new { x.CaseFileLocation.Id, x.CaseFileLocation.Name }).Select(
              x =>
              new
                 {
                    CaseFileLocationId = x.Key.Id,
                    Description = x.Key.Name,
                    TotalCasesEnteredCfl = x.Sum(y => y.TotalCasesEntered),
                    TotalNetFeeEnteredCfl = x.Sum(y => y.TotalNetFeeEntered),
                    TotalCasesLeftCfl = x.Sum(y => y.TotalCasesLeft),
                    TotalNetFeeLeftCfl = x.Sum(y => y.TotalNetFeeLeft)
                 })
                 .OrderBy(x => x.CaseFileLocationId)
                 .ToList();

     var finalList = summaryForQuarter
        .Select(x => new StagSummaryByCflHistoricalItem()
           {
              CaseFileLocationId = x.CaseFileLocationId,
              Description = x.Description,
              QuarterTotalCasesEnteredCfl = x.TotalCasesEnteredCfl,
              QuarterTotalCasesLeftCfl = x.TotalCasesLeftCfl,
              QuarterTotalNetFeeEnteredCfl = x.TotalNetFeeEnteredCfl,
              QuarterTotalNetFeeLeftCfl = x.TotalNetFeeLeftCfl
           })
           .OrderBy(x => x.CaseFileLocationId)
           .ToList();

     foreach (var qrt in finalList)
     {

        var mnthData = summaryForMonth.FirstOrDefault(x => x.CaseFileLocationId == qrt.CaseFileLocationId);

        if (mnthData != null)
        {
           qrt.MonthTotalCasesEnteredCfl = mnthData.TotalCasesEnteredCfl;
           qrt.MonthTotalCasesLeftCfl = mnthData.TotalCasesLeftCfl;
           qrt.MonthTotalNetFeeEnteredCfl = mnthData.TotalNetFeeEnteredCfl;
           qrt.MonthTotalNetFeeLeftCfl = mnthData.TotalNetFeeLeftCfl;
        }

        var weekData = summaryForWeek.FirstOrDefault(x => x.CaseFileLocationId == qrt.CaseFileLocationId);
        if (weekData == null)
        {
           continue;
        }
        qrt.WeekTotalCasesEnteredCfl = weekData.TotalCasesEnteredCfl;
        qrt.WeekTotalCasesLeftCfl = weekData.TotalCasesLeftCfl;
        qrt.WeekTotalNetFeeEnteredCfl = weekData.TotalNetFeeEnteredCfl;
        qrt.WeekTotalNetFeeLeftCfl = weekData.TotalNetFeeLeftCfl;
     }

     return finalList;
  }

Note: I am intentionally getting the entire quarter’s worth of data first as a list and then operating on it to do the month & quarter totals but this is mainly because I cannot fathom a way to get the end result from a combined LINQ IQuerable.

I am using NHibernate, LINQ method syntax, the repository pattern and SQL Server 2008

Answer 1

If I’m reading your code correctly, you’re projecting your results to anonymous types with the same resulting members, which makes it very easy to join your results together. I did something similar recently with Union. Here’s a simplified example I just wrote to demonstrate:

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;

namespace ConsoleApplication1 {
    public class Month {
        public int MonthID { get; set; }
        public string MonthName { get; set; }
        public int NoDays { get; set; }
    }

    internal class Program {
        private static void Main(string[] args) {
            // Build up months
            var months = new List<Month>();
            for (var i = 1; i <= 12; i++) {
                months.Add(new Month {
                    MonthID = i,
                    MonthName = DateTimeFormatInfo.CurrentInfo.GetMonthName(i),
                    NoDays = DateTime.DaysInMonth(2012, i)
                });
            }

            var w = months.Select(m => new {
                m.MonthName
            });

            var x = months.Select(m => new {
                m.MonthName
            });

            var y = months.Select(m => new {
                m.MonthName
            });

            var z = w.Union(x).Union(y);

            foreach (var m in z) {
                Console.WriteLine(m.MonthName);
            }
            Console.Read();
        }
    }
}

Bear in mind that “Union” (like the SQL UNION clause) will remove any duplicates from your list. If you don’t want to remove duplicates (i.e. perform a “union all”), use “Concat” as follows:

var z = w.Concat(x).Concat(y);