50 คำถามและคำตอบสัมภาษณ์เกี่ยวกับ Entity Framework ยอดนิยม (ปี 2026)

การเตรียมตัวสำหรับการสัมภาษณ์งานด้าน Entity Framework หมายถึงการคาดการณ์คำถามที่จะเปิดเผยความสามารถที่แท้จริง คำถามสัมภาษณ์งาน Entity Framework จะเผยให้เห็นถึงความคิด ความตระหนักรู้ด้านประสิทธิภาพ และวิธีที่ผู้สมัครนำแนวคิดไปประยุกต์ใช้ในทางปฏิบัติ

การเชี่ยวชาญ Entity Framework จะเปิดโอกาสทางอาชีพในด้านการพัฒนาซอฟต์แวร์สมัยใหม่ ตั้งแต่แพลตฟอร์มที่ขับเคลื่อนด้วยข้อมูลไปจนถึงบริการคลาวด์ ประสบการณ์จริงช่วยสร้างความสามารถในการวิเคราะห์ เสริมสร้างความรู้เชิงเทคนิค และสนับสนุนทีมงาน ผู้บริหารฝ่ายบุคคลให้ความสำคัญกับการแก้ปัญหาด้วยตนเอง การออกแบบที่ปรับขนาดได้ การให้คำแนะนำแก่ผู้ที่มีประสบการณ์น้อยกว่า และเส้นทางการเติบโตสำหรับบัณฑิตจบใหม่ อ่านเพิ่มเติม ...

👉 ดาวน์โหลด PDF ฟรี: คำถามและคำตอบสำหรับการสัมภาษณ์งานเกี่ยวกับ Entity Framework

คำถามและคำตอบสัมภาษณ์งานเกี่ยวกับ Entity Framework ที่ได้รับความนิยมสูงสุด

1) Entity Framework คืออะไร และใช้เพื่ออะไร?

Entity Framework (EF) คือ MicrosoftORM (Object-Relational Map) ของpingเฟรมเวิร์กสำหรับ .NET ที่ ช่วยลดความซับซ้อนของการโต้ตอบกับฐานข้อมูลโดยอนุญาตให้นักพัฒนาทำงานกับข้อมูลในรูปแบบอ็อบเจ็กต์ .NET ที่กำหนดประเภทไว้อย่างชัดเจน แทนที่จะใช้คำสั่ง SQL ดิบๆกล้ามท้องนี้tracEntity Framework ช่วยให้นักพัฒนาสามารถดำเนินการ CRUD (สร้าง อ่าน อัปเดต ลบ) โดยใช้โครงสร้าง C# ที่คุ้นเคย และเฟรมเวิร์กจะจัดการแปลงการดำเนินการเหล่านี้ให้เป็นคำสั่ง SQL ที่เหมาะสมที่สุดโดยอัตโนมัติ EF ช่วยลดโค้ดการเข้าถึงข้อมูลที่ซ้ำซ้อน ปรับปรุงความสามารถในการบำรุงรักษา และช่วยบังคับใช้ความปลอดภัยของประเภทข้อมูลในระหว่างการคอมไพล์

ตัวอย่างเช่น แทนที่จะเขียน SQL คุณสามารถใช้:

var customers = context.Customers.Where(c => c.IsActive).ToList();

EF จะแปลงคำสั่ง LINQ นี้เป็นคำสั่ง SQL จากนั้นเรียกใช้คำสั่งนั้นกับฐานข้อมูล และส่งคืนผลลัพธ์ในรูปแบบอ็อบเจ็กต์

2) อธิบายความแตกต่างระหว่าง Code แนวทางแรก ได้แก่ แนวทางฐานข้อมูลเป็นหลัก (Database First) และแนวทางแบบจำลองเป็นหลัก (Model First)

Entity Framework รองรับแนวทางการพัฒนาหลัก 3 วิธี ได้แก่:

เข้าใกล้	ควรใช้เมื่อใด	เกิดอะไรขึ้น
Code ชื่อจริง	โครงการใหม่หรือการออกแบบที่ขับเคลื่อนด้วยโดเมน	คุณกำหนดคลาสเอนทิตี EF จะสร้างสคีมาฐานข้อมูลจากโค้ด
ฐานข้อมูลก่อน	ฐานข้อมูลที่มีอยู่	EF สร้างคลาสเอนทิตีและคอนเท็กซ์จากสคีมาที่มีอยู่แล้ว
แบบจำลองแรก	เมื่อคุณชื่นชอบการออกแบบเชิงภาพ	คุณออกแบบโมเดลในโปรแกรมออกแบบภาพ (Entity Designer) และ EF จะสร้างทั้งคลาสและฐานข้อมูลให้โดยอัตโนมัติ

แต่ละแนวทางเหมาะสำหรับสถานการณ์ที่แตกต่างกัน: Code ชื่อจริง เป็นที่นิยมในการพัฒนาแบบ Agile ฐานข้อมูลก่อน นิยมใช้กับฐานข้อมูลแบบเก่า และ แบบจำลองแรก เหมาะสำหรับกรณีที่การออกแบบรูปลักษณ์มีความสำคัญ

3) DbContext คืออะไร และมีบทบาทอย่างไรใน EF?

DbContext เป็นคลาสหลักที่จัดการ เซสชันกับฐานข้อมูล, tracการเปลี่ยนแปลงของเอนทิตี ks และการบันทึกข้อมูลพิกัดกลับไปยังฐานข้อมูล มันทำหน้าที่เป็นสะพานเชื่อมระหว่างแอปพลิเคชัน C# ของคุณกับฐานข้อมูล ผ่านทาง DbContextคุณกำหนด DbSet<TEntity> คุณสมบัติ ซึ่งแสดงถึงกลุ่มของเอนทิตีและเชื่อมโยงกับตารางในฐานข้อมูล

ตัวอย่าง:

public class AppDbContext : DbContext
{
    public DbSet<Product> Products { get; set; }
}

ที่นี่ Products ทำหน้าที่เป็นชุดข้อมูลสำหรับการดำเนินการ CRUD EF ใช้บริบทนี้เพื่อ tracสถานะวัตถุ k และสร้างคำสั่ง SQL บน SaveChanges().

4) การย้ายข้อมูล (Migration) ใน Entity Framework คืออะไร และใช้งานอย่างไร?

การย้ายถิ่น เป็นกลไกในการ track และสมัคร การเปลี่ยนแปลงโครงร่าง การย้ายข้อมูลจะช่วยให้ฐานข้อมูลซิงค์ข้อมูลได้อย่างต่อเนื่องเมื่อโมเดลของคุณพัฒนาขึ้น โดยไม่ต้องแก้ไขสคริปต์ SQL ด้วยตนเอง เมื่อโมเดลของคุณพัฒนาขึ้น การย้ายข้อมูลจะช่วยให้ฐานข้อมูลซิงค์ข้อมูลได้อย่างถูกต้อง Code ขั้นแรก คุณใช้คำสั่งต่างๆ เช่น:

Add-Migration InitialCreate
Update-Database

กระบวนการนี้จะสร้างคลาสการย้ายข้อมูลที่กำหนดการเปลี่ยนแปลงโครงสร้างฐานข้อมูลและนำไปใช้กับฐานข้อมูล การย้ายข้อมูลช่วยให้สามารถควบคุมเวอร์ชันของโครงสร้างฐานข้อมูลและอำนวยความสะดวกในการพัฒนาร่วมกันได้

5) อธิบาย Lazy Loading, Eager Loading และ Explicit Loading

การโหลดข้อมูลที่เกี่ยวข้องอย่างมีประสิทธิภาพเป็นสิ่งสำคัญใน EF ต่อไปนี้เป็นการเปรียบเทียบ:

กลยุทธ์	เมื่อมันทำงาน	การใช้งานทั่วไป
กำลังโหลดขี้เกียจ	ข้อมูลที่เกี่ยวข้องจะถูกโหลดเมื่อเข้าถึงครั้งแรก	ใช้ในกรณีที่ข้อมูลที่เกี่ยวข้องอาจไม่จำเป็นเสมอไป
กำลังโหลดอย่างกระตือรือร้น	ข้อมูลที่เกี่ยวข้องถูกโหลดไว้ล่วงหน้าผ่านทาง `.Include()`	ใช้เมื่อคุณรู้ว่าคุณต้องการข้อมูลที่เกี่ยวข้อง
กำลังโหลดที่ชัดเจน	โหลดด้วยตนเองหลังจากสอบถาม	ช่วยให้สามารถควบคุมได้อย่างแม่นยำว่าข้อมูลที่เกี่ยวข้องจะถูกโหลดเมื่อใด

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

var orders = context.Orders.Include(o => o.Customer).ToList(); // Eager

การโหลดแบบ Lazy Loading ช่วยลดจำนวนการสืบค้นข้อมูลในขั้นต้น แต่ก็อาจทำให้เกิดปัญหาได้ ปัญหาการสอบถาม N+1 หากไม่ใช้งานอย่างระมัดระวัง

6) การเปลี่ยนแปลงคืออะไร tracราชาแห่ง Entity Framework?

เปลี่ยนแปลง tracking คือกลไกภายในของ EF ในการ ตรวจสอบการเปลี่ยนแปลงสถานะของเอนทิตี หลังจากดำเนินการสืบค้นแล้ว เมื่อมีการดึงข้อมูลเอนทิตีโดย DbContext, มันคือ tracked. การเปลี่ยนแปลงใดๆ ต่อคุณสมบัติของมันจะถูกบันทึกไว้ และเมื่อใด SaveChanges() เมื่อถูกเรียกใช้งาน EF จะสร้างคำสั่ง SQL ที่เหมาะสม INSERT, UPDATEหรือ DELETE คำสั่ง สำหรับสถานการณ์แบบอ่านอย่างเดียวที่ tracไม่จำเป็นต้องมีกษัตริย์ AsNoTracking() ช่วยเพิ่มประสิทธิภาพโดยการปิดใช้งานการเปลี่ยนแปลง tracกษัตริย์.

7) Entity Framework จัดการกับข้อขัดแย้งในการทำงานพร้อมกันอย่างไร?

