พื้นหลัง: กว่าเดือนต่อไปผมจะให้พูดคุยเกี่ยวกับสามหรืออย่างน้อยรวมทั้งในบริบทของLINQ C#ฉันต้องการทราบว่าหัวข้อใดที่ควรให้ความสนใจอย่างยุติธรรมโดยพิจารณาจากสิ่งที่ผู้คนอาจเข้าใจยากหรือสิ่งที่พวกเขาอาจรู้สึกผิด ฉันจะไม่พูดLINQถึงSQLหรือ Entity Framework โดยเฉพาะยกเว้นเป็นตัวอย่างของวิธีการสืบค้นข้อมูลที่สามารถดำเนินการจากระยะไกลโดยใช้แผนผังต้นไม้ (และปกติIQueryable)

แล้วคุณพบLINQอะไรที่หนักหนาสาหัส คุณเห็นอะไรในแง่ของความเข้าใจผิด? ตัวอย่างอาจมีข้อใดข้อหนึ่งต่อไปนี้ แต่โปรดอย่า จำกัด ตัวเอง!

• วิธีC#การปฏิบัติเรียบเรียงแบบสอบถามการแสดงออก
• นิพจน์แลมบ์ดา
• ต้นไม้แสดงออก
• วิธีการขยาย
• ประเภทนิรนาม
• IQueryable
• รอการตัดบัญชีเทียบกับการดำเนินการทันที
• สตรีมมิ่ง vs การประมวลผลบัฟเฟอร์ (เช่น OrderBy ถูกเลื่อนออกไป แต่บัฟเฟอร์)
• พิมพ์ตัวแปรโลคัลโดยปริยาย
• การอ่านลายเซ็นทั่วไปที่ซับซ้อน (เช่นEnumerable.Join )

การดำเนินการล่าช้า

ฉันรู้ว่าแนวคิดการดำเนินการที่เลื่อนออกไปควรจะพ่ายแพ้ต่อฉันในตอนนี้ แต่ตัวอย่างนี้ช่วยให้ฉันเข้าใจได้จริง:

static void Linq_Deferred_Execution_Demo()
{
    List<String> items = new List<string> { "Bob", "Alice", "Trent" };

    var results = from s in items select s;

    Console.WriteLine("Before add:");
    foreach (var result in results)
    {
        Console.WriteLine(result);
    }

    items.Add("Mallory");

    //
    //  Enumerating the results again will return the new item, even
    //  though we did not re-assign the Linq expression to it!
    //

    Console.WriteLine("\nAfter add:");
    foreach (var result in results)
    {
        Console.WriteLine(result);
    }
}

โค้ดด้านบนส่งคืนค่าต่อไปนี้:

Before add:
Bob
Alice
Trent

After add:
Bob
Alice
Trent
Mallory

ว่ามีมากขึ้นกว่าเพียงแค่LINQการSQLและคุณสมบัติที่มีมากกว่าเพียงแค่SQLparser ฝังตัวอยู่ในภาษา

สัญกรณ์ Big O LINQ ทำให้มันง่ายในการเขียนอัลกอริทึม O (n ^ 4) อย่างไม่น่าเชื่อหากคุณไม่รู้ว่าคุณกำลังทำอะไรอยู่

ฉันคิดว่าความจริงที่ว่าLambdaนิพจน์สามารถแก้ไขทั้งต้นไม้นิพจน์และผู้รับมอบสิทธิ์ที่ไม่ระบุชื่อดังนั้นคุณสามารถส่งlambdaนิพจน์ที่เหมือนกันประกาศไปยังIEnumerable<T>วิธีการIQueryable<T>ขยายและวิธีการขยาย

เอาฉันวิธีนานเกินไปที่จะรู้ว่าหลายวิธีการขยาย LINQ เช่นSingle(), SingleOrDefault()ฯลฯ มี overloads ที่ใช้ lambdas

คุณทำได้ :

Single(x => x.id == id)

และไม่จำเป็นต้องพูดสิ่งนี้ - ซึ่งการสอนที่ไม่ดีบางอย่างทำให้ฉันติดนิสัย

Where(x => x.id == id).Single()

ใน LINQ ไปยัง SQL ฉันเห็นคนที่ไม่เข้าใจ DataContext อย่างต่อเนื่องว่าจะใช้อย่างไรและควรใช้อย่างไร มีคนจำนวนมากที่ไม่เห็น DataContext สำหรับสิ่งที่เป็นหน่วยของงานวัตถุไม่ใช่วัตถุแบบถาวร

