关于C#：在linq中左外部联接

LEFT OUTER JOIN in LINQ

如何在不使用join-on-equals-into子句的情况下执行c linq to objects中的左外部联接？有没有办法用where条款做到这一点？纠正问题：因为内部连接很容易，我有这样的解决方案

1 2	List<JoinPair> innerFinal = (from l in lefts from r in rights where l.Key == r.Key select new JoinPair { LeftId = l.Id, RightId = r.Id})

但是对于左外部连接，我需要一个解决方案。我的有点像这样，但不起作用

1
2
3
4
5

List< JoinPair> leftFinal = (from l in lefts from r in rights
select new JoinPair {
LeftId = l.Id,
RightId = ((l.Key==r.Key) ? r.Id : 0
})

如果joinPair是类：

1	public class JoinPair { long leftId; long rightId; }

相关讨论

如：

101个Linq示例-左外部联接

1
2
3
4
5

var q =
from c in categories
join p in products on c.Category equals p.Category into ps
from p in ps.DefaultIfEmpty()
select new { Category = c, ProductName = p == null ?"(No products)" : p.ProductName };

相关讨论

如果使用数据库驱动的LINQ提供程序，则可以编写一个可读性更高的左外部联接，如下所示：

1 2	from maintable in Repo.T_Whatever from xxx in Repo.T_ANY_TABLE.Where(join condition).DefaultIfEmpty()

如果省略DefaultIfEmpty()，则会有一个内部连接。

接受接受的答案：

1
2
3

from c in categories
join p in products on c equals p.Category into ps
from p in ps.DefaultIfEmpty()

这个语法非常混乱，当您想离开join多个表时，它是如何工作的还不清楚。< BR>

注
应该注意的是，from alias in Repo.whatever.Where(condition).DefaultIfEmpty()与外部应用程序/左侧联接侧边相同，只要不引入每行值(即实际的外部应用程序)，任何(合适的)数据库优化器都完全能够将其转换为左侧联接。在LINQ-2对象中不要这样做(因为使用LINQ-to对象时没有DB优化器)。

详细示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

var query2 = (
from users in Repo.T_User
from mappings in Repo.T_User_Group
.Where(mapping => mapping.USRGRP_USR == users.USR_ID)
.DefaultIfEmpty() // <== makes join left join
from groups in Repo.T_Group
.Where(gruppe => gruppe.GRP_ID == mappings.USRGRP_GRP)
.DefaultIfEmpty() // <== makes join left join

// where users.USR_Name.Contains(keyword)
// || mappings.USRGRP_USR.Equals(666)
// || mappings.USRGRP_USR == 666
// || groups.Name.Contains(keyword)

select new
{
UserId = users.USR_ID
,UserName = users.USR_User
,UserGroupId = groups.ID
,GroupName = groups.Name
}

);

var xy = (query2).ToList();

当与Linq2 SQL一起使用时，它将很好地转换为以下非常清晰的SQL查询：

1
2
3
4
5
6
7
8
9
10
11
12

SELECT
users.USR_ID AS UserId
,users.USR_User AS UserName
,groups.ID AS UserGroupId
,groups.Name AS GroupName
FROM T_User AS users

LEFT JOIN T_User_Group AS mappings
ON mappings.USRGRP_USR = users.USR_ID

LEFT JOIN T_Group AS groups
ON groups.GRP_ID == mappings.USRGRP_GRP

编辑：

也见"将SQL Server查询转换为LINQ查询"更复杂的例子。

另外，如果您是在linq-2-objects(而不是linq-2-sql)中执行此操作，则应该使用老式的方法(因为linq-to-sql会正确地将其转换为join操作，但是对于对象，此方法强制进行完全扫描，并且不利用索引搜索，为什么…)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

var query2 = (
from users in Repo.T_Benutzer
join mappings in Repo.T_Benutzer_Benutzergruppen on mappings.BEBG_BE equals users.BE_ID into tmpMapp
join groups in Repo.T_Benutzergruppen on groups.ID equals mappings.BEBG_BG into tmpGroups
from mappings in tmpMapp.DefaultIfEmpty()
from groups in tmpGroups.DefaultIfEmpty()
select new
{
UserId = users.BE_ID
,UserName = users.BE_User
,UserGroupId = mappings.BEBG_BG
,GroupName = groups.Name
}

);

相关讨论

这个答案实际上是有帮助的。感谢您提供可以理解的语法。
这么多年来左撇子加入了另一条路！谢谢！
wtb a nhibernate兼容的linq查询…：)
linq to sql将其正确转换为join操作。然而，对于对象，这种方法强制进行完全扫描，这就是为什么官方文档提供了可以利用哈希进行索引搜索的组连接解决方案。
@Stefan Steiger，你能帮我查一下stackoverflow.com/questions/31938784/&hellip；
@用户：完成，然后回答。
我认为显式join的语法要比where后接DefaultIfEmpty的语法更易读、更清晰。
@用户3441905：只要您只需要将表A和表B连接起来，就可以了。但一旦你拥有了更多，就不会了。但即使只有两张桌子，我也觉得太冗长了。流行的观点似乎也反对你，因为这个答案从0开始，而最高的答案已经有90多个赞成票。
非常有帮助，更容易理解，谢谢！
注意，我在与后面的Where语句结合使用时遇到了这个问题，后者过滤了左联接表中的一列。添加Where语句(例如Where(mappings.SomeField = Parameter语句)将在SQL转换中将映射联接转换为内部联接。我认为这是因为ef希望能够一直读取这个属性，并且不希望处理mappings的空对象，尽管存在上面的DefaultIfEmpty。
@伪编码：如果在SQL中，对左联接表中的字段执行WHERE，则结果与内部联接中的结果相同。您需要在SQL WHERE子句中特别允许NULL…例如，其中(map_dateto>now()或map_dateto为空)。
@Stefansteiger谢谢，我考虑了一会儿才意识到这一点。(哈哈，明白了吗？)你提出了一个有趣的观点，所以我做了一些进一步的测试。我在linq中表达field is null时遇到了问题，因为我测试的字段不是可以为空的类型，并且得到了一个运行时错误。然后，我尝试检查实体是否为空，并且对SQL没有影响；仍然列出了一个内部联接。所以，不确定如何处理这个问题，但是在这个特殊的情况下，我不想在空值的情况下允许行，所以内部联接工作得很好。
@伪编码：如果字段不为空(在实体中)，那么我假设它在数据库中不为空。但是，当您离开连接一个尚不存在的对象(例如，尚未输入楼层但已连接楼层的建筑)时，仍然可以获取空值。另一种可能是，您没有设置外键，并且此字段中存在一些垃圾数据(例如，不再存在的引用，或者一开始根本不存在的引用，但因为您缺少一个外键，或者将其设置为不检查…)。
@Stefansteiger，在你的select new块上，mappings和groups可能是空的，会抛出一个异常，不是吗？
@Heyjude；不可能。一些映射和组的单个值可能为空，但这不会引发异常。但是，值得注意的是，"从XXX开始，其中"与实际的外部应用/左侧连接横向相同，但这意味着它仍然是发动机罩下的左侧连接。
为什么这个答案不坏，反正这不是一个好的建议。这个问题甚至没有提到使用了数据库驱动的LINQ提供程序，即使这样，也不建议在数据库优化器上中继来修复SQL查询。因为这个原因，我投了反对票。在LinqToObjects中，这种方法会破坏您的性能，因此最好熟悉不是"老式"而是正确的方法。
@蒂姆·施梅勒：你说得对。修正了。"熟悉"语法的问题在于，它们没有提供多个表上的左联接如何工作的示例。这就是我之前添加该示例的原因。如果他们愿意的话，我一开始就不必想出来。如果您不熟悉LINQ，那么所谓的"熟悉"语法就不是非常有意义。
我知道你的意思，如果你用方法语法而不是查询语法，情况会更糟。顺便说一句，即使在SQL中，使用旧样式的连接也是一个不好的习惯。
@Tim Schmelter：的确如此，但这是一个有趣的特性——可能能够在Linq中以这种方式进行左连接；)
@Heyjude如果像在空引用上访问属性那样对对象执行Linq，他们会抛出一个异常。但是，如果在数据库上运行，该值将变为空。
from xxx in Repo.T_ANY_TABLE.Where(join condition).DefaultIfEmpty()语法在实体框架核心中不能正常工作。它变成了一个相当讨厌的CROSS APPLY，最终以An exception occurred in the database while iterating the results of a query. Nullable object must have a value.失败而告终。太糟糕了，我真的更喜欢那个语法…
@克里斯托弗·霍斯：那么我建议你打开一个关于实体框架核心的问题。因为首先它应该是一个外部应用，而不是交叉应用，第二个交叉应用也应该有效。我建议你暂时避免实体框架核心，因为它实际上是在进行中的，从上到下…不仅仅是因为左连接/外部应用。不管怎样，衣冠楚楚要好得多。实际上，我必须编写自己的代码来从数据库生成实体模式…这就是Fubar的情况。
@Stefansteiger Dapper没有依赖关系图，这是EF提供给您的开箱即用的。我在更简单的解决方案中使用dapper，在这种解决方案中，我不需要图的强大功能或轻松地对类进行单元测试的能力。
克里斯托弗·霍斯：是的，但达珀不需要依赖关系图。
哎哟！再见，Linq你好，dapper.net。不必重新学习您在SQL中已经可以做的事情

