在lambda表達式鏈接語法中加入列表<Array>

Question

我是Joins的業餘愛好者，但我試圖使用表達式鏈接語法而不是LINQ語句。我發現的大多數例子都使用了數組或列表{Lists <class>};但沒有數組列表{名單<array>}

List<int[]> needHelp = new List<int[]>{ 
new int[3] { 10, 20, 50}, 
new int[3] { 10, 21, 53}, 
new int[3] { 10, 22, 55}, 
new int[3] { 11, 20, 60}, 
new int[3] { 11, 22, 51} }; 

List<int[]> ghosts = new List<int[]>{ 
new int[3] { 10, 45, 65}, 
new int[3] { 11, 34, 60} }; 

的LINQ「查詢」語法的工作原理是：

List<int[]> result = (from h in needHelp join g in ghosts on h[0] equals g[0] 
         where h[1] == 21 select g).ToList(); 

但這種「方法」表達鏈語法不是爲我工作：

List<int[]> result = needHelp.Join(ghosts, x=>x[0], y=>y[0], (x,y) => y).Where(x => x[1] == 21).ToList(); 

對於那些有興趣我已經發現，這lambda表達式鏈可以打印出陣列的列表，而無需使用兩個foreach循環。

result.ForEach(x => { Array.ForEach(x, e => Console.Write(e + " ")); Console.WriteLine();}); 

好吧，我想我找到了我自己的解決方案，它是通過改變where子句的位置。但是，在加入之前哪裏必須來到，而不是之後要去的原因是什麼？我在帖子上看到，如果這是一個數據庫調用where類在「.Join」之前，那麼它在服務器上而不是客戶端上處理。然後，我假設在連接之後嘗試使用它，這是剩餘數據的超出範圍，在這種情況下將是y（列表<int[]> ghosts）。

Answer 1

Join s和Where s通常是不可互換的。

如果你讀了你的表情鏈「出聲」，它會讀這樣的：首先讓我在ghosts與needHelp東西匹配的第一元素，所有的陣列，然後從選擇那些有數組第二個元素等於21。

因此，在Join之後的那一刻，您只剩下來自ghosts列表的數組。您的WHERE子句不會返回任何內容，因爲ghosts中沒有第二個元素等於21.您正在檢查needHelp列表中的內容。

我會建議你做交換Join和Where：

List<int[]> result = needHelp.Where(x => x[1] == 21).Join(ghosts, x=>x[0], y=>y[0], (x,y) => y).ToList(); 

如果它是混亂的爲你的來源，不要以爲在功能x和y變量意味着什麼在多個功能。您的Where呼叫相關x到needHelp，但這並不意味着Join功能中的x與needHelp相關;它引用Where的輸出，它們是來自ghosts的元素。

Answer 2

您的加入方法不是您提供的查詢語法的翻譯。

（在加入x[1]）上h[1]查詢過濾器，但你只能選擇y（g在查詢中），所以凡適用於錯誤的事情後。

這是你查詢的直接翻譯：

List<int[]> result = 
    needHelp 
    .Join (ghosts, x => x[0], y => y[0], (x, y) => new { x, y }) 
    .Where (anon => anon.x[1] == 21) 
    .Select (anon => anon.y) 
    .ToList(); 

Answer 3

的確切方法的語法相當於該查詢語法

from h in needHelp join g in ghosts on h[0] equals g[0] 
where h[1] == 21 
select g 

的是這樣的：

needHelp.Join(ghosts, h => h[0], g => g[0], (h, g) => new { h, g }) 
    .Where(x => x.h[1] == 21) 
    .Select(x => x.g); 

查詢語法使用所謂的「透明標識符」來隱藏這些中間匿名類型，並且這就是爲什麼對於涉及連接的查詢更可取。

談到連接和一般情況下，IMO總是在加入之前應用過濾器總是更好，尤其是在LINQ to Objects中，因爲數據庫查詢優化器無論如何都會重新排列過濾器和連接操作。因此，一個更好的查詢（從性能和內存分配）會是：

needHelp.Where(h => h[1] == 21).Join(ghosts, h => h[0], g => g[0], (h, g) => g);