การควบคุมการทำงานพร้อมกัน (Concurrency control) ช่วยให้มั่นใจได้ว่าผู้ใช้หลายคนที่อัปเดตข้อมูลเดียวกันจะไม่เขียนทับการเปลี่ยนแปลงของกันและกันโดยไม่ตั้งใจ EF ใช้การควบคุมนี้ การเกิดขึ้นพร้อมกันในแง่ดี โดยค่าเริ่มต้น วิธีการทั่วไปคือการเพิ่ม โทเค็นการทำงานพร้อมกัน (ชอบ RowVersion (การประทับเวลา) EF ตรวจสอบโทเค็นนี้ระหว่าง SaveChanges()และหากแตกต่างจากเวอร์ชันในฐานข้อมูล DbUpdateConcurrencyException เกิดข้อผิดพลาดขึ้น ซึ่งบ่งชี้ถึงความขัดแย้ง จากนั้นนักพัฒนาสามารถจัดการกับข้อผิดพลาดนี้เพื่อลองใหม่หรือแก้ไขความแตกต่างของข้อมูลได้

8) คุณสมบัติการนำทางใน EF คืออะไร?

คุณสมบัติการนำทางกำหนดความสัมพันธ์ระหว่างเอนทิตีต่างๆ ซึ่งช่วยให้ EF สามารถ... นำทางความสัมพันธ์ (เช่น ความสัมพันธ์แบบหนึ่งต่อหลาย) โดยไม่ต้องทำการเชื่อมต่อด้วยตนเอง:

public class Order
{
    public int Id { get; set; }
    public Customer Customer { get; set; }
}

ที่นี่ Customer เป็นคุณสมบัติการนำทางที่เชื่อมโยง Order ที่เกี่ยวข้องกับ CustomerEF ใช้คุณสมบัติเหล่านี้ในการสร้างความสัมพันธ์และเชื่อมต่อโดยอัตโนมัติระหว่างการสืบค้น คุณสมบัติการนำทางทำงานควบคู่กันไป กุญแจต่างประเทศ เพื่อสร้างแบบจำลองความสัมพันธ์

9) จุดประสงค์ของ AsNo คืออะไรTracกษัตริย์()?

AsNoTracking() ปิดใช้งานการเปลี่ยนแปลง tracกษัตริย์สำหรับการสอบถาม ซึ่งเป็นประโยชน์สำหรับ อ่านอย่างเดียว การดำเนินการที่คุณไม่ได้ตั้งใจจะอัปเดตเอนทิตีที่ดึงมา ซึ่งจะช่วยเพิ่มประสิทธิภาพโดยการลดการใช้หน่วยความจำและ tracลดภาระงานของ King โดยเฉพาะอย่างยิ่งมีประโยชน์เมื่อต้องการดึงชุดข้อมูลขนาดใหญ่โดยไม่แก้ไขข้อมูลเหล่านั้น

10) คำสั่งค้นหาแบบคอมไพล์คืออะไร และควรใช้เมื่อใด?

การคอมไพล์คิวรีเป็นเทคนิคการเพิ่มประสิทธิภาพการทำงาน โดยปกติแล้วเมื่อมีการเรียกใช้คิวรี LINQ นั้น EF จะแปลงเป็น SQL ทุกครั้ง แต่ด้วยการคอมไพล์คิวรี การแปลงนี้จะทำเพียงครั้งเดียว และจะนำดีเลเกตที่ได้กลับมาใช้ซ้ำ ซึ่งช่วยลดภาระการทำงานสำหรับคิวรีที่เรียกใช้บ่อยหรือคิวรีที่ซับซ้อน ใช้ได้ใน... การจราจรสูง สถานการณ์ที่เรียกใช้คำสั่งค้นหาเดียวกันซ้ำๆ โดยใช้พารามิเตอร์ที่แตกต่างกัน

11) สถานะของเอนทิตีใน Entity Framework คืออะไร และส่งผลต่อฟังก์ชัน SaveChanges() อย่างไร?

กรอบเอนทิตี tracks ของแต่ละเอนทิตี้ รัฐ เพื่อพิจารณาว่าควรดำเนินการใดกับฐานข้อมูลระหว่าง SaveChanges()สถานะหลักของเอนทิตีมีดังนี้:

สถานะ	Descriptไอออน	Operation ถูกกระตุ้น
ที่เพิ่ม	จะเพิ่มเอนทิตีใหม่เข้าไป	`INSERT`
แก้ไข	เอนทิตีที่มีอยู่ได้รับการอัปเดตแล้ว	`UPDATE`
ลบ	หน่วยงานที่ถูกทำเครื่องหมายเพื่อลบออก	`DELETE`
ไม่เปลี่ยนแปลง	ไม่พบการเปลี่ยนแปลงใดๆ	ไม่มี
สันโดษ	ไม่ tracถูกกำหนดโดยบริบท	ไม่มี

เมื่อคุณโทร SaveChanges()EF จะตรวจสอบสถานะของเอนทิตีและดำเนินการคำสั่ง SQL ที่เกี่ยวข้อง ตัวอย่างเช่น การเพิ่มเอนทิตีใหม่ลงใน... DbSet จะถูกทำเครื่องหมาย ที่เพิ่มส่งผลให้ไฟล์ INSERT แบบสอบถาม

ตัวอย่าง:

context.Entry(product).State = EntityState.Modified;
context.SaveChanges();

คำสั่งนี้จะอัปเดตข้อมูลในฐานข้อมูลสำหรับเอนทิตีนั้นโดยตรง

ความเข้าใจเกี่ยวกับสถานะต่างๆ ช่วยให้ควบคุมการซิงโครไนซ์ข้อมูลและประสิทธิภาพได้ดียิ่งขึ้น

12) การใช้ Entity Framework มีข้อดีและข้อเสียอย่างไรบ้าง?

Entity Framework มีข้อดีมากมาย แต่ก็มีข้อเสียอยู่บ้าง ขึ้นอยู่กับกรณีการใช้งานของคุณ

ข้อดี	ข้อเสีย
ช่วยให้การเข้าถึงข้อมูลง่ายขึ้นด้วย LINQ และโมเดลเชิงวัตถุ	ค่าใช้จ่ายด้านประสิทธิภาพเมื่อเทียบกับ ADO.NET แบบดั้งเดิม
ลดการเขียนโค้ด SQL ที่ซ้ำซ้อน	แบบสอบถามที่ซับซ้อนอาจทำให้ได้คำสั่ง SQL ที่ไม่มีประสิทธิภาพ
รองรับผู้ให้บริการฐานข้อมูลหลายราย	การแก้ไขข้อผิดพลาดในคำสั่ง SQL ที่สร้างขึ้นทำได้ยากขึ้น
มีการกำหนดประเภทข้อมูลอย่างเข้มงวด ช่วยเพิ่มความปลอดภัยในขั้นตอนการคอมไพล์	อาจเกิดความขัดแย้งด้านการย้ายข้อมูลในทีมขนาดใหญ่ได้
ช่วยให้สามารถสร้างต้นแบบได้อย่างรวดเร็วping สีสดสวย Code แรก	Less ควบคุมการค้นหาข้อมูลอย่างละเอียดได้

สำหรับระบบขนาดใหญ่ที่ต้องการประสิทธิภาพสูงสุด นักพัฒนาอาจยังคงผสมผสานวิธีการต่างๆ เข้าด้วยกัน SQL ดิบกับ EF สำหรับการเพิ่มประสิทธิภาพ

13) Entity Framework จัดการกับความสัมพันธ์ (หนึ่งต่อหนึ่ง หนึ่งต่อหลาย หลายต่อหลาย) อย่างไร?

Entity Framework จัดการความสัมพันธ์ผ่านทาง คุณสมบัติการนำทาง และ สมาคมต่างประเทศที่สำคัญ.

ประเภทของความสัมพันธ์มีดังนี้:

ประเภทความสัมพันธ์	Descriptไอออน	ตัวอย่าง
หนึ่งต่อหนึ่ง	แต่ละอินสแตนซ์ของเอนทิตีจะมีเอนทิตีที่เกี่ยวข้องหนึ่งรายการ	`User` ↔ `UserProfile`
หนึ่งต่อหลายคน	หนึ่งหน่วยมีความสัมพันธ์กับอีกหลายหน่วย	`Customer` → `Orders`
หลายต่อหลาย	สิ่งต่างๆ หลายอย่างมีความสัมพันธ์กัน	`Student` ↔ `Course`

ตัวอย่างของไฟล์ หนึ่งต่อหลายคน ความสัมพันธ์:

public class Customer
{
    public int CustomerId { get; set; }
    public ICollection<Order> Orders { get; set; }
}

EF จะสร้าง foreign key และ handle โดยอัตโนมัติ กฎการลบแบบเรียงลำดับ ขึ้นอยู่กับการกำหนดค่า

คุณยังสามารถใช้ ฟลูเอนท์ API สำหรับแผนผังความสัมพันธ์ที่ชัดเจนยิ่งขึ้นping.

14) LINQ to Entities และ LINQ to SQL แตกต่างกันอย่างไร?

ลักษณะ	LINQ ไปยังเอนทิตี	LINQ เป็น SQL
ฐานข้อมูลที่รองรับ	หลายรายการ (SQL Server, Oracle, MySQLฯลฯ )	เฉพาะ SQL Server เท่านั้น
โครงสร้างพื้นฐาน	กรอบเอนทิตี	ADO.NET
รุ่น	แบบจำลองเอนทิตีเชิงแนวคิด	ตารางฐานข้อมูลเท่านั้น
แผนที่แสดงที่ตั้งบริษัทping	แผนที่ซับซ้อนping (การสืบทอด, ความสัมพันธ์)	แผนผังตารางโดยตรงping
การสนับสนุนในอนาคต	ได้รับการสนับสนุนอย่างแข็งขัน	เลิก

LINQ ไปยังเอนทิตี เป็นส่วนหนึ่งของ Entity Framework และมีความหลากหลายในการใช้งานมากกว่า ในขณะที่ LINQ เป็น SQL มีข้อจำกัดอยู่ที่ SQL Server และกรณีการใช้งานที่ไม่ซับซ้อน

ดังนั้น LINQ to Entities จึงเป็นตัวเลือกที่แนะนำสำหรับการพัฒนาในระดับองค์กร