使用lambda表达式

1
2
3
4
5
6
7
8
9
10
11
12
13
14

db.Categories
.GroupJoin(
db.Products,
Category => Category.CategoryId,
Product => Product.CategoryId,
(x, y) => new { Category = x, Products = y })
.SelectMany(
xy => xy.Products.DefaultIfEmpty(),
(x, y) => new { Category = x.Category, Product = y })
.Select(s => new
{
CategoryName = s.Category.Name,
ProductName = s.Product.Name
})

相关讨论

看看这个例子。此查询应该有效：

1
2
3
4

var leftFinal = from left in lefts
join right in rights on left equals right.Left into leftRights
from leftRight in leftRights.DefaultIfEmpty()
select new { LeftId = left.Id, RightId = left.Key==leftRight.Key ? leftRight.Id : 0 };

相关讨论

Now as an extension method:

1
2
3
4
5
6
7
8
9
10
11
12

public static class LinqExt
{
public static IEnumerable<TResult> LeftOuterJoin<TLeft, TRight, TKey, TResult>(this IEnumerable<TLeft> left, IEnumerable<TRight> right, Func<TLeft, TKey> leftKey, Func<TRight, TKey> rightKey,
Func<TLeft, TRight, TResult> result)
{
return left.GroupJoin(right, leftKey, rightKey, (l, r) => new { l, r })
.SelectMany(
o => o.r.DefaultIfEmpty(),
(l, r) => new { lft= l.l, rght = r })
.Select(o => result.Invoke(o.lft, o.rght));
}
}

