LINQ Lambda-加入，不同

Question

I am still learning to develop LINQ lambda expressions.

I have a parent table Requests and a child table Sponsor that will have 0 or 1 row associated with a request. I would like to show a list of past sponsors that a user might have defined in any of his/her previous requests.

1st: I can find all previous requests entered by a user (Request.UserId == 1111);

2nd: The tables are associated by RequestId (request.RequestId == Sponsor.RequestId);

3rd: I want to limit the rows returned based on distinct Sponsor.Email (return the max Sponsor.RequestId based on distinct Sponsor.Email);

4th: I want them ordered by the latest sponsor used (order by descending Sponsor.RequestId);

One last caveat, I only want to return sponsor records were the Sponsor.LastNm is not null (A previous upgrade issue).

So I am close, but I am not filtering out based on emails being the same:

db.Requests
   .Where (req => req.UserID == 1111)
   .Join(db.Sponsors, 
      req => req.RequestID, 
      spon => spon.RequestID, 
      (req, spon) => new { Requests = req, Sponsors = spon })
   .Where(both => both.Sponsors.LastNm != null)
   .OrderByDescending(both => both.Sponsors.RequestID);

At a minimum I need the Request.DateRequested and entire Sponsor row returned.

Request Table (only certain columns)

RequestId    UserId   DateRequested
12           1111     2013-10-12
34           1111     2013-10-23
56           2222     2013-10-25
87           1111     2013-11-02
99           1111     2013-11-15

Sponsor Table (only certain columns)

RequestId   Email                LastNm
12          abc.xyz.com
34          abc@xyz.com          Doe
87          abc@xyz.com          Doe
99          def@xyz.com          Doe

So I would like to have the following rows returned

Request.DateRequested   Sponsor
2013-11-15              99, def@xyz.com, Doe
2013-11-02              87, abc@xyz.com, DOe

Answer 1

I find it easier to write my LINQ queries in query syntax style. It really does improve readability for me.

        var qry = from r in db.Requests
                  join s in db.Sponsors on r.RequestID equals s.RequestID
                  where r.UserID == 111 &&
                    s.LastNm != null
                  orderby s.RequestID descending
                  group new { Request = r, Sponsor = s } by s.EMail into g
                  select g.First();

Sticking with function notation, it would be:

        var qry = db.requests
            .Where(req => req.UserID == 111)
            .Join(db.sponsors,
            req => req.RequestID,
            spon => spon.RequestID,
            (req, spon) => new { Requests = req, Sponsor = spon })
            .Where(both => both.Sponsor.LastNm != null)
            .OrderByDescending(both => both.Sponsor.RequestID)
            .GroupBy(both => both.Sponsor.EMail)
            .Select(group => group.First());

This produces the result I think you are going for. With a local replica of your data in two separate arrays,and using the following loop:

        foreach (var rec in qry)
            Console.WriteLine("{0}\t{1}\t{2}\t{3}", rec.Request.DateRequested, rec.Request.RequestID, rec.Sponsor.EMail, rec.Sponsor.LastNm);

I get:

11/15/2013 12:00:00 AM  99      def@xyz.com     Doe
11/2/2013 12:00:00 AM   87      abc@xyz.com     Doe

Also, if you have referential integrity in your database and are using EntityFramework (or OpenAccess) you can replace the join with two froms.

from r in requests
from s in r.sponsors