15) ObjectContext และ DbContext แตกต่างกันอย่างไร?

ลักษณะ	อ็อบเจ็กต์คอนเท็กซ์	บริบทฐานข้อมูล
กรอบ	EF เวอร์ชันก่อนหน้า	API ที่ใช้งานง่ายขึ้นใน EF 4.1+
ความซับซ้อน	ละเอียดยิ่งขึ้น	น้ำหนักเบาและใช้งานง่าย
ประสิทธิภาพ	เร็วกว่าเล็กน้อย แต่ใช้งานยากกว่า	ลดความซับซ้อนด้วยค่าใช้จ่ายขั้นต่ำ
เปลี่ยนแปลง Tracกษัตริย์	จำเป็นต้องมีการกำหนดค่าด้วยตนเอง	อัตโนมัติ tracกษัตริย์
การใช้งานที่ต้องการ	ระบบเดิม	โครงการ EF / EF Core สมัยใหม่

DbContext ห่อหุ้มภายใน ObjectContext แต่มี API ที่สะอาดตาและใช้งานง่ายกว่า แอปพลิเคชัน .NET ส่วนใหญ่ในปัจจุบันควรใช้ DbContext.

16) อธิบายวงจรชีวิตของเอนทิตีใน Entity Framework

วงจรชีวิตของเอนทิตีอธิบายถึงสิ่งนั้นๆ การเปลี่ยนสถานะ จากจุดเริ่มต้นสู่ความคงอยู่:

การสร้าง – เอนทิตีถูกสร้างขึ้นในหน่วยความจำ (สถานะ: สันโดษ).
สิ่งที่แนบมา – เพิ่มเข้าไปในบริบทโดย DbSet.Add() (สถานะ: ที่เพิ่ม).
การเปลี่ยนแปลง – ตรวจพบการเปลี่ยนแปลงโดยอัตโนมัติ (สถานะ: แก้ไข).
การติดตา - SaveChanges() เรียกใช้ → คำสั่ง SQL ถูกดำเนินการ
การลบ – หน่วยงานที่ถูกทำเครื่องหมายว่า ลบ และถูกลบออกจากฐานข้อมูลแล้ว

การเข้าใจวงจรชีวิตนี้จะช่วยในการแก้ไขปัญหาข้อมูลและเพิ่มประสิทธิภาพการจัดการบริบท EF

17) Fluent API มีประโยชน์อย่างไรใน Entity Framework?

การขอ ฟลูเอนท์ API นำเสนอวิธีการเขียนโปรแกรมเพื่อกำหนดค่าความสัมพันธ์ของโมเดล ข้อจำกัด และแผนที่pingมักใช้ใน OnModelCreating() วิธีการของคุณ DbContext.

มันช่วยให้สามารถควบคุมการกำหนดค่าต่างๆ ได้อย่างละเอียดมากขึ้น คำอธิบายประกอบข้อมูล ไม่สามารถอธิบายได้

ตัวอย่าง:

modelBuilder.Entity<Customer>()
    .HasMany(c => c.Orders)
    .WithOne(o => o.Customer)
    .HasForeignKey(o => o.CustomerId);

Fluent API มีประสิทธิภาพเป็นพิเศษสำหรับการกำหนดค่า คีย์ผสม, ความสัมพันธ์แบบหลายต่อหลายและ กฎการเรียงลำดับ.

18) Data Annotations ใน Entity Framework คืออะไร?

คำอธิบายประกอบข้อมูลคือ แอตทริบิวต์ นำไปใช้โดยตรงกับคลาสโมเดลหรือคุณสมบัติเพื่อกำหนดพฤติกรรมของสคีมา วิธีการนี้เรียบง่ายกว่า Fluent API แต่มีความยืดหยุ่นน้อยกว่า

ตัวอย่าง:

public class Product
{
    [Key]
    public int ProductId { get; set; }

    [Required]
    [StringLength(50)]
    public string Name { get; set; }
}

คำอธิบายประกอบจะกำหนดคีย์ ความยาวของสตริง ฟิลด์ที่จำเป็น และความสัมพันธ์ สำหรับกรณีขั้นสูง นักพัฒนาซอฟต์แวร์มักจะใช้การผสมผสานกัน คำอธิบายประกอบข้อมูล และ ฟลูเอนท์ API.

19) อะไรคือความแตกต่างระหว่าง tracเคดและอันtracเอนทิตี ked ใน EF Core?

ประเภท	Descriptไอออน	ใช้กรณี
Tracเอนทิตี ked	ตรวจสอบโดย `DbContext` สำหรับการเปลี่ยนแปลง	ลักษณะการทำงานเริ่มต้นสำหรับการอัปเดต
Untracเอนทิตี ked	ไม่ได้ตรวจสอบ; ดึงข้อมูลด้วย `.AsNoTracking()`.	เหมาะสำหรับการอ่านข้อมูลอย่างเดียว

Tracเอนทิตี ked ใช้หน่วยความจำมากกว่า แต่ช่วยให้ EF ตรวจจับการเปลี่ยนแปลงได้โดยอัตโนมัติ

Untracหน่วยงาน ked ช่วยเพิ่มประสิทธิภาพ การปฏิบัติ ในสถานการณ์ที่มีการอ่านข้อมูลสูงและมีการอัปเดตข้อมูลต่ำ

20) คุณสามารถเรียกใช้คำสั่ง SQL ดิบใน Entity Framework ได้อย่างไร?

Entity Framework อนุญาตให้เรียกใช้คำสั่ง SQL ดิบสำหรับคำสั่งค้นหาแบบกำหนดเองหรือคำสั่งค้นหาที่ต้องการประสิทธิภาพสูง

var result = context.Products
    .FromSqlRaw("SELECT * FROM Products WHERE Price > 100")
    .ToList();

สำหรับคำสั่งที่ไม่ใช่การสอบถามข้อมูล:

context.Database.ExecuteSqlRaw("DELETE FROM Products WHERE Discontinued = 1");

โปรดใช้ฟังก์ชันนี้อย่างระมัดระวังเพื่อหลีกเลี่ยงปัญหา การแทรก SQL และรักษาความยืดหยุ่นที่ไม่ขึ้นกับฐานข้อมูลใดๆ

21) Entity Framework และ Entity Framework Core แตกต่างกันอย่างไร?

Entity Framework (EF) และ Entity Framework Core (EF Core) มีความแตกต่างกันในด้านสถาปัตยกรรม ความสามารถ และการรองรับหลายแพลตฟอร์ม

ลักษณะ	เอนทิตี้เฟรมเวิร์ก 6 (EF6)	เอนทิตีเฟรมเวิร์กคอร์
แพลตฟอร์ม	เฉพาะ .NET Framework เท่านั้น	รองรับหลายแพลตฟอร์ม (.NET 5/6/7)
Archiเทคเจอร์	อ้างอิงจาก ObjectContext	น้ำหนักเบาและปรับเปลี่ยนได้
ประสิทธิภาพ	การค้นหาบางรายการทำงานช้าลง	การสร้างคำค้นหาที่ได้รับการปรับให้เหมาะสม
การสนับสนุน LINQ	เป็นผู้ใหญ่แล้วแต่ยังมีข้อจำกัด	ปรับปรุงการแปลและการทำงานแบบอะซิงโครนัส
ผู้ให้บริการฐานข้อมูล	เซิร์ฟเวอร์ SQL, Oracle	หลายรายการ (MySQL, PostgreSQL, SQLiteฯลฯ )
คุณสมบัติ	สมบูรณ์ (เช่น การโหลดแบบ Lazy Loading)	ทันสมัย (เช่น คุณสมบัติเงา ตัวกรองทั่วโลก)

EF Core คือ ทันสมัย พัฒนาอย่างต่อเนื่อง เวอร์ชันนี้เป็นตัวเลือกที่แนะนำสำหรับโปรเจ็กต์ .NET ใหม่ เนื่องจากมีความยืดหยุ่นและประสิทธิภาพสูง

22) การทำธุรกรรมใน Entity Framework ทำงานอย่างไร?

ธุรกรรมใน Entity Framework ช่วยให้มั่นใจได้ว่า ความสมบูรณ์ของข้อมูล เมื่อการดำเนินการหลายอย่างต้องสำเร็จหรือล้มเหลวพร้อมกัน โดยค่าเริ่มต้น EF จะทำการห่อหุ้ม SaveChanges() ภายในธุรกรรม สำหรับการควบคุมด้วยตนเอง:

using (var transaction = context.Database.BeginTransaction())
{
    try
    {
        context.Customers.Add(new Customer());
        context.SaveChanges();

        context.Orders.Add(new Order());
        context.SaveChanges();

        transaction.Commit();
    }
    catch
    {
        transaction.Rollback();
    }
}

วิธีนี้ช่วยให้มั่นใจได้ว่าการเปลี่ยนแปลงทั้งหมดเป็นไปอย่างสมบูรณ์ หากคำสั่งใดล้มเหลว การเปลี่ยนแปลงทั้งหมดจะถูกยกเลิก

EF ยังผสานรวมกับ ธุรกรรมระบบ เพื่อรองรับการทำธุรกรรมแบบกระจายศูนย์

23) อธิบายกลยุทธ์การสืบทอดแบบ TPH, TPT และ TPC ใน Entity Framework

Entity Framework รองรับแผนผังการสืบทอดหลักสามแบบping กลยุทธ์สำหรับการสร้างแบบจำลองลำดับชั้นของคลาส

กลยุทธ์	Descriptไอออน	ตัวอย่าง	ข้อดี	ข้อเสีย
TPH (ตารางต่อลำดับชั้น)	ทุกคลาสใช้ตารางเดียวกัน โดยมีคอลัมน์ตัวแยกประเภทเพื่อระบุชนิดของคลาส	พบได้ทั่วไปใน EF Core	การค้นหาข้อมูลทำได้ง่ายและรวดเร็ว	ตารางอาจมีขนาดใหญ่และมีข้อมูลกระจัดกระจาย
TPT (ตารางต่อประเภท)	แต่ละคลาสย่อยจะมีตารางของตัวเอง	แต่ละคลาสที่ได้มาจะทำการแมปแยกกัน	โครงสร้างข้อมูลแบบมาตรฐาน	การเชื่อมข้อมูลในลำดับชั้นขนาดใหญ่จะช้าลง
TPC (ตารางต่อประเภทคอนกรีต)	แต่ละคลาสจะมีตารางของตัวเองซึ่งมีคอลัมน์ซ้ำกัน	แต่ละเอนทิตีจะถูกแมปแยกกัน	การอ่านที่มีประสิทธิภาพสูง	การสำรองข้อมูล.