像通常使用join一样使用：

1
2
3
4

var contents = list.LeftOuterJoin(list2,
l => l.country,
r => r.name,
(l, r) => new { count = l.Count(), l.country, l.reason, r.people })

希望这能节省你一些时间。

通过扩展方法实现左外部联接可能看起来像

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

public static IEnumerable<Result> LeftJoin<TOuter, TInner, TKey, Result>(
this IEnumerable<TOuter> outer, IEnumerable<TInner> inner
, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector
, Func<TOuter, TInner, Result> resultSelector, IEqualityComparer<TKey> comparer)
{
if (outer == null)
throw new ArgumentException("outer");

if (inner == null)
throw new ArgumentException("inner");

if (outerKeySelector == null)
throw new ArgumentException("outerKeySelector");

if (innerKeySelector == null)
throw new ArgumentException("innerKeySelector");

if (resultSelector == null)
throw new ArgumentException("resultSelector");

return LeftJoinImpl(outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer ?? EqualityComparer<TKey>.Default);
}

static IEnumerable<Result> LeftJoinImpl<TOuter, TInner, TKey, Result>(
IEnumerable<TOuter> outer, IEnumerable<TInner> inner
, Func<TOuter, TKey> outerKeySelector, Func<TInner, TKey> innerKeySelector
, Func<TOuter, TInner, Result> resultSelector, IEqualityComparer<TKey> comparer)
{
var innerLookup = inner.ToLookup(innerKeySelector, comparer);

foreach (var outerElment in outer)
{
var outerKey = outerKeySelector(outerElment);
var innerElements = innerLookup[outerKey];

if (innerElements.Any())
foreach (var innerElement in innerElements)
yield return resultSelector(outerElment, innerElement);
else
yield return resultSelector(outerElment, default(TInner));
}
}

