C# LINQ Lambda-连接，独立

我仍在学习开发LINQ lambda表达式

我有一个父表请求和一个子表发起人，它们将有0或1行与请求关联。我想显示一个过去赞助商的列表，用户可能在他/她以前的任何请求中定义了这些赞助商

第一：我可以找到用户以前输入的所有请求（Request.UserId==1111）

第二：表由RequestId关联（request.RequestId==赞助商.RequestId）

第三：我想限制根据不同的赞助商.Email返回的行（根据不同的赞助商.Email返回最大赞助商.RequestId）

第四：我希望他们按使用的最新赞助商排序（按降序赞助商.RequestId排序）

最后一个警告，我只想返回赞助商记录。LastNm不为null（以前的升级问题）

所以我很接近，但我不会根据相同的电子邮件进行过滤：

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);

至少我需要Request.DateRequested并返回整个赞助商行

请求表（仅某些列）

赞助商表（仅特定列）

因此，我希望返回以下行

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

---

我发现用查询语法样式编写LINQ查询更容易。它确实提高了我的可读性

        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();

按照函数表示法，它将是：

        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());

这就产生了我认为你想要的结果。在两个单独的阵列中使用数据的本地副本，并使用以下循环：

        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);

我得到：

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

此外，如果数据库中具有引用完整性，并且正在使用EntityFramework（或OpenAccess），则可以使用两个From替换连接

from r in requests
from s in r.sponsors

---

我发现用查询语法样式编写LINQ查询更容易。它确实提高了我的可读性

        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();

按照函数表示法，它将是：

        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());

这就产生了我认为你想要的结果。在两个单独的阵列中使用数据的本地副本，并使用以下循环：

        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);

我得到：

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

此外，如果数据库中具有引用完整性，并且正在使用EntityFramework（或OpenAccess），则可以使用两个From替换连接

from r in requests
from s in r.sponsors

---

我发现用查询语法样式编写LINQ查询更容易。它确实提高了我的可读性

        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();

按照函数表示法，它将是：

        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());

这就产生了我认为你想要的结果。在两个单独的阵列中使用数据的本地副本，并使用以下循环：

        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);

我得到：

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

此外，如果数据库中具有引用完整性，并且正在使用EntityFramework（或OpenAccess），则可以使用两个From替换连接

from r in requests
from s in r.sponsors

---

我发现用查询语法样式编写LINQ查询更容易。它确实提高了我的可读性

        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();

按照函数表示法，它将是：

        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());

这就产生了我认为你想要的结果。在两个单独的阵列中使用数据的本地副本，并使用以下循环：

        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);

我得到：

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

此外，如果数据库中具有引用完整性，并且正在使用EntityFramework（或OpenAccess），则可以使用两个From替换连接

from r in requests
from s in r.sponsors

---

基于您完成的函数表示法和关于RI的最后注释，我重新编写了代码：

var qry=db.requests.Where（req=>req.UserID==111&&req.shandor！=null&&req.shandor.Lastnm！=null）。OrderByDescending（req=>req.RequestID）。GroupBy（req=>req.shandor.EMail）。选择（group=>group.First（））根据您完成的函数表示法和关于RI的最终注释，我重新编写了代码：
var qry=db.requests.Where（req=>req.UserID==111&&req.shandor！=null&&req.shandor.Lastnm！=null）。OrderByDescending（req=>req.RequestID）。GroupBy（req=>req.shandor.EMail）。选择（group=>group.First（））;根据您完成的函数表示法和关于RI的最终注释，我重新编写了代码：
var qry=db.requests.Where（req=>req.UserID==111&&req.shandor！=null&&req.shandor.Lastnm！=null）。OrderByDescending（req=>req.RequestID）。GroupBy（req=>req.shandor.EMail）。选择（group=>group.First（））;根据您完成的函数表示法和关于RI的最终注释，我重新编写了代码：
var qry=db.requests.Where（req=>req.UserID==111&&req.shandor！=null&&req.shandor.Lastnm！=null）。OrderByDescending（req=>req.RequestID）。GroupBy（req=>req.shandor.EMail）。选择（group=>group.First（））;