ฉันได้เห็นหลายครั้งที่ผู้คนพยายามที่จะเป็นหนึ่งเดียว DataContext / เซสชันมัน / ฯลฯ แทนที่จะทำเวลาใหม่สำหรับการดำเนินการแต่ละครั้ง

จากนั้นก็มีการทิ้ง DataContext ก่อนที่ IQueryable จะได้รับการประเมิน แต่นั่นก็เป็นเรื่องที่สมบูรณ์แบบสำหรับคนที่ไม่เข้าใจ IQueryable มากกว่า DataContext

แนวคิดอื่นที่ฉันเห็นความสับสนเป็นจำนวนมากคือ Query Syntax และ Expression Syntax ฉันจะใช้สิ่งที่ง่ายที่สุด ณ จุดนั้นซึ่งมักจะติดกับ Expression Syntax ผู้คนจำนวนมากยังไม่รู้ว่าพวกเขาจะสร้างสิ่งเดียวกันในตอนท้ายแบบสอบถามจะรวบรวมเป็น Expression หลังจากทั้งหมด

ผมคิดว่าส่วนหนึ่งเข้าใจผิดของ LINQ ก็คือว่ามันเป็นส่วนขยายของภาษาไม่ได้ขยายฐานข้อมูลหรือสร้าง

LINQเป็นมากกว่าLINQ to SQLนั้นอีกแล้ว

ตอนนี้พวกเราส่วนใหญ่เคยใช้LINQคอลเลคชั่นเราจะไม่กลับไป!

LINQ เป็นคุณลักษณะที่สำคัญที่สุดอย่างเดียวของ. NET ตั้งแต่ Generics ใน 2.0 และ Anonymous Type ใน 3.0

และตอนนี้เรามีแลมบ์ดาฉันไม่สามารถรอการเขียนโปรแกรมแบบขนาน!

ฉันคนหนึ่งอยากจะรู้ว่าถ้าฉันต้องรู้ว่าต้นไม้แสดงออกคืออะไรและทำไม

ฉันค่อนข้างใหม่กับ LINQ นี่คือสิ่งที่ฉันสะดุดในความพยายามครั้งแรกของฉัน

• การรวมหลายแบบสอบถามเป็นหนึ่งเดียว
• การดีบักการสอบถาม LINQ อย่างมีประสิทธิภาพใน Visual Studio

สิ่งที่ฉันไม่ได้ตระหนักในตอนแรกก็คือว่าไวยากรณ์ LINQ ไม่ต้องการIEnumerable<T>หรือIQueryable<T>ทำงานได้ LINQ เป็นเพียงการจับคู่รูปแบบ

alt text http://bartdesmet.info/images_wlw/QIsIQueryabletheRightChoiceforMe_13478/image_thumb_3.png

นี่คือคำตอบ (ไม่ฉันไม่ได้เขียนบล็อกนั้น Bart De Smet ทำและเขาเป็นหนึ่งในนักเขียนบล็อกที่ดีที่สุดใน LINQ ที่ฉันพบ)

ฉันยังคงมีปัญหากับคำสั่ง "let" (ซึ่งฉันไม่เคยพบใช้มาก่อน) และ SelectMany (ซึ่งฉันเคยใช้ แต่ไม่แน่ใจว่าฉันทำถูกต้องแล้ว)

ทำความเข้าใจเมื่อสิ่งที่เป็นนามธรรมในหมู่ผู้ให้บริการ Linq รั่วไหล บางสิ่งทำงานบนวัตถุ แต่ไม่ใช่ SQL (เช่น. TakeWhile) วิธีการบางอย่างสามารถแปลเป็น SQL (ToUpper) ในขณะที่วิธีอื่นไม่สามารถทำได้ เทคนิคบางอย่างมีประสิทธิภาพมากขึ้นในวัตถุที่คนอื่นมีประสิทธิภาพมากขึ้นใน SQL (วิธีการเข้าร่วมที่แตกต่างกัน)

สองสิ่ง

1. คนที่คิดถึง Linq ว่า Linq ถึง SQL
2. บางคนคิดว่าพวกเขาสามารถเริ่มแทนที่ foreach / logic ทั้งหมดด้วยการสืบค้น Linq โดยไม่คำนึงถึงผลการปฏิบัติงานนี้