结果选择器必须处理空元素。外汇。

1
2
3
4
5
6
7
8
9
10
11

static void Main(string[] args)
{
var inner = new[] { Tuple.Create(1,"1"), Tuple.Create(2,"2"), Tuple.Create(3,"3") };
var outer = new[] { Tuple.Create(1,"11"), Tuple.Create(2,"22") };

var res = outer.LeftJoin(inner, item => item.Item1, item => item.Item1, (it1, it2) =>
new { Key = it1.Item1, V1 = it1.Item2, V2 = it2 != null ? it2.Item2 : default(string) });

foreach (var item in res)
Console.WriteLine(string.Format("{0}, {1}, {2}", item.Key, item.V1, item.V2));
}

相关讨论

看看这个例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

class Person
{
public int ID { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public string Phone { get; set; }
}

class Pet
{
public string Name { get; set; }
public Person Owner { get; set; }
}

public static void LeftOuterJoinExample()
{
Person magnus = new Person {ID = 1, FirstName ="Magnus", LastName ="Hedlund"};
Person terry = new Person {ID = 2, FirstName ="Terry", LastName ="Adams"};
Person charlotte = new Person {ID = 3, FirstName ="Charlotte", LastName ="Weiss"};
Person arlene = new Person {ID = 4, FirstName ="Arlene", LastName ="Huff"};

Pet barley = new Pet {Name ="Barley", Owner = terry};
Pet boots = new Pet {Name ="Boots", Owner = terry};
Pet whiskers = new Pet {Name ="Whiskers", Owner = charlotte};
Pet bluemoon = new Pet {Name ="Blue Moon", Owner = terry};
Pet daisy = new Pet {Name ="Daisy", Owner = magnus};

// Create two lists.
List<Person> people = new List<Person> {magnus, terry, charlotte, arlene};
List<Pet> pets = new List<Pet> {barley, boots, whiskers, bluemoon, daisy};

var query = from person in people
where person.ID == 4
join pet in pets on person equals pet.Owner into personpets
from petOrNull in personpets.DefaultIfEmpty()
select new { Person=person, Pet = petOrNull};

foreach (var v in query )
{
Console.WriteLine("{0,-15}{1}", v.Person.FirstName +":", (v.Pet == null ?"Does not Exist" : v.Pet.Name));
}
}

// This code produces the following output:
//
// Magnus: Daisy
// Terry: Barley
// Terry: Boots
// Terry: Blue Moon
// Charlotte: Whiskers
// Arlene:

现在，即使那个元素has no matches in the right，你也可以使用include elements from the left，在我们的例子中，我们重新使用Arlene，即使他在右边没有匹配项。

这是参考资料

如何：执行左侧外部连接(C编程指南)

相关讨论

这是一般形式(如其他答案中所述)

1
2
3
4
5

var c =
from a in alpha
join b in beta on b.field1 equals a.field1 into b_temp
from b_value in b_temp.DefaultIfEmpty()
select new { Alpha = a, Beta = b_value };

不过，这里有一个解释，我希望能澄清这到底意味着什么！

1	join b in beta on b.field1 equals a.field1 into b_temp

基本上创建一个单独的结果集b_temp，它有效地为右侧的条目(b'中的条目)包含空的"行"。

然后下一行：

1	from b_value in b_temp.DefaultIfEmpty()

..迭代该结果集，为右侧的"row"设置默认的空值，并将右侧行join的结果设置为"b_value"的值(即，如果有匹配的记录，则为右侧的值，否则为"null")。

现在，如果右侧是单独的LINQ查询的结果，它将由匿名类型组成，匿名类型只能是"something"或"null"。但是，如果它是一个可枚举的(例如，一个列表-其中myObjectB是一个具有2个字段的类)，那么可以具体说明其属性使用的默认"空"值是什么：

1
2
3
4
5

var c =
from a in alpha
join b in beta on b.field1 equals a.field1 into b_temp
from b_value in b_temp.DefaultIfEmpty( new MyObjectB { Field1 = String.Empty, Field2 = (DateTime?) null })
select new { Alpha = a, Beta_field1 = b_value.Field1, Beta_field2 = b_value.Field2 };

这样可以确保"b"本身不为空(但它的属性可以为空，使用您指定的默认空值)，这允许您检查b_值的属性，而不必为b_值获取空引用异常。请注意，对于可为空的日期时间，类型为(日期时间？)例如，"nullable datetime"必须在"defaultifempty"的规范中指定为空的"type"(这也适用于不可"native"为空的类型，例如double、float)。

您可以通过简单地链接上述语法来执行多个左外部联接。

相关讨论

下面是一个例子，如果您需要连接两个以上的表：

1
2
3
4
5
6
7

from d in context.dc_tpatient_bookingd
join bookingm in context.dc_tpatient_bookingm
on d.bookingid equals bookingm.bookingid into bookingmGroup
from m in bookingmGroup.DefaultIfEmpty()
join patient in dc_tpatient
on m.prid equals patient.prid into patientGroup
from p in patientGroup.DefaultIfEmpty()

参考：https://stackoverflow.com/a/17142392/2343

有三张表：人、学校和人-学校，将人与他们学习的学校联系起来。表中没有对ID=6的人的引用。但是，id=6的人出现在结果lef-joined网格中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

List<Person> persons = new List<Person>
{
new Person { id = 1, name ="Alex", phone ="4235234" },
new Person { id = 2, name ="Bob", phone ="0014352" },
new Person { id = 3, name ="Sam", phone ="1345" },
new Person { id = 4, name ="Den", phone ="3453452" },
new Person { id = 5, name ="Alen", phone ="0353012" },
new Person { id = 6, name ="Simon", phone ="0353012" }
};

List<School> schools = new List<School>
{
new School { id = 1, name ="Saint. John's school
<div class="suo-content">[collapse title=""]<ul><li>虽然这可能是问题的答案，但请对您的答案提供一些解释：)</li></ul>[/collapse]</div><hr><P>扩展方法的工作方式与使用联接语法的左联接类似</P>[cc lang="csharp"]public static class LinQExtensions
{
public static IEnumerable<TResult> LeftJoin<TOuter, TInner, TKey, TResult>(
this IEnumerable<TOuter> outer, IEnumerable<TInner> inner,
Func<TOuter, TKey> outerKeySelector,
Func<TInner, TKey> innerKeySelector,
Func<TOuter, TInner, TResult> resultSelector)
{
return outer.GroupJoin(
inner,
outerKeySelector,
innerKeySelector,
(outerElement, innerElements) => resultSelector(outerElement, innerElements.FirstOrDefault()));
}
}

刚刚在.NET核心中编写了它，它似乎按预期工作。

小测验：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

var Ids = new List<int> { 1, 2, 3, 4};
var items = new List<Tuple<int, string>>
{
new Tuple<int, string>(1,"a"),
new Tuple<int, string>(2,"b"),
new Tuple<int, string>(4,"d"),
new Tuple<int, string>(5,"e"),
};

var result = Ids.LeftJoin(
items,
id => id,
item => item.Item1,
(id, item) => item ?? new Tuple<int, string>(id,"not found"));

result.ToList()
Count = 4
[0]: {(1, a)}
[1]: {(2, b)}
[2]: {(3, not found)}
[3]: {(4, d)}

这是一个与内部和左侧外部联接的LINQ语法比较的SQL语法。左外部联接：

http://www.ozkary.com/2011/07/linq-to-entity-inner-and-left-joins.html

"下面的示例是在产品和类别之间进行组联接。这基本上是左连接。即使类别表为空，into表达式也返回数据。要访问类别表的属性，现在必须通过在catlist.defaultifempty()语句中添加fromcl从可枚举结果中进行选择。

在LINQ C中执行左外部联接#//执行左外部联接

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

class Person
{
public string FirstName { get; set; }
public string LastName { get; set; }
}

class Child
{
public string Name { get; set; }
public Person Owner { get; set; }
}
public class JoinTest
{
public static void LeftOuterJoinExample()
{
Person magnus = new Person { FirstName ="Magnus", LastName ="Hedlund" };
Person terry = new Person { FirstName ="Terry", LastName ="Adams" };
Person charlotte = new Person { FirstName ="Charlotte", LastName ="Weiss" };
Person arlene = new Person { FirstName ="Arlene", LastName ="Huff" };

Child barley = new Child { Name ="Barley", Owner = terry };
Child boots = new Child { Name ="Boots", Owner = terry };
Child whiskers = new Child { Name ="Whiskers", Owner = charlotte };
Child bluemoon = new Child { Name ="Blue Moon", Owner = terry };
Child daisy = new Child { Name ="Daisy", Owner = magnus };

// Create two lists.
List<Person> people = new List<Person> { magnus, terry, charlotte, arlene };
List<Child> childs = new List<Child> { barley, boots, whiskers, bluemoon, daisy };

var query = from person in people
join child in childs
on person equals child.Owner into gj
from subpet in gj.DefaultIfEmpty()
select new
{
person.FirstName,
ChildName = subpet!=null? subpet.Name:"No Child"
};
// PetName = subpet?.Name ?? String.Empty };

foreach (var v in query)
{
Console.WriteLine($"{v.FirstName +":",-25}{v.ChildName}");
}
}

// This code produces the following output:
//
// Magnus: Daisy
// Terry: Barley
// Terry: Boots
// Terry: Blue Moon
// Charlotte: Whiskers
// Arlene: No Child

https://dotnetwithhamid.blogspot.in网站/

下面是使用方法语法相当容易理解的版本：

1
2
3
4
5

IEnumerable<JoinPair> outerLeft =
lefts.SelectMany(l =>
rights.Where(r => l.Key == r.Key)
.DefaultIfEmpty(new Item())
.Select(r => new JoinPair { LeftId = l.Id, RightId = r.Id }));

我想补充一点，如果您得到morelinq扩展，现在就可以同时支持同质和异构的左连接了

http://morelinq.github.io/2.8/ref/api/html/overload_morelinq_moreenumerable_leftjoin.htm(http://morelinq.github.io/2.8/ref/api/html/overload_morelinq_moreenumerable

例子：

1
2
3
4
5
6
7
8

//Pretend a ClientCompany object and an Employee object both have a ClientCompanyID key on them

return DataContext.ClientCompany
.LeftJoin(DataContext.Employees, //Table being joined
company => company.ClientCompanyID, //First key
employee => employee.ClientCompanyID, //Second Key
company => new {company, employee = (Employee)null}, //Result selector when there isn't a match
(company, employee) => new { company, employee }); //Result selector when there is a match

编辑：

回想起来，这可能是可行的，但它将IQueryable转换为IEnumerable，因为MoreLinq不将查询转换为SQL。

您可以使用groupjoin，如下所述：https://stackoverflow.com/a/24273804/4251433

这将确保它作为一个iQueryable保持，以防您以后需要对其进行进一步的逻辑操作。

如果需要联接和过滤某些内容，可以在联接之外进行。可以在创建集合后进行筛选。

在本例中，如果在联接条件中执行此操作，则会减少返回的行。

采用三元条件dOCx1〔0〕。

如果对象是null(因此不匹配)，则返回?之后的内容。在这种情况下，__。
否则，返回:和n.MonDayNote之后的内容。

感谢其他的贡献者，这是我开始自己的问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

var schedLocations = (from f in db.RAMS_REVENUE_LOCATIONS
join n in db.RAMS_LOCATION_PLANNED_MANNING on f.revenueCenterID equals

n.revenueCenterID into lm

from n in lm.DefaultIfEmpty()

join r in db.RAMS_LOCATION_SCHED_NOTE on f.revenueCenterID equals r.revenueCenterID
into locnotes

from r in locnotes.DefaultIfEmpty()
where f.LocID == nLocID && f.In_Use == true && f.revenueCenterID > 1000

orderby f.Areano ascending, f.Locname ascending
select new
{
Facname = f.Locname,
f.Areano,
f.revenueCenterID,
f.Locabbrev,

// MonNote = n == null ?"__" : n.MonDayNote,
MonNote = n == null ?"__" : n.MonDayNote,
TueNote = n == null ?"__" : n.TueDayNote,
WedNote = n == null ?"__" : n.WedDayNote,
ThuNote = n == null ?"__" : n.ThuDayNote,

FriNote = n == null ?"__" : n.FriDayNote,
SatNote = n == null ?"__" : n.SatDayNote,
SunNote = n == null ?"__" : n.SunDayNote,
MonEmpNbr = n == null ? 0 : n.MonEmpNbr,
TueEmpNbr = n == null ? 0 : n.TueEmpNbr,
WedEmpNbr = n == null ? 0 : n.WedEmpNbr,
ThuEmpNbr = n == null ? 0 : n.ThuEmpNbr,
FriEmpNbr = n == null ? 0 : n.FriEmpNbr,
SatEmpNbr = n == null ? 0 : n.SatEmpNbr,
SunEmpNbr = n == null ? 0 : n.SunEmpNbr,
SchedMondayDate = n == null ? dMon : n.MondaySchedDate,
LocNotes = r == null ?"Notes: N/A" : r.LocationNote

}).ToList();
Func<int, string> LambdaManning = (x) => { return x == 0 ?"" :"Manning:" + x.ToString(); };
DataTable dt_ScheduleMaster = PsuedoSchedule.Tables["ScheduleMasterWithNotes"];
var schedLocations2 = schedLocations.Where(x => x.SchedMondayDate == dMon);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

(from a in db.Assignments
join b in db.Deliveryboys on a.AssignTo equals b.EmployeeId

//from d in eGroup.DefaultIfEmpty()
join c in db.Deliveryboys on a.DeliverTo equals c.EmployeeId into eGroup2
from e in eGroup2.DefaultIfEmpty()
where (a.Collected == false)
select new
{
OrderId = a.OrderId,
DeliveryBoyID = a.AssignTo,
AssignedBoyName = b.Name,
Assigndate = a.Assigndate,
Collected = a.Collected,
CollectedDate = a.CollectedDate,
CollectionBagNo = a.CollectionBagNo,
DeliverTo = e == null ?"Null" : e.Name,
DeliverDate = a.DeliverDate,
DeliverBagNo = a.DeliverBagNo,
Delivered = a.Delivered

});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

class Program
{
List<Employee> listOfEmp = new List<Employee>();
List<Department> listOfDepart = new List<Department>();

public Program()
{
listOfDepart = new List<Department>(){
new Department { Id = 1, DeptName ="DEV" },
new Department { Id = 2, DeptName ="QA" },
new Department { Id = 3, DeptName ="BUILD" },
new Department { Id = 4, DeptName ="SIT" }
};

listOfEmp = new List<Employee>(){
new Employee { Empid = 1, Name ="Manikandan",DepartmentId=1 },
new Employee { Empid = 2, Name ="Manoj" ,DepartmentId=1},
new Employee { Empid = 3, Name ="Yokesh" ,DepartmentId=0},
new Employee { Empid = 3, Name ="Purusotham",DepartmentId=0}
};

}
static void Main(string[] args)
{
Program ob = new Program();
ob.LeftJoin();
Console.ReadLine();
}

private void LeftJoin()
{
listOfEmp.GroupJoin(listOfDepart.DefaultIfEmpty(), x => x.DepartmentId, y => y.Id, (x, y) => new { EmpId = x.Empid, EmpName = x.Name, Dpt = y.FirstOrDefault() != null ? y.FirstOrDefault().DeptName : null }).ToList().ForEach
(z =>
{
Console.WriteLine("Empid:{0} EmpName:{1} Dept:{2}", z.EmpId, z.EmpName, z.Dpt);
});
}
}

class Employee
{
public int Empid { get; set; }
public string Name { get; set; }
public int DepartmentId { get; set; }
}

class Department
{
public int Id { get; set; }
public string DeptName { get; set; }
}

产量

相关讨论

左外部联接的简单解决方案：

1
2
3

var setA = context.SetA;
var setB = context.SetB.Select(st=>st.Id).Distinct().ToList();
var leftOuter = setA.Where(stA=> !setB.Contains(stA.Id));

笔记：

为了提高性能，可以将setb转换为字典(如果这样做了，则必须更改此：！setb.contains(sta.id))或哈希集
当涉及多个字段时，可以使用set操作和实现以下内容的类来实现：ieQualityComparer