นักพัฒนาส่วนใหญ่ชอบแบบนั้น TPH เนื่องจากความเรียบง่าย เว้นแต่ความต้องการด้านการปรับมาตรฐานหรือประสิทธิภาพจะกำหนดเป็นอย่างอื่น

24) คุณจัดการการปรับแต่งประสิทธิภาพใน Entity Framework อย่างไร?

เพื่อเพิ่มประสิทธิภาพการทำงานของ Entity Framework:

ใช้ AsNoTracking() สำหรับคำสั่งค้นหาแบบอ่านอย่างเดียว
โหลดที่กระตือรือร้น เฉพาะหน่วยงานที่เกี่ยวข้องที่จำเป็นเท่านั้น .Include().
หลีกเลี่ยงการสืบค้น N+1 โดยใช้การฉายภาพหรือ Select().
ใช้คิวรีที่คอมไพล์แล้ว สำหรับการดำเนินการที่ดำเนินการบ่อยครั้ง
แทรก/อัปเดตข้อมูลหลายรายการพร้อมกัน สีสดสวย AddRange() และ SaveChanges().
ปิดใช้งานการตรวจจับการเปลี่ยนแปลงอัตโนมัติ สำหรับการดำเนินการจำนวนมาก: context.Configuration.AutoDetectChangesEnabled = false;
ใช้การแคชและการแบ่งหน้า สำหรับชุดข้อมูลขนาดใหญ่

การใช้งาน EF ที่ได้รับการปรับแต่งอย่างดีสามารถทำให้ประสิทธิภาพใกล้เคียงกับ ADO.NET ในขณะที่ยังคงรักษาประสิทธิภาพการทำงานของนักพัฒนาไว้ได้

25) Shadow property ใน Entity Framework Core คืออะไร?

A คุณสมบัติเงา มีอยู่ในโมเดล EF แต่ไม่มีอยู่ในคลาสเอนทิตี EF จะดูแลรักษาข้อมูลนี้ในส่วนการเปลี่ยนแปลง tracker และจัดเก็บไว้ในฐานข้อมูล

ตัวอย่าง:

modelBuilder.Entity<Order>()
    .Property<DateTime>("LastUpdated");

วิธีนี้ช่วยให้ EF สามารถจัดเก็บข้อมูลเมตาเพิ่มเติม (เช่น การประทับเวลา ข้อมูลการตรวจสอบ) โดยไม่ต้องแก้ไขคลาสเอนทิตี

คุณสามารถเข้าถึงคุณสมบัติเงาได้ผ่านทาง:

var value = context.Entry(order).Property("LastUpdated").CurrentValue;

คุณสมบัติแบบ Shadow เหมาะอย่างยิ่งสำหรับการบันทึกข้อมูลหรือการตรวจสอบต่างๆ

26) ตัวแปลงค่าใน EF Core คืออะไร?

ตัวแปลงค่าใน EF Core ช่วยให้สามารถแปลงค่าของคุณสมบัติเมื่ออ่านหรือเขียนข้อมูลลงในฐานข้อมูลได้

ตัวอย่างเช่น การจัดเก็บค่า enum ในรูปแบบสตริง:

modelBuilder.Entity<Employee>()
    .Property(e => e.Status)
    .HasConversion(
        v => v.ToString(),
        v => (EmployeeStatus)Enum.Parse(typeof(EmployeeStatus), v));

สิ่งนี้ช่วยเพิ่มความยืดหยุ่นสำหรับประเภทข้อมูลแบบกำหนดเอง เช่น enum, boolหรือ DateTimeOffset.

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

27) ตัวกรองการค้นหาทั่วโลกคืออะไร และทำงานอย่างไร?

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

นี้เป็นประโยชน์อย่างยิ่งสำหรับ การลบแบบนุ่มนวล or หลายผู้เช่า.

ตัวอย่าง:

modelBuilder.Entity<Employee>()
    .HasQueryFilter(e => !e.IsDeleted);

ทุกคำสั่งค้นหาที่ดำเนินการกับ Employee ระบบจะยกเว้นระเบียนที่ถูกลบแบบชั่วคราวโดยอัตโนมัติ เว้นแต่จะมีการกำหนดค่าเปลี่ยนแปลงอย่างชัดเจน

ตัวกรองทั่วโลกช่วยเพิ่มประสิทธิภาพในการบำรุงรักษาและความปลอดภัยของข้อมูล

28) คุณสามารถทดสอบโค้ด Entity Framework โดยใช้ Unit Test ได้อย่างไร?

หากต้องการทดสอบหน่วยของตรรกะ EF โดยไม่ต้องเข้าถึงฐานข้อมูลจริง ให้ใช้ ฐานข้อมูลในหน่วยความจำ or ซึ่งจำลอง:

ตัวเลือกที่ 1: ผู้ให้บริการหน่วยความจำภายใน
```
var options = new DbContextOptionsBuilder<AppDbContext>()
    .UseInMemoryDatabase("TestDb")
    .Options;
```
ตัวเลือกที่ 2: จำลอง DbContext
เยาะเย้ย DbSet โดยใช้ไลบรารีต่างๆ เช่น ขั้นต่ำ สำหรับการทดสอบแบบแยกส่วน

การทดสอบหน่วยควรตรวจสอบความถูกต้องของสิ่งต่อไปนี้:

ความถูกต้องของคำสั่งค้นหา (ผ่าน LINQ)
ความสอดคล้องของข้อมูลหลังจาก SaveChanges()
ตรรกะของที่เก็บข้อมูล

การทดสอบด้วย EF Core InMemory ช่วยให้มั่นใจได้ถึงความเร็วและหลีกเลี่ยงการพึ่งพา SQL Server

29) อธิบายรูปแบบ Repository และ Unit of Work ใน EF

รูปแบบสถาปัตยกรรมทั้งสองนี้ช่วย เอบีเอสtracการเข้าถึงข้อมูล t และ รักษาความสม่ำเสมอในการทำธุรกรรม.

แบบแผน	จุดมุ่งหมาย	ตัวอย่างการใช้งาน
กรุ	รวบรวมการดำเนินการ CRUD สำหรับแต่ละเอนทิตีไว้ด้วยกัน	`IRepository<T>` เชื่อมต่อกับ `Add()`, `GetAll()`ฯลฯ
หน่วยงาน	ประสานงานที่เก็บข้อมูลหลายแห่งภายในธุรกรรมเดียว	`SaveChanges()` ทำหน้าที่เป็นขอบเขตการยืนยันการเปลี่ยนแปลง

ตัวอย่าง:

public class UnitOfWork : IUnitOfWork
{
    private readonly AppDbContext _context;
    public void Commit() => _context.SaveChanges();
}

รูปแบบเหล่านี้ปรับปรุง ความสามารถในการทดสอบ, การนำโค้ดกลับมาใช้ใหม่และ แยกความกังวล ในแอปพลิเคชันระดับองค์กรขนาดใหญ่

30) การโหลดแบบเร่งด่วน (eager loading) และการโหลดแบบฉายภาพ (projection loading) แตกต่างกันอย่างไร?

แง่มุม	กำลังโหลดอย่างกระตือรือร้น	กำลังโหลดโปรเจกต์
จุดมุ่งหมาย	โหลดข้อมูลที่เกี่ยวข้องล่วงหน้า	โหลดเฉพาะฟิลด์หรือคุณสมบัติที่ระบุเท่านั้น
วิธี	`.Include()`	`.Select()`
ตัวอย่าง	`context.Orders.Include(o => o.Customer)`	`context.Orders.Select(o => new { o.Id, o.Customer.Name })`
ประสิทธิภาพ	ดึงข้อมูลวัตถุทั้งหมด	ดึงข้อมูลขั้นต่ำ
ใช้กรณี	เมื่อจำเป็นต้องใช้เอนทิตีที่เกี่ยวข้องในการประมวลผล	เมื่อคุณต้องการข้อมูลขนาดเล็กที่เฉพาะเจาะจง

การโหลดแบบโปรเจคชั่นคือ การเพิ่มประสิทธิภาพ ซึ่งช่วยลดการใช้หน่วยความจำโดยการเลือกเฉพาะคอลัมน์ที่จำเป็นเท่านั้น

31) Interceptor ใน Entity Framework Core คืออะไร?

Interceptor ใน EF Core ช่วยให้นักพัฒนาสามารถดักจับและแก้ไขการทำงานของฐานข้อมูลได้ เช่น การเรียกใช้คิวรี การสร้างคำสั่ง และการเปิดการเชื่อมต่อ.

ส่วนประกอบเหล่านี้ทำหน้าที่เป็นตัวกลางระหว่าง EF และผู้ให้บริการฐานข้อมูล

ตัวอย่าง: บันทึกคำสั่ง SQL ทั้งหมดที่ถูกดำเนินการ

public class CommandInterceptor : DbCommandInterceptor
{
    public override void ReaderExecuting(
        DbCommand command,
        CommandEventData eventData,
        InterceptionResult<DbDataReader> result)
    {
        Console.WriteLine($"Executing SQL: {command.CommandText}");
        base.ReaderExecuting(command, eventData, result);
    }
}

คุณลงทะเบียนมันในระบบ DbContextOptionsBuilder:

optionsBuilder.AddInterceptors(new CommandInterceptor());

ประโยชน์ที่ได้รับ:

การบันทึกข้อมูลขั้นสูง
ความปลอดภัย (การตรวจสอบความถูกต้องของคำค้นหา)
การตรวจสอบและการประเมินผล tracกษัตริย์

32) EF Core จัดการกับการทำงานแบบอะซิงโครนัสอย่างไร?

Entity Framework Core รองรับอย่างเต็มที่ การเขียนโปรแกรมแบบอะซิงโครนัส ด้วยวิธีการต่างๆเช่น SaveChangesAsync(), ToListAsync()และ FirstOrDefaultAsync().

