相关疑难解决方法(0)

我会假设有一个简单的LINQ查询来执行此操作,我只是不确定如何.请参阅下面的代码段.

class Program
{
    static void Main(string[] args)
    {
        List<Person> peopleList1 = new List<Person>();
        peopleList1.Add(new Person() { ID = 1 });
        peopleList1.Add(new Person() { ID = 2 });
        peopleList1.Add(new Person() { ID = 3 });

        List<Person> peopleList2 = new List<Person>();
        peopleList2.Add(new Person() { ID = 1 });
        peopleList2.Add(new Person() { ID = 2 });
        peopleList2.Add(new Person() { ID = 3 });
        peopleList2.Add(new Person() { ID = 4 });
        peopleList2.Add(new Person() { ID = 5 });
    }
}

class Person
{ …

假设我有一个左外连接:

from f in Foo
join b in Bar on f.Foo_Id equals b.Foo_Id into g
from result in g.DefaultIfEmpty()
select new { Foo = f, Bar = result }

如何使用扩展方法表达相同的任务？例如

Foo.GroupJoin(Bar, f => f.Foo_Id, b => b.Foo_Id, (f,b) => ???)
    .Select(???)

我有网络搜索但我仍然无法找到一个简单的答案.有人可以解释(用简单的英文)是什么GroupJoin？它与普通的内心有什么不同Join？它常用吗？它只适用于方法语法吗？查询语法怎么样？一个c#代码示例会很好.

我最近升级到了VS 2010,正在玩LINQ to Dataset.我有一个强大的类型化的Authorization数据集,它位于ASP.NET WebApplication的HttpCache中.

所以我想知道实际上检查用户是否有权做某事的最快方法.如果有人感兴趣的话,这是我的数据模型和其他一些信息.

我检查了3种方法:

1. 直接数据库
2. LINQ查询的Where条件为"Join" - 语法
3. 带有Join的 LINQ查询- 语法

这些是每个函数1000次调用的结果:

1.Iteration:

1. 4,2841519秒
2. 115,7796925秒
3. 2,024749秒

2.Iteration:

1. 3,1954857秒
2. 84,97047秒
3. 1,5783397秒

3.Iteration:

1. 2,7922143秒
2. 97,8713267秒
3. 1,8432163秒

平均:

1. 数据库:3,4239506333秒.
2. 其中:99,5404964秒.
3. 加入:1,815435秒.

为什么Join-version比where-syntax快得多,这使得它无用尽管作为LINQ新手它似乎是最清晰的.或者我在查询中遗漏了什么？

这是LINQ查询,我跳过数据库:

地点:

Public Function hasAccessDS_Where(ByVal accessRule As String) As Boolean
    Dim userID As Guid = DirectCast(Membership.GetUser.ProviderUserKey, Guid)
    Dim query = From accRule In Authorization.dsAuth.aspnet_AccessRule, _
                roleAccRule In Authorization.dsAuth.aspnet_RoleAccessRule, _
                role In Authorization.dsAuth.aspnet_Roles, _
                userRole In Authorization.dsAuth.aspnet_UsersInRoles _
                Where accRule.idAccessRule = roleAccRule.fiAccessRule …

我正在尝试LINQ实体.

我有以下问题:我希望它这样做:

SELECT 
     T_Benutzer.BE_User
    ,T_Benutzer_Benutzergruppen.BEBG_BE
FROM T_Benutzer

LEFT JOIN T_Benutzer_Benutzergruppen
    ON T_Benutzer_Benutzergruppen.BEBG_BE = T_Benutzer.BE_ID 

我最接近的是这个:

        var lol = (
            from u in Repo.T_Benutzer

            //where u.BE_ID == 1
            from o in Repo.T_Benutzer_Benutzergruppen.DefaultIfEmpty()
                // on u.BE_ID equals o.BEBG_BE

            where (u.BE_ID == o.BEBG_BE || o.BEBG_BE == null)

            //join bg in Repo.T_Benutzergruppen.DefaultIfEmpty()
            //    on o.BEBG_BG equals bg.ID

            //where bg.ID == 899 

            orderby
                u.BE_Name ascending
                //, bg.Name descending

            //select u 
            select new
            {
                 u.BE_User
                ,o.BEBG_BG
                //, bg.Name 
            }
         ).ToList();

但是这会产生与内部联接相同的结果,而不是左联接.
而且,它创建了这个完全疯狂的SQL:

SELECT 
     [Extent1].[BE_ID] AS [BE_ID] …

我在SQL中有这个查询,我希望它使用Entity Framework在LINQ中实现它,但是如何应用多个表左外连接？

SELECT d.bookingid,
       d.labid,
       d.processid,
       p.prid,
       p.prno,
       d.DestinationBranchID,
       d.SendStatus
FROM   dc_tpatient_bookingd d
       LEFT OUTER JOIN dc_tpatient_bookingm m ON d.bookingid = m.bookingid
       LEFT OUTER JOIN dc_tpatient p ON p.prid = m.prid
       LEFT OUTER JOIN dc_tp_test t ON d.testid = t.testid
       LEFT OUTER JOIN dc_tp_groupm gm ON t.groupid = gm.groupid
       LEFT OUTER JOIN dc_tpanel pn ON m.panelid = pn.panelid
       LEFT OUTER JOIN dc_tp_organization og ON og.orgid = m.clientid
       LEFT OUTER JOIN dc_tp_ward w ON w.wardid = m.wardid
       LEFT OUTER …

我有一个linq连接查询wriiten,我想取值,如果其中一个是空的...

码:

var Details = 

UnitOfWork.FlightDetails
          .Query()
          .Join
          (
              PassengersDetails,
              x => x.Flightno,
              y => y.FlightNo,
              (x, y) => new
              {
                  y.PassengerId,
                  y.classType,
                  x.Flightno,
                  x.FlightName,
              }
          );

我想用...

"Above query".DefaultIfEmpty
(
    new 
    {
        y.PassengerId,
        y.classType,
        string.Empty,
        string.Empty
    }
);

"FlightDetails"是类上的Idatarepository类型,"PassengerDetails"是可查询的局部变量结果.如何获得乘客ID和Classtype的结果,并且整体结果中不包含flightno和flightname.

我正在尝试使用linq的查询语法将此查询转换为基于方法的语法.

这是查询:

  var products = from p in context.Products
                 join t in context.TopSellings
                 on p.Id equals t.Id into g
                 from tps in g.DefaultIfEmpty()
                 orderby tps.Rating descending
                 select new
                 {
                     Name = p.Name,
                     Rating = tps.Rating == null ? 0 : tps.Rating
                 };

上面的查询产生这个SQL查询:

{SELECT 
    [Project1].[Id] AS [Id], 
    [Project1].[Name] AS [Name], 
    [Project1].[C1] AS [C1]
    FROM ( SELECT 
        [Extent1].[Id] AS [Id], 
        [Extent1].[Name] AS [Name], 
        CASE WHEN ([Extent2].[Rating] IS NULL) THEN 0 ELSE [Extent2].[Rating] END AS [C1], 
        [Extent2].[Rating] AS [Rating]
        FROM  [dbo].[Products] AS …

我有以下用数据填充的类

public class cntrydata
{
    public string countryid { get; set; }
    public string countryname { get; set; }

    public IEnumerable<Data> data { get; set; }

}
public class Data
{
        public int year { get; set; }
        public float value { get; set; }
}

我有一个IEnumerable结果,其中包含如下数据:

IEnumerable<cntryData> result

USA
United States
   2000 12
   2001 22
   2004 32

CAN
Canada
   2001 29
   2003 22
   2004 24

我想使用LINQ评估"result"对象以获得以下结果:

2000 USA 12   CAN null
2001 USA 22   CAN 29
2003 USA null …

我目前正在使用EF而且我有两张桌子,Employees并且Orders鉴于它Employee有多个Orders.

我需要在EF中执行一个查询,它会为我提供所有Employees相关的列表Orders,但只包含两个日期之间的查询.如果在给定时间内Employee没有执行任何操作Order,他的Orders列表将为空.

我想我需要从EmployeesDbSet 开始我的查询,但是如何为Orders属性分配条件？

我试图这样做,但显然它没有用.

public List<Employee> GetAllByIdListAndDateRange(int[] ids, DateTime fromDate, DateTime toDate)
    {
        var query = _context.Set<Employee>().Where(a => ids.Contains(a.EmployeeID)).Include(a => a.Orders.Where(o.OrderDate <= toDate && o.OrderDate >= fromDate));

        return query.ToList();
    }

有帮助吗？我想我可能会错过这里非常简单的事情.