zoukankan      html  css  js  c++  java
  • 转载: C#: Left outer joins with LINQ

    I always considered Left Outer Join in LINQ to be complex until today when I had to use it in my application. I googled and the firstresult gave a very nice explanation. The only difference between ordinary joins (inner joins) and left joins in LINQ is the use of “join into” and “DefaultIfEmpty()” expressions.

    Consider this very simple query (Assuming a scenario that not all the TimesheetLines are associated with a Job)

    1
    2
    3
    Select TL.EntryDate, TL.Hours, J.JobName
    From TimeSheetLines TL
    Left Join Jobs J on TL.JobNo=J.JobNo

    A LINQ query using inner join is

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    var lines =
        from tl in db.TimeSheetLines
        join in db.Jobs on tl.JobNo equals j.JobNo
        where tl.ResourceNo == resourceNo
     
        select new
        {
            EntryDate = tl.EntryDate,
            Hours = tl.Hours,
            Job = j.JobName
        };

    And a LINQ query performing left join is

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    var lines =
        from tl in db.TimeSheetLines
        join in db.Jobs on tl.JobNo equals j.JobNo into tl_j
        where tl.ResourceNo == resourceNo
     
        from j in tl_j.DefaultIfEmpty()
        select new
        {
            EntryDate = tl.EntryDate,
            Hours = tl.Hours,
            Job = j.JobName
        };

    Notice that the only difference is the use of “into” with the join statement followed by reselecting the result using “DefaultIfEmpty()” expression. And here’s the generated SQL for the above LINQ expression.

    1
    2
    3
    4
    SELECT [t0].[EntryDate] as [EntryDate], [t0].[Hours] as [Hours], [t1].[JobName] AS [Job]
    FROM [dbo].[TimeSheetLine] AS [t0]
    LEFT OUTER JOIN [dbo].[Jobs] AS [t1] ON [t0].[JobNo] = [t1].[JobNo]
    WHERE [t0].[ResourceNo] = @p0

    Another LINQ version which is more compact is:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    var lines =
        from tl in db.TimeSheetLines
        from j in db.Jobs.Where(j=>j.JobNo == tl.JobNo).DefaultIfEmpty()
        select new
        {
            EntryDate = tl.EntryDate,
            Hours = tl.Hours,
            Job = j.JobName
        };

    Similarly, this concept can be expanded for multiple left joins. Assuming that a TimeSheetLine will either have a JobNo or an IndirectCode, consider this SQL query:

    1
    2
    3
    4
    Select TL.EntryDate, TL.Hours, J.JobName, I.IndirectName
    From TimeSheetLines TL
    Left Join Jobs J on TL.JobNo=J.JobNo
    Left Join Indirects I on TL.IndirectCode=I.IndirectCode

    The equivalent LINQ query is:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    var lines =
        from tl in db.TimeSheetLines
        join j in db.Jobs      on tl.JobNo        equals j.JobNo         into tl_j
        join i in db.Indirects on tl.IndirectCode equals i.IndirectCode  into tl_i
        where tl.ResourceNo == resourceNo
     
        from j in tl_j.DefaultIfEmpty()
        from i in tl_i.DefaultIfEmpty()
        select new
        {
            EntryDate = tl.EntryDate,
            Hours = tl.Hours,
            Job = j.JobName,
            Indirect = i.IndirectName,
        };

    And the generated SQL is:

    1
    2
    3
    4
    SELECT [t0].[EntryDate] as [EntryDate], [t0].[Hours] as [Hours], [t1].[JobName] AS [Job], [t2].[IndirectName] As [Indirect]
    LEFT OUTER JOIN [dbo].[Jobs] AS [t1] ON [t0].[JobNo] = [t1].[JobNo]
    LEFT OUTER JOIN [dbo].[Indirects] AS [t2] ON [t0].[IndirectCode] = [t2].[IndirectCode]
    WHERE [t0].[ResourceNo] = @p0

    That’s all, left outer joins in LINQ are as easy as in T-SQL. Happy joining.

    Update:
    Notice that this post describes the approach to perform a Left Outer Join in LINQ To SQL as well as Entity Framework (version 4). The same is not true for Entity Framework version 3.5 since it does not support the DefaultIfEmpty keyword. To perform Left Outer Joins with Entity Framework 3.5, we need to create appropriate relationships (e.g 0..1 to 0..Many) in our Entity Model and they will be automatically translated into TSQL’s Left Join clause.

    come form: https://smehrozalam.wordpress.com/2009/06/10/c-left-outer-joins-with-linq/

  • 相关阅读:
    另类多线程生产者与消费者模式
    redis.conf配置详细翻译解析
    数据库优化之索引使用简介
    Comparable和Comparator的区别
    spring中用到哪些设计模式
    JVM之几种垃圾收集器简单介绍
    angular.extend()和 angular.copy()的区别
    ThreadLocal是什么?保证线程安全
    excel文件怎么使用php进行处理
    ubuntu 安装ssh 服务
  • 原文地址:https://www.cnblogs.com/facial/p/4381038.html
Copyright © 2011-2022 走看看