การดำเนินการแบบอะซิงโครนัสช่วยให้ ปรับปรุงความสามารถในการขยายขนาด ในแอปพลิเคชันเว็บ โดยการปล่อยเธรดขณะรอการดำเนินการฐานข้อมูลที่เกี่ยวข้องกับ I/O

ตัวอย่าง:

var customers = await context.Customers
    .Where(c => c.IsActive)
    .ToListAsync();

การทำงานแบบอะซิงโครนัสมีประสิทธิภาพเป็นพิเศษในการจัดการกับปริมาณงานสูง ASP.NET Core API และไมโครเซอร์วิส ซึ่งช่วยลดการเรียกใช้งานที่ทำให้เกิดการติดขัด และปรับปรุงเวลาตอบสนองให้ดียิ่งขึ้น

33) ความยืดหยุ่นในการเชื่อมต่อใน Entity Framework Core คืออะไร?

ความยืดหยุ่นในการเชื่อมต่อช่วยให้แอปพลิเคชันของคุณทำงานได้ดียิ่งขึ้น กู้คืนโดยอัตโนมัติจากความล้มเหลวชั่วคราวของฐานข้อมูลเช่น การขัดข้องของเครือข่าย หรือการหมดเวลาของ SQL

สามารถตั้งค่าได้ดังนี้:

optionsBuilder.UseSqlServer(
    connectionString,
    options => options.EnableRetryOnFailure(5, TimeSpan.FromSeconds(10), null)
);

ในกรณีนี้ EF จะลองดำเนินการที่ล้มเหลวซ้ำสูงสุด 5 ครั้ง โดยจะมีช่วงเวลาหน่วง

สิ่งนี้มีประโยชน์อย่างยิ่งใน สภาพแวดล้อมที่โฮสต์บนคลาวด์ กดไลก์ Azure SQL ที่มักเกิดข้อผิดพลาดชั่วคราวบ่อยครั้ง

34) ใน EF Core มีเอนทิตีประเภทใดบ้างที่เป็นเจ้าของ?

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

พวกมันใช้โต๊ะเดียวกันกับเจ้าของ และไม่สามารถอยู่ได้อย่างอิสระ

ตัวอย่าง:

public class Address
{
    public string Street { get; set; }
    public string City { get; set; }
}
public class Customer
{
    public int Id { get; set; }
    public Address Address { get; set; }
}

การกำหนดค่า:

modelBuilder.Entity<Customer>().OwnsOne(c => c.Address);

ใช้กรณี:

แนวคิดการสร้างแบบจำลอง เช่น ที่อยู่ , เงินหรือ การวัด ที่ไม่มีเอกลักษณ์เป็นของตัวเอง

35) คุณจะนำการลบแบบซอฟต์มาใช้ใน Entity Framework Core ได้อย่างไร?

การลบแบบซอฟต์ (Soft delete) จะทำเครื่องหมายว่าข้อมูลถูกลบแล้ว แทนที่จะลบข้อมูลนั้นออกไปจริงๆ

มีการนำไปใช้โดยใช้ ธงบูลีน และ ตัวกรองการค้นหาทั่วโลก.

modelBuilder.Entity<Employee>()
    .HasQueryFilter(e => !e.IsDeleted);

ในขั้นตอนการลบ:

employee.IsDeleted = true;
context.Update(employee);
context.SaveChanges();

ข้อดี:

การเก็บรักษาข้อมูลทางประวัติศาสตร์
การกู้คืนที่ง่ายขึ้น

ข้อเสีย:

ตารางฐานข้อมูลขนาดใหญ่ขึ้น
ต้องใช้ตรรกะการกรองอย่างระมัดระวัง

36) โมเดลที่คอมไพล์แล้วใน EF Core คืออะไร และใช้เพื่ออะไร?

ใน EF Core 6+ โมเดลที่รวบรวม อนุญาตให้คอมไพล์ข้อมูลเมตาของโมเดล EF ล่วงหน้าเป็นแอสเซมบลี .NET ซึ่งช่วยลดเวลาเริ่มต้นและค่าใช้จ่ายในการรันไทม์

ขั้นตอน:

เรียกใช้คำสั่ง: dotnet ef dbcontext optimize
EF สร้างไฟล์โมเดลที่คอมไพล์ล่วงหน้า ซึ่งช่วยให้แอปพลิเคชันโหลดได้เร็วขึ้นในระหว่างการทำงาน

ประโยชน์: ช่วยลดเวลาในการเริ่มต้นระบบลง 30–40% โดยเฉพาะในแอปพลิเคชันขนาดใหญ่ที่มีเอนทิตีจำนวนมาก

ใช้กรณี: ไมโครเซอร์วิสประสิทธิภาพสูงและสภาพแวดล้อมแบบไร้เซิร์ฟเวอร์

37) คุณสามารถนำการแคชมาใช้ใน Entity Framework ได้อย่างไร?

การแคชช่วยลดการเรียกใช้ฐานข้อมูลซ้ำๆ โดยมีสองระดับหลักๆ ดังนี้:

ประเภท	Descriptไอออน	ตัวอย่าง
แคชระดับแรก	ติดตั้งในตัว ต่อ `DbContext` ตัวอย่าง	จัดการโดยอัตโนมัติ
แคชระดับที่สอง	แคชภายนอกที่ใช้ร่วมกันระหว่างบริบทต่างๆ	ใช้ไลบรารีเช่น `EFCoreSecondLevelCacheInterceptor`

ตัวอย่างการแคชระดับที่สอง:

services.AddEFSecondLevelCache(options =>
{
    options.UseMemoryCacheProvider().DisableLogging(false);
});

สิ่งนี้ช่วยปรับปรุงประสิทธิภาพได้อย่างมากใน แอปพลิเคชันที่เน้นการอ่านข้อมูลจำนวนมาก โดยหลีกเลี่ยงการเรียกใช้ฐานข้อมูลซ้ำซ้อน

38) EF Core จัดการโทเค็นการทำงานพร้อมกันและเวลาประทับอย่างไร?

โทเค็นการทำงานพร้อมกันป้องกัน การอัปเดตที่ขัดแย้งกัน ในสภาพแวดล้อมที่มีผู้ใช้งานหลายคน

คุณสามารถกำหนดคุณสมบัติให้เป็นโทเค็นการทำงานพร้อมกันได้โดยใช้ [ConcurrencyCheck] or [Timestamp] คุณลักษณะ

ตัวอย่าง:

public class Product
{
    public int Id { get; set; }

    [Timestamp]
    public byte[] RowVersion { get; set; }
}

เมื่อมีการอัปเดตเกิดขึ้น EF จะรวมคอลัมน์นี้ไว้ในการอัปเดตด้วย WHERE ประโยค

หากค่าไม่ตรงกัน จะเกิดเหตุการณ์ขึ้น DbUpdateConcurrencyException ถูกโยนออกไป — เพื่อให้แน่ใจว่า การควบคุมภาวะพร้อมกันในแง่ดี.

39) คุณดำเนินการตรวจสอบ (การสร้าง การแก้ไข การลบ) อย่างไร trac(king) ใน EF Core?

การตรวจสอบบัญชี tracเมตาเดต้า ks เช่น ใครเป็นผู้สร้าง แก้ไข หรือลบข้อมูล ประวัติ

คุณสามารถแทนที่ SaveChanges():

public override int SaveChanges()
{
    var entries = ChangeTracker.Entries()
        .Where(e => e.Entity is IAuditable && 
                   (e.State == EntityState.Added || e.State == EntityState.Modified));

    foreach (var entry in entries)
    {
        var auditable = (IAuditable)entry.Entity;
        auditable.LastModified = DateTime.UtcNow;
    }

    return base.SaveChanges();
}

Interface:

public interface IAuditable
{
    DateTime Created { get; set; }
    DateTime LastModified { get; set; }
}

วิธีการนี้จะรวมศูนย์ตรรกะการตรวจสอบ เพื่อให้มั่นใจได้ว่า การกำกับดูแลข้อมูลอย่างสม่ำเสมอ.

40) แนวทางปฏิบัติที่ดีที่สุดสำหรับการใช้ Entity Framework ในแอปพลิเคชันระดับองค์กรมีอะไรบ้าง?

Category	ปฏิบัติที่ดีที่สุด	ประโยชน์
ประสิทธิภาพ	ใช้ `AsNoTracking()` และการคาดการณ์สำหรับแบบสอบถามแบบอ่านอย่างเดียว	ช่วยลดค่าใช้จ่ายในการดำเนินงาน
ออกแบบ	นำรูปแบบ Repository และ Unit of Work มาใช้	ช่วยให้การบำรุงรักษาทำได้ง่ายขึ้น
⁠ความปลอดภัย	ใช้คำสั่ง SQL แบบกำหนดพารามิเตอร์เพื่อหลีกเลี่ยงการโจมตีแบบ SQL injection	การป้องกันข้อมูล.
scalability	ใช้การจัดการกลุ่มการเชื่อมต่อและวิธีการแบบอะซิงโครนัส	รองรับน้ำหนักบรรทุกสูงได้
การย้ายถิ่น	ใช้การย้ายข้อมูลอัตโนมัติร่วมกับการควบคุมเวอร์ชัน	ช่วยให้การจัดการสคีมาง่ายขึ้น
องค์ประกอบ	แยกสตริงการเชื่อมต่อและรหัสลับออกสู่ภายนอก	การแยกสภาพแวดล้อมที่ดีขึ้น
การทดสอบ	ใช้ InMemory provider สำหรับการทดสอบหน่วย (unit test)	การทดสอบทำได้เร็วขึ้น
เข้าสู่ระบบ	เปิดใช้งานการบันทึกข้อมูล EF เพื่อรับข้อมูลเชิงลึกด้านประสิทธิภาพ	การแก้ไขข้อผิดพลาดทำได้ง่ายขึ้น

แนวปฏิบัติเหล่านี้ช่วยให้มั่นใจได้ว่า แข็งแกร่ง ปรับขนาดได้ และบำรุงรักษาได้ง่าย แอปพลิเคชันที่สร้างขึ้นบน Entity Framework

