如何在Linq中按具有复杂类型的多列分组

Question

I'm trying to preform a group by to get all of the students, by college, grouped by status. The problem is the database I'm working with has hundreds of fields in the StudentInfo table, which is why I think this is failing.

I'm basically trying to get counts for the students by their statuses, and grouped by the college they are from.

When I execute this query, I get the following exception.

The key selector type for the call to the 'GroupBy' method is not comparable in the underlying store provider.

Now I believe this is because there are way too many fields on the StudentInfo table, but I can't do anything about that in this case. There has to be a way to do what I want.

I need the following fields returned, all of which are counts, except College.

College | Accepts | Webapps | Ays | Total

Can someone please point me in the right direction.

Here is my model

public class EnrollmentCountsBySchool
{
    // selected terms
    public int[] SelectedTerms { get; set; }
    // list of terms
    public IEnumerable<SelectListItem> Terms { get; set; }

    // selected programs
    public int[] SelectedPrograms { get; set; }
    // list of programs
    public IEnumerable<SelectListItem> Programs { get; set; }

    // selected statuses
    public string[] SelectedStatuses { get; set; }
    // list of statuses
    public IEnumerable<SelectListItem> Statuses { get; set; }

    // list of results
    public List<EnrollmentCountsBySchoolResult> Results { get; set; }

My Query (way to long, I know.)

 var results =
            (from student in db.StudentInfo
             join college in db.Colleges on student.College.Id equals college.Id
             where model.SelectedTerms.Contains(student.TermOfInterestId.Value) &&
                   model.SelectedPrograms.Contains(student.ProgramId.Value) &&
                   model.SelectedStatuses.Contains(student.Status)

             group student by new
             {
                 College = college.Name,
                 Accepts = (
                         from s in db.StudentInfo
                         join c in db.Colleges on student.College.Id equals college.Id
                         where model.SelectedTerms.Contains(student.TermOfInterestId.Value) &&
                               model.SelectedPrograms.Contains(student.ProgramId.Value) &&
                               model.SelectedStatuses.Contains(student.Status) &&
                               student.Status.ToLower().Contains("accepted") ||
                               student.Status.ToLower().Contains("applicant")
                         group s by new
                         {
                             College = c.Name,
                         } into accepts
                         select new
                         {
                             accepts.Key.College,
                             Count = accepts.Count()
                         }
                 ),
                 Webapps =
                 (
                         from s in db.StudentInfo
                         join c in db.Colleges on student.College.Id equals college.Id
                         where model.SelectedTerms.Contains(student.TermOfInterestId.Value) &&
                               model.SelectedPrograms.Contains(student.ProgramId.Value) &&
                               model.SelectedStatuses.Contains(student.Status) &&
                               student.Status.ToLower().Contains("webapp")
                         group s by new
                         {
                             College = c.Name,
                         } into webapps
                         select new
                         {
                             webapps.Key.College,
                             Count = webapps.Count()
                         }
                 ),
                 Ays = (
                         from s in db.StudentInfo
                         join c in db.Colleges on student.College.Id equals college.Id
                         where model.SelectedTerms.Contains(student.TermOfInterestId.Value) &&
                               model.SelectedPrograms.Contains(student.ProgramId.Value) &&
                               model.SelectedStatuses.Contains(student.Status) &&
                               !student.Status.ToLower().Contains("accepted") &&
                               !student.Status.ToLower().Contains("applicant") &&
                               !student.Status.ToLower().Contains("webapp")
                         group s by new
                         {
                             College = c.Name,
                         } into ays
                         select new
                         {
                             ays.Key.College,
                             Count = ays.Count()
                         }
                 ),
                 Total = (
                         from s in db.StudentInfo
                         join c in db.Colleges on student.College.Id equals college.Id
                         where model.SelectedTerms.Contains(student.TermOfInterestId.Value) &&
                               model.SelectedPrograms.Contains(student.ProgramId.Value) &&
                               model.SelectedStatuses.Contains(student.Status)
                         group s by new
                         {
                             College = c.Name,
                         } into totals
                         select new
                         {
                             totals.Key.College,
                             Count = totals.Count()
                         }
                 )

             }
                 into grouping
                 select new EnrollmentCountsBySchoolResult
                 {
                     College = grouping.Key.College,
                     Accepts = grouping.Key.Accepts.Count(),
                     Webapps = grouping.Key.Webapps.Count(),
                     Ays = grouping.Key.Ays.Count(),
                     Total = grouping.Key.Total.Count()
                 }).ToList();

Answer 1

I ended up re-writing the query to search by colleges and join students, then do the grouping and I got the results I was looking for.

       var results =
            from college in db.Colleges
            join student in db.StudentInfo on college.Id equals student.UniversityId
            where model.SelectedTerms.Contains(student.TermOfInterestId.Value) &&
                  model.SelectedPrograms.Contains(student.ProgramId.Value) &&
                  model.SelectedStatuses.Contains(student.Status)
            group college by new
            {
                College = college.Name,
                Accepts = (
                 from c1 in db.Colleges
                 join s1 in db.StudentInfo on c1.Id equals s1.UniversityId
                 where model.SelectedTerms.Contains(s1.TermOfInterestId.Value) &&
                       model.SelectedPrograms.Contains(s1.ProgramId.Value) &&
                       model.SelectedStatuses.Contains(s1.Status) &&
                       s1.UniversityId == college.Id &&
                       s1.Status.ToLower().Contains("accepted") || s1.Status.ToLower().Contains("applicant")
                 select c1
                ).Count(),
                Webapps = (
                    from c2 in db.Colleges
                    join s2 in db.StudentInfo on c2.Id equals s2.UniversityId
                    where model.SelectedTerms.Contains(s2.TermOfInterestId.Value) &&
                          model.SelectedPrograms.Contains(s2.ProgramId.Value) &&
                          model.SelectedStatuses.Contains(s2.Status) &&
                          s2.UniversityId == college.Id &&
                          s2.Status.ToLower().Contains("webapp")
                    select c2
                ).Count(),
                Ays = (
                    from c3 in db.Colleges
                    join s3 in db.StudentInfo on c3.Id equals s3.UniversityId
                    where model.SelectedTerms.Contains(s3.TermOfInterestId.Value) &&
                          model.SelectedPrograms.Contains(s3.ProgramId.Value) &&
                          model.SelectedStatuses.Contains(s3.Status) &&
                          s3.UniversityId == college.Id &&
                          !s3.Status.ToLower().Contains("accepted") && !s3.Status.ToLower().Contains("applicant") &&
                          !s3.Status.ToLower().Contains("webapp")
                    select c3
                ).Count()
            }
                into grouping
                select new EnrollmentCountsBySchoolResult
                {
                    College = grouping.Key.College,
                    Accepts = grouping.Key.Accepts,
                    Webapps = grouping.Key.Webapps,
                    Ays = grouping.Key.Ays,
                    Total = grouping.Count()
                };

        model.Results = results.OrderByDescending(o => o.Total).ToList();