包含表上的实体框架分组

Question

I've two tables joined in 1-n way.

First Table - Users :

Second Table - Consent :

In SQL Server i use this query

SELECT *
FROM Users
  Inner Join (
    Select Consent.IDUser, Consent.Type, Consent.Date, Consent.Consent
    From Consent
    Inner Join (
        Select IDUser, Type, Max(Date) as MaxDate
        From Consent
        Group By IDUser, Type
    ) As ConsentGrouped on Consent.IDUser = ConsentGrouped.IDUser and Consent.Type = ConsentGrouped.Type and Consent.Date = ConsentGrouped.MaxDate
  ) as AllData
  On Users.id = AllData.IDUser

to achieve this

In my .NET project i use entity framework, so i've this two entities:

    public partial class Users
    {
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors")]
        public Users()
        {
            this.Consent = new HashSet<Consent>();
        }

        public int Id { get; set; }
        public string Name { get; set; }
        public string Surname { get; set; }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")]
        public virtual ICollection<Consent> Consent{ get; set; }
    }

public partial class Consent
{
    public int Id { get; set; }
    public Nullable<int> IDUser { get; set; }
    public string Type { get; set; }
    public string Origin { get; set; }
    public Nullable<System.DateTime> Date { get; set; }
    public Nullable<bool> Consent { get; set; }

    public virtual Users Users { get; set; }
}

How can i obtain the same query result via Entity Framework? So only the most recent consent by type for each user.

I use this lambda to get the user, how can I modify it to obtain the desired result?

 var user = await db.Users
     .Include(ut => ut.Consent)
     .Where(ut => ut.Id == userID)
     .FirstOrDefaultAsync();

Thanks!

Answer 1

Here I used LINQ instead of lambda expressions because in this scenario lambda can be tricky sometimes, I also used explicit join so the explanation got easier to understand.

var query = (from user in users
                    join consent in consents
                        on user.Id equals consent.IdUser
                    group new {user, consent} by new {consent.Type, consent.IdUser} into g 
                    select new { 
                            g.FirstOrDefault().user.Id, 
                            g.FirstOrDefault().user.Name,
                            g.FirstOrDefault().user.SureName,
                            ConsentId = g.FirstOrDefault().consent.Id,
                            g.FirstOrDefault().consent.IdUser,
                            g.FirstOrDefault().consent.Type,
                            g.FirstOrDefault().consent.Origin,
                            Date = g.Max(m => m.consent.Date),
                            g.FirstOrDefault().consent.ConsentFlag
                        }).ToList();

Answer 2

After some tests and several researches, I managed to solve using a complex lambda.

var user = db.Users
    .Where(ut => ut.Id == userID)
    .Select(b => new UsersResource
        {
            Id = b.Id,
            Name = b.Name,
            Surname = b.Surname,
            Consent = b.Consent
            .GroupBy(item => item.Type,
                (key, g) => g.OrderByDescending(gx => gx.Date).FirstOrDefault())
            .Select(st => new ConsentResource
                {
                    Id = st.Id,
                    IDUser = st.IDUser,
                    Type = st.Type,
                    Origin = st.Origin,
                    Date = st.Date,
                    Consent = st.Consent
                }).ToList()
             }).FirstOrDefault();