41) คุณจะปรับปรุงประสิทธิภาพของคิวรี LINQ เพื่อการแปลงเป็น SQL ที่ดีขึ้นใน Entity Framework ได้อย่างไร?

Entity Framework จะแปลงคำสั่ง LINQ เป็น SQL โดยอัตโนมัติ แต่รูปแบบที่ไม่เหมาะสมอาจทำให้ SQL ทำงานช้าหรือซ้ำซ้อน การเพิ่มประสิทธิภาพ LINQ จะช่วยให้ ORM สร้างคำสั่งค้นหาฐานข้อมูลที่มีประสิทธิภาพ

เทคนิคการเพิ่มประสิทธิภาพ:

ใช้การฉายภาพ:

เลือกเฉพาะคอลัมน์ที่ต้องการแทนที่จะเลือกข้อมูลทั้งหมด

var customers = context.Customers
    .Select(c => new { c.Id, c.Name })
    .ToList();

หลีกเลี่ยงการประเมินจากฝั่งลูกค้า:
ตรวจสอบให้แน่ใจว่ามีการกรองข้อมูลอยู่เสมอ ใน SQLไม่อยู่ในหน่วยความจำ EF Core จะแจ้งเตือนเมื่อการประเมินผลเกิดขึ้นฝั่งไคลเอ็นต์
ใช้ AsNoTracking() สำหรับข้อมูลที่อ่านอย่างเดียว

var orders = context.Orders.AsNoTracking().ToList();

ใช้ประโยชน์จากคิวรีที่คอมไพล์แล้ว สำหรับการดำเนินการ LINQ ซ้ำๆ
หลีกเลี่ยงสิ่งที่ไม่จำเป็น .Include() โทร — ใส่ข้อมูลที่เกี่ยวข้องเฉพาะเมื่อจำเป็นเท่านั้น

ตัวอย่าง:

ไม่มีประสิทธิภาพ:

context.Customers.ToList().Where(c => c.IsActive);

ที่มีประสิทธิภาพ:

context.Customers.Where(c => c.IsActive).ToList();

42) มีวิธีการใดบ้างในการใส่ข้อมูลเริ่มต้นลงใน EF Core?

การใส่ข้อมูลเริ่มต้นช่วยให้มั่นใจได้ว่าฐานข้อมูลมีข้อมูลครบถ้วน ค่าเริ่มต้นหรือข้อมูลอ้างอิง เมื่อสร้างขึ้น

แนวทางที่ 1: การใช้ ModelBuilder

modelBuilder.Entity<Role>().HasData(
    new Role { Id = 1, Name = "Admin" },
    new Role { Id = 2, Name = "User" }
);

ข้อมูลจะถูกแทรกโดยอัตโนมัติระหว่างนี้ Update-Database.

แนวทางที่ 2: วิธีการกำหนดเมล็ดพันธุ์เอง

เรียกใช้โค้ดด้วยตนเองเมื่อเริ่มต้นระบบ:

context.Database.Migrate();
if (!context.Users.Any())
{
    context.Users.Add(new User { Name = "Admin" });
    context.SaveChanges();
}

แนวทางที่ 3: สคริปต์ SQL

ใช้คำสั่ง SQL ดิบในการสร้างไฟล์ migration:

migrationBuilder.Sql("INSERT INTO Roles (Name) VALUES ('Admin')");

คำแนะนำ:
ใช้ HasData() สำหรับข้อมูลอ้างอิงแบบคงที่และการกำหนดค่าเริ่มต้นแบบโปรแกรมสำหรับข้อมูลเริ่มต้นแบบไดนามิก

43) EF Core จัดการผู้ให้บริการฐานข้อมูลภายในอย่างไร?

EF Core คือ ไม่ขึ้นกับผู้ให้บริการหมายความว่าสามารถกำหนดเป้าหมายไปยังเอ็นจิ้นฐานข้อมูลหลายตัวผ่านทางแยกต่างหากได้ แพ็กเกจผู้ให้บริการฐานข้อมูล.

ผู้ให้บริการทั่วไป:

ผู้ให้บริการ	NuGet แพ็คเกจ	ฐานข้อมูล
SQL Server	`Microsoft.EntityFrameworkCore.SqlServer`	MSSQL
SQLite	`Microsoft.EntityFrameworkCore.Sqlite`	อุปกรณ์เคลื่อนที่/เดสก์ท็อป
PostgreSQL	`Npgsql.EntityFrameworkCore.PostgreSQL`	PostgreSQL
MySQL	`Pomelo.EntityFrameworkCore.MySql`	MySQL
คอสมอส DB	`Microsoft.EntityFrameworkCore.Cosmos`	NoSQL

ภายในแล้ว EF Core ใช้ เอบีเอสtracชั้นการเรียงตัว สำหรับ:

การแปลแบบสอบถาม
การสร้างคำสั่ง SQL
แผนที่ประเภทข้อมูลping

ผู้ให้บริการแต่ละรายจะนำคลาสของตนเองมาใช้งาน โดยสืบทอดมาจากคลาสพื้นฐานของ EF Coretractions (เช่น RelationalDatabaseProvider, QuerySqlGenerator).

44) “การแยกคำสั่งค้นหา” คืออะไร และควรใช้เมื่อใด?

การแยกคำสั่ง SQL ป้องกันไม่ให้ EF ทำงานได้ รอยต่อขนาดใหญ่และซับซ้อน โดยการเรียกใช้คำสั่ง SQL หลายคำสั่งแทนที่จะเป็นคำสั่งเดียว

ตัวอย่าง:

var customers = context.Customers
    .Include(c => c.Orders)
    .AsSplitQuery()
    .ToList();

คำสั่งนี้จะดำเนินการ:

แบบสอบถามที่ 1 → ดึงข้อมูลลูกค้า
แบบสอบถามที่ 2 → ดึงข้อมูลคำสั่งซื้อที่เกี่ยวข้องกับลูกค้าเหล่านั้น

ประโยชน์ที่ได้รับ:

ป้องกันผลคูณคาร์ทีเซียนขนาดใหญ่
ช่วยเพิ่มประสิทธิภาพในการทำงานกับชุดข้อมูลขนาดใหญ่ที่เกี่ยวข้องกัน

ข้อเสียเปรียบ:

มีการเรียกเข้าและออกฐานข้อมูลหลายรอบ

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

45) คุณจะตรวจสอบคำสั่ง SQL ที่สร้างโดย EF ได้อย่างมีประสิทธิภาพได้อย่างไร?

การตรวจสอบ SQL ช่วยในการแก้ไขข้อผิดพลาดของคิวรีที่ทำงานช้า และเพิ่มประสิทธิภาพการทำงานของ ORM

วิธีการบันทึกข้อมูล SQL:

การบันทึกข้อมูลคอนโซล

optionsBuilder
    .UseSqlServer(conn)
    .LogTo(Console.WriteLine, LogLevel.Information);

การผสานรวม ILoggerFactory

var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole());
optionsBuilder.UseLoggerFactory(loggerFactory);

อินเตอร์เซปเตอร์ Implement DbCommandInterceptor เพื่อบันทึกคำสั่งและช่วงเวลาต่างๆ
เครื่องมือสร้างโปรไฟล์ ใช้เครื่องมือเช่น:

มินิโปรไฟล์
ตัวสร้างโปรไฟล์เซิร์ฟเวอร์ SQL
EFCorePowerTools

การบันทึกข้อมูลควรจะเป็น เปิดใช้งานแบบเลือกได้ ในขั้นตอนการผลิตเพื่อหลีกเลี่ยงภาระด้านประสิทธิภาพ

46) อะไรคือความแตกต่างระหว่าง การเปลี่ยนแปลงTracker.DetectChanges() และ AutoDetectChangesEnabled?

ลักษณะ	`DetectChanges()`	`AutoDetectChangesEnabled`
ประเภท	วิธี	อสังหาริมทรัพย์
จุดมุ่งหมาย	บังคับให้ EF สแกน tracเอนทิตีที่เข้ารหัสและตรวจจับการเปลี่ยนแปลง	เปิด/ปิดการตรวจจับการเปลี่ยนแปลงอัตโนมัติ
ค่าเริ่มต้น	ด้วยมือ	จริง
การใช้	เรียกร้องให้มีการปรับปรุงประสิทธิภาพอย่างชัดเจน	ปิดใช้งานสำหรับการอัปเดตจำนวนมาก

ตัวอย่าง:

context.ChangeTracker.AutoDetectChangesEnabled = false;
foreach (var item in list)
{
    context.Add(item);
}
context.SaveChanges();

การปิดใช้งานการตรวจจับอัตโนมัติในลูปจะช่วยเพิ่มประสิทธิภาพได้สูงสุดถึง 40% ในการดำเนินงานจำนวนมาก

47) คุณใช้ตารางเชิงเวลา (temporal tables) กับ EF Core อย่างไร?

ตารางชั่วคราว (Temporal tables) (ที่เปิดตัวใน SQL Server 2016) ช่วยให้คุณสามารถ tracข้อมูลทางประวัติศาสตร์ k อัตโนมัติ

ขั้นตอน:

เปิดใช้งานการสนับสนุนชั่วคราวในการย้ายข้อมูล:

builder.Entity<Employee>()
    .ToTable("Employees", b => b.IsTemporal());

สอบถามข้อมูลในอดีต:

var history = context.Employees
    .TemporalAsOf(DateTime.UtcNow.AddDays(-7))
    .ToList();

ข้อดี:

ประวัติข้อมูลในตัว tracกษัตริย์
การตรวจสอบและการปฏิบัติตามข้อกำหนด
ไม่ต้องใช้ตัวกระตุ้นแบบแมนนวล

EF Core 6+ รองรับการสืบค้นข้อมูลตามช่วงเวลาอย่างเต็มรูปแบบ

48) EF Core รองรับการใช้งานคิวรีที่คอมไพล์แล้วและโมเดลที่สร้างไว้ล่วงหน้าได้อย่างไร?

แบบสอบถามที่คอมไพล์แล้วและโมเดลที่คอมไพล์แล้วเป็นสองสิ่ง คุณสมบัติด้านประสิทธิภาพ ที่เสริมซึ่งกันและกัน