ตกลงเนื่องจากความต้องการฉันได้เขียนรายการของ Expression ฉันไม่พอใจ 100% กับวิธีที่ blogger และ LiveWriter สมคบกันในการจัดรูปแบบ แต่ตอนนี้มันจะทำ ...

อย่างไรก็ตามนี่ไป ... ฉันชอบความคิดเห็นใด ๆ โดยเฉพาะถ้ามีพื้นที่ที่ผู้คนต้องการข้อมูลเพิ่มเติม

ที่นี่มันคือชอบหรือเกลียดมัน ...

ข้อความแสดงข้อผิดพลาดบางอย่างโดยเฉพาะจาก LINQ ไปยัง SQL อาจทำให้สับสนได้ การยิ้มกว้าง

ฉันถูกกัดโดยการดำเนินการรอการตัดบัญชีสองครั้งเหมือนคนอื่น ๆ ฉันคิดว่าสิ่งที่สับสนที่สุดสำหรับฉันคือ SQL Server Query Provider และสิ่งที่คุณทำได้และไม่สามารถทำได้

ฉันยังคงประหลาดใจกับความจริงที่ว่าคุณไม่สามารถทำ Sum () ในคอลัมน์ทศนิยม / เงินซึ่งบางครั้งว่างเปล่า ใช้ DefaultIfEmpty () เพียงใช้งานไม่ได้ :(

ฉันคิดว่าสิ่งที่ดีที่จะครอบคลุมใน LINQ คือวิธีที่คุณจะได้รับตัวเองในปัญหาประสิทธิภาพฉลาด ตัวอย่างเช่นการใช้การนับของ LINQ เป็นเงื่อนไขลูปไม่ใช่สมาร์ทจริงๆ

IQueryable นั้นยอมรับทั้งExpression<Func<T1, T2, T3, ...>>และFunc<T1, T2, T3, ...>โดยไม่ให้คำแนะนำเกี่ยวกับการเสื่อมประสิทธิภาพในกรณีที่ 2

นี่คือตัวอย่างรหัสที่แสดงให้เห็นถึงสิ่งที่ฉันหมายถึง:

[TestMethod]
public void QueryComplexityTest()
{
    var users = _dataContext.Users;

    Func<User, bool>                funcSelector =       q => q.UserName.StartsWith("Test");
    Expression<Func<User, bool>>    expressionSelector = q => q.UserName.StartsWith("Test");

    // Returns IEnumerable, and do filtering of data on client-side
    IQueryable<User> func = users.Where(funcSelector).AsQueryable();
    // Returns IQuerible and do filtering of data on server side
    // SELECT ... FROM [dbo].[User] AS [t0] WHERE [t0].[user_name] LIKE @p0
    IQueryable<User> exp = users.Where(expressionSelector);
}

ฉันไม่รู้ว่ามันมีคุณสมบัติเข้าใจผิดหรือไม่ แต่สำหรับฉัน

ฉันยินดีที่ได้เรียนรู้เกี่ยวกับ DataLoadOptions และฉันจะควบคุมว่าตารางใดบ้างที่จะเข้าร่วมเมื่อฉันทำการสืบค้นเฉพาะ

ดูที่นี่สำหรับข้อมูลเพิ่มเติม: MSDN: DataLoadOptions

ฉันจะบอกว่ามุมมองที่ผิดพลาดมากที่สุด (หรือไม่ควรเข้าใจ?) ของ LINQ คือ IQueryableและผู้ให้บริการ LINQ ที่กำหนดเองกำหนดเองผู้ให้บริการ

ฉันใช้ LINQ มาระยะหนึ่งแล้วและรู้สึกสะดวกสบายในโลก IEnumerable และสามารถแก้ปัญหาส่วนใหญ่ด้วย LINQ

แต่เมื่อฉันเริ่มดูและอ่านเกี่ยวกับ IQueryable และ Expressions และผู้ให้บริการ linq แบบกำหนดเองมันทำให้หัวของฉันหมุน ดูว่า LINQ กับ SQL ทำงานอย่างไรถ้าคุณต้องการดูตรรกะที่ซับซ้อน

ฉันหวังว่าจะเข้าใจลักษณะของ LINQ ...

อย่างที่คนส่วนใหญ่พูดว่าฉันคิดว่าส่วนที่เข้าใจผิดมากที่สุดคือสมมติว่า LINQ เป็นเพียงการแทนที่ T-SQL ผู้จัดการของฉันที่คิดว่าตัวเองเป็นกูรู TSQL จะไม่ให้พวกเราใช้ LINQ ในโครงการของเราและแม้แต่เกลียด MS ในการปล่อยเรื่องนี้ !!!

var แสดงถึงอะไรเมื่อดำเนินการสืบค้น

ใช่ไหม iQueryable , iSingleResult, iMultipleResult, หรือไม่ก็เปลี่ยนขึ้นอยู่กับการดำเนินการ มีการคาดเดาบางอย่างเกี่ยวกับการใช้ (สิ่งที่ดูเหมือนจะเป็น) การพิมพ์แบบไดนามิกและการพิมพ์แบบคงที่มาตรฐานใน C #

วิธีง่ายๆในการซ้อนวนเป็นสิ่งที่ฉันไม่คิดว่าทุกคนเข้าใจ

ตัวอย่างเช่น:

from outerloopitem in outerloopitems
from innerloopitem in outerloopitem.childitems
select outerloopitem, innerloopitem

group by ยังทำให้หัวของฉันหมุน

ความสับสนเกี่ยวกับการดำเนินการรอการตัดบัญชีควรสามารถแก้ไขได้ด้วยการใช้รหัส LINQ ที่ใช้งานง่ายและเล่นในหน้าต่างดู

รวบรวมคำค้นหา

ความจริงที่ว่าคุณไม่สามารถเชื่อมโยง IQueryableเนื่องจากพวกเขาเรียกวิธีการ (ในขณะที่ยังไม่มีอะไรอื่นนอกจาก SQL แปลได้!) และเป็นไปไม่ได้ที่จะหลีกเลี่ยงปัญหานี้ก็คือการสร้างความกังวลและสร้างการละเมิด DRY ฉันต้องการของฉันIQueryableสำหรับเฉพาะกิจซึ่งฉันไม่ได้รวบรวมแบบสอบถาม (ฉันมีเพียงแบบสอบถามรวบรวมสำหรับสถานการณ์หนัก) แต่ในแบบสอบถามที่รวบรวมฉันไม่สามารถใช้พวกเขาและต้องเขียนไวยากรณ์แบบสอบถามปกติอีกครั้ง ตอนนี้ฉันกำลังทำแบบสอบถามย่อยเดียวกันใน 2 แห่งต้องจำไว้ว่าต้องอัปเดตทั้งสองอย่าง ฝันร้าย

ฉันคิดว่า # 1 ความเข้าใจผิดเกี่ยวกับ LINQ กับ SQL คือคุณยังต้องรู้จัก SQL เพื่อให้สามารถใช้งานได้อย่างมีประสิทธิภาพ

อีกสิ่งหนึ่งที่เข้าใจผิดเกี่ยวกับ Linq ถึง SQL คือคุณยังคงต้องลดความปลอดภัยของฐานข้อมูลของคุณลงจนถึงจุดที่ไร้สาระเพื่อให้มันทำงานได้

ประเด็นที่สามคือการใช้ Linq ถึง Sql พร้อมกับคลาสแบบไดนามิก (หมายถึงคำจำกัดความของคลาสนั้นถูกสร้างขึ้นที่รันไทม์) ทำให้มีการรวบรวมในเวลาอันรวดเร็ว ซึ่งสามารถฆ่าประสิทธิภาพได้อย่างแน่นอน

ขี้เกียจโหลด

ดังที่กล่าวมาการโหลดแบบขี้เกียจและการดำเนินการที่เลื่อนออกไป

วิธี LINQ กับวัตถุและ LINQ กับ XML (IEnumerable) แตกต่างจาก LINQ ไปยัง SQL (IQueryable)

วิธีสร้าง Data Access Layer, Business Layer และ Presentation Layer ด้วย LINQ ในทุกชั้น .... และเป็นตัวอย่างที่ดี

อย่างที่คนส่วนใหญ่พูดว่าฉันคิดว่าส่วนที่เข้าใจผิดมากที่สุดคือสมมติว่า LINQ เป็นเพียงการแทนที่ T-SQL ผู้จัดการของฉันที่คิดว่าตัวเองเป็นกูรู TSQL จะไม่ให้พวกเราใช้ LINQ ในโครงการของเราและแม้แต่เกลียด MS ในการปล่อยเรื่องนี้ !!!

ธุรกรรม (โดยไม่ใช้ TransactionScope)