ลักษณะ	จุดมุ่งหมาย
แบบสอบถามที่รวบรวมไว้	ผลลัพธ์การแปลการค้นหาแคช
โมเดลที่รวบรวม	คอมไพล์ข้อมูลเมตาของโมเดลล่วงหน้า

ตัวอย่างของคำสั่งค้นหาที่คอมไพล์แล้ว:

static readonly Func<AppDbContext, int, Customer> _getCustomerById =
    EF.CompileQuery((AppDbContext ctx, int id) =>
        ctx.Customers.FirstOrDefault(c => c.Id == id));

การใช้งาน:

var customer = _getCustomerById(context, 5);

ด้วยกัน: แบบจำลองที่รวบรวมไว้จะลดขนาดลง ต้นทุนเริ่มต้นในขณะที่แบบสอบถามที่คอมไพล์แล้วจะลดลง ค่าใช้จ่ายในการสืบค้นข้อมูลขณะรันไทม์ — เหมาะสำหรับ คำถามที่มีความถี่สูง.

49) ข้อผิดพลาดที่พบบ่อยเมื่อใช้ EF ในสถาปัตยกรรมไมโครเซอร์วิสมีอะไรบ้าง?

ข้อผิดพลาดทั่วไป:

DbContext ที่ใช้ร่วมกันระหว่างบริการต่างๆ
→ ละเมิดหลักการแบ่งแยกไมโครเซอร์วิส
→ ไมโครเซอร์วิสแต่ละตัวควรมี DbContext และ Schema เป็นของตัวเอง
การสื่อสารแบบพูดคุย (คำถาม N+1)
→ ลดจำนวนการเรียกใช้ EF ต่อการเรียกใช้ API ให้เหลือน้อยที่สุด
การโหลดที่มากเกินไป
→ โหลดเฉพาะสิ่งที่จำเป็นผ่าน DTOs เท่านั้น
การย้ายข้อมูลแบบรวมศูนย์
→ แต่ละบริการควรจัดการการย้ายข้อมูลของตนเองอย่างอิสระ
การขาดขอบเขตในการทำธุรกรรม
→ ใช้ธุรกรรมแบบกระจาย (รูปแบบ Outbox) หากต้องการความสอดคล้องข้ามบริการ
การเชื่อมโยงอย่างแน่นหนากับผู้ให้บริการ SQL
→ ใช้ที่เก็บข้อมูล abstracเพื่อให้มีความยืดหยุ่นในการเลือกใช้ฐานข้อมูล

50) การฉีดการพึ่งพา (Dependency Injection) ทำงานร่วมกับ DbContext ใน ASP.NET Core อย่างไร?

Entity Framework ผสานรวมได้อย่างราบรื่นกับ ระบบ Dependency Injection (DI) ในตัวของ ASP.NET Core ระบบ

การติดตั้ง:

services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(Configuration.GetConnectionString("Default")));

จากนั้นจึงฉีดเข้าไปในคอนโทรลเลอร์หรือเซอร์วิส:

public class CustomerService
{
    private readonly AppDbContext _context;
    public CustomerService(AppDbContext context)
    {
        _context = context;
    }
}

อายุขัย:

ตลอดชีวิต	Descriptไอออน	แนะนำสำหรับ
ขอบเขต	หนึ่งบริบทต่อคำขอ HTTP	ค่าเริ่มต้น
ชั่วคราว	สร้างอินสแตนซ์ใหม่ทุกครั้ง	งานเบื้องหลัง
ซิงเกิล	แบ่งปันไปทั่วโลก	ควรหลีกเลี่ยง (ไม่ปลอดภัยสำหรับเธรด)

การใช้ DI ช่วยให้มั่นใจได้ว่า ความสามารถในการทดสอบ การจัดการวงจรชีวิตและ ทรัพยากรอย่างมีประสิทธิภาพ ครอบคลุมทั้งกระบวนการบนเว็บและกระบวนการเบื้องหลัง

🔍 คำถามสัมภาษณ์งานเกี่ยวกับ Entity Framework ยอดฮิต พร้อมสถานการณ์จริงและคำตอบเชิงกลยุทธ์

1) Entity Framework คืออะไร และเหตุใดจึงถูกนำไปใช้ในแอปพลิเคชันระดับองค์กร?

สิ่งที่คาดหวังจากผู้สมัคร: ผู้สัมภาษณ์ต้องการประเมินความเข้าใจพื้นฐานของคุณเกี่ยวกับ Entity Framework และคุณค่าของมันในการใช้งานจริง

ตัวอย่างคำตอบ: Entity Framework คือแผนที่เชิงวัตถุสัมพันธ์ (Object-Relational Map)ping เฟรมเวิร์กสำหรับ .NET ที่ช่วยให้นักพัฒนาสามารถทำงานกับฐานข้อมูลโดยใช้ .NET object แทนการใช้ SQL โดยตรง มีการใช้งานในแอปพลิเคชันระดับองค์กรเพื่อเพิ่มประสิทธิภาพการทำงาน ลดโค้ดการเข้าถึงข้อมูลที่ซ้ำซ้อน และรักษาการแยกส่วนการทำงานอย่างชัดเจน

2) คุณสามารถอธิบายความแตกต่างระหว่าง Code แนวทางแรกคือการใช้ฐานข้อมูลเป็นหลัก และแนวทางที่สองคือการใช้โมเดลเป็นหลัก?

สิ่งที่คาดหวังจากผู้สมัคร: ผู้สัมภาษณ์ต้องการประเมินความรู้ของคุณเกี่ยวกับขั้นตอนการทำงานด้านการพัฒนาซอฟต์แวร์ที่แตกต่างกัน และวิธีการใช้งานแต่ละขั้นตอน

ตัวอย่างคำตอบ: Code การสร้างฐานข้อมูลแบบแรกเริ่มจากคลาสโดเมนและสร้างฐานข้อมูลจากโค้ด การสร้างฐานข้อมูลแบบแรกเริ่มจากฐานข้อมูลที่มีอยู่แล้วและสร้างคลาสเอนทิตี ส่วนการสร้างแบบจำลองแบบแรกใช้เครื่องมือออกแบบภาพเพื่อกำหนดแบบจำลอง จากนั้นจึงสร้างทั้งโค้ดและฐานข้อมูล แต่ละวิธีจะถูกเลือกตามข้อกำหนดของโครงการและโครงสร้างพื้นฐานที่มีอยู่

3) Entity Framework จัดการความสัมพันธ์ระหว่างตารางอย่างไร?

สิ่งที่คาดหวังจากผู้สมัคร: ผู้สัมภาษณ์ต้องการตรวจสอบความเข้าใจของคุณเกี่ยวกับแบบจำลองข้อมูลและแผนที่ความสัมพันธ์ping.

ตัวอย่างคำตอบ: Entity Framework จัดการความสัมพันธ์โดยใช้คุณสมบัติการนำทางและคีย์ต่างประเทศ รองรับความสัมพันธ์แบบหนึ่งต่อหนึ่ง หนึ่งต่อหลาย และหลายต่อหลาย ทำให้ผู้พัฒนาสามารถเข้าถึงข้อมูลที่เกี่ยวข้องโดยใช้การอ้างอิงวัตถุแทนการเชื่อมต่อ (joins)

4) อธิบายสถานการณ์ที่คุณปรับปรุงประสิทธิภาพของฐานข้อมูลโดยใช้ Entity Framework

สิ่งที่คาดหวังจากผู้สมัคร: ผู้สัมภาษณ์ต้องการฟังตัวอย่างที่เป็นรูปธรรมที่แสดงให้เห็นถึงทักษะการเพิ่มประสิทธิภาพ

ตัวอย่างคำตอบ: ในบทบาทก่อนหน้านี้ ผมได้ปรับปรุงประสิทธิภาพโดยการลดการโหลดข้อมูลแบบเร่งด่วนที่ไม่จำเป็น และใช้คำสั่ง Select ในการสร้างคิวรีแบบ Projection ซึ่งช่วยลดปริมาณข้อมูลที่ดึงมาจากฐานข้อมูลและลดเวลาในการประมวลผลคิวรีได้อย่างมาก

5) คุณจัดการการย้ายข้อมูลใน Entity Framework อย่างไร?

สิ่งที่คาดหวังจากผู้สมัคร: ผู้สัมภาษณ์กำลังประเมินประสบการณ์ของคุณเกี่ยวกับการเปลี่ยนแปลงโครงสร้างข้อมูลและการควบคุมเวอร์ชัน

ตัวอย่างคำตอบ: การย้ายข้อมูลจะได้รับการจัดการโดยใช้เครื่องมือการย้ายข้อมูลในตัว tracโมเดล k เปลี่ยนแปลงไปตามเวลา ในตำแหน่งงานก่อนหน้านี้ ฉันสร้างและตรวจสอบสคริปต์การย้ายข้อมูลเป็นประจำก่อนนำไปใช้ เพื่อให้มั่นใจในความสมบูรณ์ของฐานข้อมูลในสภาพแวดล้อมต่างๆ

6) Lazy Loading คืออะไร และเมื่อใดที่คุณควรหลีกเลี่ยงการใช้งาน?

สิ่งที่คาดหวังจากผู้สมัคร: ผู้สัมภาษณ์ต้องการทดสอบความเข้าใจของคุณเกี่ยวกับกลยุทธ์การโหลดข้อมูลและการแลกเปลี่ยนประสิทธิภาพ

ตัวอย่างคำตอบ: การโหลดแบบ Lazy Loading จะโหลดข้อมูลที่เกี่ยวข้องโดยอัตโนมัติเมื่อมีการเรียกใช้งาน อย่างไรก็ตาม ควรหลีกเลี่ยงการใช้ในสถานการณ์หรือ API ที่ต้องการประสิทธิภาพสูง เพราะอาจทำให้เกิดการเรียกใช้ฐานข้อมูลโดยไม่ตั้งใจหลายครั้ง ซึ่งนำไปสู่ปัญหา N+1 ในการค้นหาข้อมูล

7) คุณจัดการธุรกรรมใน Entity Framework อย่างไร?

สิ่งที่คาดหวังจากผู้สมัคร: ผู้สัมภาษณ์กำลังประเมินความรู้ของคุณเกี่ยวกับความสอดคล้องของข้อมูลและการจัดการข้อผิดพลาด

ตัวอย่างคำตอบ: Entity Framework รองรับธุรกรรมผ่านทาง DbContext และ TransactionScope ในงานก่อนหน้านี้ ผมใช้ธุรกรรมแบบระบุชัดเจนเพื่อให้แน่ใจว่าการดำเนินการฐานข้อมูลที่เกี่ยวข้องกันหลายรายการจะเสร็จสมบูรณ์พร้อมกัน หรือถูกยกเลิกในกรณีที่เกิดความล้มเหลว

8) อธิบายวิธีการใช้งาน Dependency Injection ใน Entity Framework

สิ่งที่คาดหวังจากผู้สมัคร: ผู้สัมภาษณ์ต้องการดูว่าคุณเข้าใจสถาปัตยกรรมแอปพลิเคชันสมัยใหม่ได้ดีแค่ไหน

ตัวอย่างคำตอบ: Dependency injection ใช้สำหรับฉีด DbContext เข้าไปในเซอร์วิสหรือคอนโทรลเลอร์ ซึ่งช่วยเพิ่มความสามารถในการทดสอบและการบำรุงรักษาโดยอนุญาตให้จำลองหรือแทนที่ context ได้โดยไม่ต้องเปลี่ยนแปลงตรรกะทางธุรกิจ

9) อธิบายข้อผิดพลาดที่ท้าทายที่คุณพบเจอใน Entity Framework และวิธีการที่คุณแก้ไขข้อผิดพลาดนั้น

สิ่งที่คาดหวังจากผู้สมัคร: ผู้สัมภาษณ์มองหาความสามารถในการแก้ปัญหาและทักษะการดีบั๊ก

ตัวอย่างคำตอบ: ในบทบาทงานล่าสุดของฉัน ฉันประสบปัญหาเกี่ยวกับ... tracเกิดข้อขัดแย้งกับ King เมื่ออัปเดตเอนทิตีที่แยกออกมา ผมแก้ไขปัญหานี้โดยการกำหนดสถานะของเอนทิตีอย่างชัดเจน และตรวจสอบให้แน่ใจว่ามีเพียงอินสแตนซ์เดียวของแต่ละเอนทิตีเท่านั้น tracขึ้นอยู่กับบริบท

10) คุณตัดสินใจอย่างไรว่าเมื่อใดที่ Entity Framework ไม่ใช่เครื่องมือที่เหมาะสม?

สิ่งที่คาดหวังจากผู้สมัคร: ผู้สัมภาษณ์ต้องการเข้าใจวิจารณญาณและความสามารถของคุณในการเลือกใช้เทคโนโลยีที่เหมาะสม

ตัวอย่างคำตอบ: ฉันพิจารณาทางเลือกอื่นเมื่อแอปพลิเคชันต้องการการเข้าถึงข้อมูลที่มีประสิทธิภาพสูงมาก หรือตรรกะของ stored procedure ที่ซับซ้อน ในกรณีเช่นนี้ การใช้ micro-ORM หรือ ADO.NET แบบดั้งเดิมสามารถให้การควบคุมและประสิทธิภาพที่มากกว่า

คำถามและคำตอบสัมภาษณ์งานเกี่ยวกับ Entity Framework ที่ได้รับความนิยมสูงสุด

1) Entity Framework คืออะไร และใช้เพื่ออะไร?

3) DbContext คืออะไร และมีบทบาทอย่างไรใน EF?

4) การย้ายข้อมูล (Migration) ใน Entity Framework คืออะไร และใช้งานอย่างไร?

5) อธิบาย Lazy Loading, Eager Loading และ Explicit Loading

6) การเปลี่ยนแปลงคืออะไร tracราชาแห่ง Entity Framework?

7) Entity Framework จัดการกับข้อขัดแย้งในการทำงานพร้อมกันอย่างไร?

บทความที่เกี่ยวข้อง

8) คุณสมบัติการนำทางใน EF คืออะไร?

9) จุดประสงค์ของ AsNo คืออะไรTracกษัตริย์()?

10) คำสั่งค้นหาแบบคอมไพล์คืออะไร และควรใช้เมื่อใด?

11) สถานะของเอนทิตีใน Entity Framework คืออะไร และส่งผลต่อฟังก์ชัน SaveChanges() อย่างไร?

12) การใช้ Entity Framework มีข้อดีและข้อเสียอย่างไรบ้าง?

13) Entity Framework จัดการกับความสัมพันธ์ (หนึ่งต่อหนึ่ง หนึ่งต่อหลาย หลายต่อหลาย) อย่างไร?

14) LINQ to Entities และ LINQ to SQL แตกต่างกันอย่างไร?

15) ObjectContext และ DbContext แตกต่างกันอย่างไร?

16) อธิบายวงจรชีวิตของเอนทิตีใน Entity Framework

17) Fluent API มีประโยชน์อย่างไรใน Entity Framework?

18) Data Annotations ใน Entity Framework คืออะไร?

19) อะไรคือความแตกต่างระหว่าง tracเคดและอันtracเอนทิตี ked ใน EF Core?

20) คุณสามารถเรียกใช้คำสั่ง SQL ดิบใน Entity Framework ได้อย่างไร?

21) Entity Framework และ Entity Framework Core แตกต่างกันอย่างไร?

22) การทำธุรกรรมใน Entity Framework ทำงานอย่างไร?

23) อธิบายกลยุทธ์การสืบทอดแบบ TPH, TPT และ TPC ใน Entity Framework

24) คุณจัดการการปรับแต่งประสิทธิภาพใน Entity Framework อย่างไร?

25) Shadow property ใน Entity Framework Core คืออะไร?

26) ตัวแปลงค่าใน EF Core คืออะไร?

27) ตัวกรองการค้นหาทั่วโลกคืออะไร และทำงานอย่างไร?

28) คุณสามารถทดสอบโค้ด Entity Framework โดยใช้ Unit Test ได้อย่างไร?

29) อธิบายรูปแบบ Repository และ Unit of Work ใน EF

30) การโหลดแบบเร่งด่วน (eager loading) และการโหลดแบบฉายภาพ (projection loading) แตกต่างกันอย่างไร?

31) Interceptor ใน Entity Framework Core คืออะไร?

32) EF Core จัดการกับการทำงานแบบอะซิงโครนัสอย่างไร?

33) ความยืดหยุ่นในการเชื่อมต่อใน Entity Framework Core คืออะไร?

34) ใน EF Core มีเอนทิตีประเภทใดบ้างที่เป็นเจ้าของ?

35) คุณจะนำการลบแบบซอฟต์มาใช้ใน Entity Framework Core ได้อย่างไร?

36) โมเดลที่คอมไพล์แล้วใน EF Core คืออะไร และใช้เพื่ออะไร?

37) คุณสามารถนำการแคชมาใช้ใน Entity Framework ได้อย่างไร?

38) EF Core จัดการโทเค็นการทำงานพร้อมกันและเวลาประทับอย่างไร?

39) คุณดำเนินการตรวจสอบ (การสร้าง การแก้ไข การลบ) อย่างไร trac(king) ใน EF Core?

40) แนวทางปฏิบัติที่ดีที่สุดสำหรับการใช้ Entity Framework ในแอปพลิเคชันระดับองค์กรมีอะไรบ้าง?

41) คุณจะปรับปรุงประสิทธิภาพของคิวรี LINQ เพื่อการแปลงเป็น SQL ที่ดีขึ้นใน Entity Framework ได้อย่างไร?

เทคนิคการเพิ่มประสิทธิภาพ:

42) มีวิธีการใดบ้างในการใส่ข้อมูลเริ่มต้นลงใน EF Core?

43) EF Core จัดการผู้ให้บริการฐานข้อมูลภายในอย่างไร?

44) “การแยกคำสั่งค้นหา” คืออะไร และควรใช้เมื่อใด?

45) คุณจะตรวจสอบคำสั่ง SQL ที่สร้างโดย EF ได้อย่างมีประสิทธิภาพได้อย่างไร?

วิธีการบันทึกข้อมูล SQL:

46) อะไรคือความแตกต่างระหว่าง การเปลี่ยนแปลงTracker.DetectChanges() และ AutoDetectChangesEnabled?

47) คุณใช้ตารางเชิงเวลา (temporal tables) กับ EF Core อย่างไร?

48) EF Core รองรับการใช้งานคิวรีที่คอมไพล์แล้วและโมเดลที่สร้างไว้ล่วงหน้าได้อย่างไร?

49) ข้อผิดพลาดที่พบบ่อยเมื่อใช้ EF ในสถาปัตยกรรมไมโครเซอร์วิสมีอะไรบ้าง?

ข้อผิดพลาดทั่วไป:

50) การฉีดการพึ่งพา (Dependency Injection) ทำงานร่วมกับ DbContext ใน ASP.NET Core อย่างไร?

การติดตั้ง:

🔍 คำถามสัมภาษณ์งานเกี่ยวกับ Entity Framework ยอดฮิต พร้อมสถานการณ์จริงและคำตอบเชิงกลยุทธ์

1) Entity Framework คืออะไร และเหตุใดจึงถูกนำไปใช้ในแอปพลิเคชันระดับองค์กร?

3) Entity Framework จัดการความสัมพันธ์ระหว่างตารางอย่างไร?

4) อธิบายสถานการณ์ที่คุณปรับปรุงประสิทธิภาพของฐานข้อมูลโดยใช้ Entity Framework

5) คุณจัดการการย้ายข้อมูลใน Entity Framework อย่างไร?

6) Lazy Loading คืออะไร และเมื่อใดที่คุณควรหลีกเลี่ยงการใช้งาน?

7) คุณจัดการธุรกรรมใน Entity Framework อย่างไร?

8) อธิบายวิธีการใช้งาน Dependency Injection ใน Entity Framework

9) อธิบายข้อผิดพลาดที่ท้าทายที่คุณพบเจอใน Entity Framework และวิธีการที่คุณแก้ไขข้อผิดพลาดนั้น

10) คุณตัดสินใจอย่างไรว่าเมื่อใดที่ Entity Framework ไม่ใช่เครื่องมือที่เหมาะสม?

สรุปโพสต์นี้ด้วย:

ลงทะเบียนเพื่อรับจดหมายข่าว