คำถามและคำตอบสัมภาษณ์ .Net 40 อันดับแรก (2026)

โดย: จาค็อบลี จาค็อบลี
Hours วันที่อัพเดท

คำถามและคำตอบในการสัมภาษณ์ .Net

การเตรียมตัวสำหรับการสัมภาษณ์งานผ่าน .Net จำเป็นต้องมีความชัดเจนในสิ่งที่คุณอาจพบเจอ และการเข้าใจแนวคิดหลักถือเป็นสิ่งสำคัญ เนื่องจากประโยคที่สองต้องมี “คำถามสัมภาษณ์งานผ่าน .Net” เพื่อให้มีความเกี่ยวข้องทันที

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

👉 ดาวน์โหลด PDF ฟรี: คำถามและคำตอบสัมภาษณ์ .Net

1) .NET Framework คืออะไร และมีส่วนประกอบหลักอะไรบ้าง?

.NET Framework เป็นแพลตฟอร์มการพัฒนาซอฟต์แวร์ที่พัฒนาโดย Microsoft ซึ่งมอบสภาพแวดล้อมที่ควบคุมได้สำหรับการสร้าง การปรับใช้ และการรันแอปพลิเคชัน รองรับหลายภาษา เช่น C#, VB.NET และ F# เฟรมเวิร์กนี้รับประกันความสามารถในการทำงานร่วมกันของภาษาและการจัดการหน่วยความจำผ่าน Common Language Runtime (CLR)

ส่วนประกอบสำคัญ:

ตัวแทน Descriptไอออน
CLR (รันไทม์ภาษาทั่วไป) จัดการหน่วยความจำ ความปลอดภัย และการดำเนินการของโค้ด
FCL (ไลบรารีคลาสเฟรมเวิร์ก) คอลเลกชันขนาดใหญ่ของคลาส อินเทอร์เฟซ และประเภทค่าที่นำมาใช้ซ้ำได้
ASP.NET ช่วยให้สามารถพัฒนาแอปพลิเคชันเว็บแบบไดนามิก
ADO.NET ให้บริการการเข้าถึงข้อมูลจากแหล่งข้อมูลต่างๆ

ตัวอย่าง: แอปพลิเคชัน AC# สามารถใช้ ADO.NET เพื่อเชื่อมต่อกับฐานข้อมูล SQL Server ผ่านสภาพแวดล้อมที่ได้รับการจัดการ ช่วยให้มั่นใจถึงความปลอดภัยและความสามารถในการปรับขนาดได้

2) อธิบายความแตกต่างระหว่าง .NET Framework, .NET Core และ .NET 5/6/7

Microsoft ได้พัฒนา .NET ให้เป็นแพลตฟอร์มรวมเพื่อรองรับการพัฒนาข้ามแพลตฟอร์ม

NET Framework ที่ is Windows-เท่านั้น ในขณะที่ .NET Core เป็นโอเพ่นซอร์สและข้ามแพลตฟอร์ม จาก .NET5 เป็นต้นไป Microsoft รวมเข้าเป็นรันไทม์รวมหนึ่งเดียว

ลักษณะ NET Framework ที่ .NET Core .NET 5/6/7+
การสนับสนุนแพลตฟอร์ม Windows เพียง ข้ามแพลตฟอร์ม ข้ามแพลตฟอร์ม
โอเพนซอร์ส ไม่ ใช่ ใช่
ประสิทธิภาพ ปานกลาง จุดสูง สูงมาก
การใช้งาน ทั้งระบบ อยู่ในตัวเอง เรามีความยืดหยุ่น
ตัวอย่างการใช้งาน แอปองค์กรแบบเก่า คลาวด์และไมโครเซอร์วิส แอปพลิเคชันหลายแพลตฟอร์มที่ทันสมัย

3) Common Language Runtime (CLR) จัดการการทำงานของโค้ดอย่างไร

CLR ทำหน้าที่เป็นกลไกประมวลผลสำหรับแอปพลิเคชัน .NET โดยแปลงโค้ด Intermediate Language (IL) ให้เป็นโค้ดเครื่องเนทีฟผ่านการคอมไพล์แบบ Just-In-Time (JIT) นอกจากนี้ CLR ยังจัดการหน่วยความจำอัตโนมัติโดยใช้ Garbage Collection อีกด้วย

ฟังก์ชันหลักของ CLR:

  1. การจัดการหน่วยความจำ – จัดสรรและยกเลิกการจัดสรรหน่วยความจำโดยอัตโนมัติ
  2. การจัดการความปลอดภัย – ตรวจสอบความปลอดภัยในการเข้าถึงรหัสและความปลอดภัยตามบทบาท
  3. การจัดการข้อยกเว้น – ช่วยให้แน่ใจว่าข้อผิดพลาดรันไทม์ถูกจับและจัดการอย่างถูกต้อง
  4. การจัดการเธรด – ช่วยให้สามารถดำเนินการโค้ดมัลติเธรดได้อย่างมีประสิทธิภาพ

ตัวอย่าง: เมื่อโปรแกรม .NET ทำงาน CLR จะคอมไพล์โค้ด IL เป็นโค้ดเนทีฟตามความต้องการ เพื่อให้แน่ใจว่ามีการดำเนินการที่เหมาะสมที่สุด

4) คอมไพเลอร์ JIT ใน .NET มีกี่ประเภท?

CLR มีคอมไพเลอร์ Just-In-Time (JIT) สามประเภท:

ประเภท Descriptไอออน ใช้กรณี
พรี-JIT (NGen) คอมไพล์โค้ดทั้งหมดในครั้งเดียวเมื่อถึงเวลาปรับใช้ ลดระยะเวลาในการเริ่มต้นใช้งาน
อีโคโน-เจไอที คอมไพล์เฉพาะวิธีการที่เรียกในระหว่างการรันไทม์และลบทิ้งในภายหลัง สภาพแวดล้อมที่มีข้อจำกัดด้านหน่วยความจำ
JIT ปกติ รวบรวมโค้ดทีละวิธีในระหว่างการดำเนินการ รูปแบบการดำเนินการมาตรฐาน

แนวทาง JIT แต่ละวิธีมีความสมดุลระหว่าง การปฏิบัติ และ การใช้ทรัพยากร ขึ้นอยู่กับบริบทการปรับใช้

5) แอสเซมบลีใน .NET คืออะไร และแตกต่างจากเนมสเปซอย่างไร

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

การเปรียบเทียบ Assembly namespace
ธรรมชาติ ไฟล์ทางกายภาพ (DLL/EXE) การจัดกลุ่มตรรกะ
จุดมุ่งหมาย การปรับใช้และการกำหนดเวอร์ชัน การจัดระเบียบโค้ด
ประกอบด้วย เมตาดาต้า, แมนิเฟสต์, MSIL คลาส, อินเทอร์เฟซ
ตัวอย่าง System.Data.dll System.Data.SqlClient

ตัวอย่าง: System.Data.dll แอสเซมบลีสามารถมีเนมสเปซหลายรายการได้ เช่น System.Data และ System.Data.SqlClient.

6) ความแตกต่างระหว่างประเภทค่าและประเภทการอ้างอิงใน .NET คืออะไร

ใน .NET ประเภทค่า เก็บข้อมูลโดยตรงในขณะที่ ประเภทการอ้างอิง เก็บข้อมูลอ้างอิงไปยังที่อยู่หน่วยความจำของข้อมูล

ฐาน ประเภทค่า ประเภทอ้างอิง
พื้นที่จัดเก็บ กอง กอง
ประเภทตัวอย่าง int, float, bool, struct คลาส, อาร์เรย์, สตริง
การทำสำเนา คัดลอกค่าจริง คัดลอกข้อมูลอ้างอิง
อนุญาตเป็นค่าว่าง ไม่ ใช่

ตัวอย่าง:

int a = 5; int b = a; → ทั้งสองมีสำเนาแยกกัน

ClassObj x = new ClassObj(); ClassObj y = x; → ทั้งสองหมายถึงวัตถุเดียวกัน

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

7) การรวบรวมขยะทำงานอย่างไรใน .NET?

Garbage Collection (GC) ใน .NET จะจัดการหน่วยความจำโดยอัตโนมัติโดยการเรียกคืนวัตถุที่ไม่ได้ใช้งาน ซึ่งทำงานใน ชั่วอายุคน เพื่อเพิ่มประสิทธิภาพการทำงาน

GC ตามรุ่น:

  1. เจน 0: วัตถุที่มีอายุสั้น (เช่น ตัวแปรชั่วคราว)
  2. เจน 1: วัตถุที่มีอายุปานกลางได้รับการส่งเสริมจาก Gen 0
  3. เจน 2: วัตถุที่มีอายุยืนยาว (เช่น ข้อมูลคงที่)

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

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

ตัวอย่าง: เมื่อไม่มีการอ้างอิงวัตถุอีกต่อไป GC จะลบวัตถุนั้นออกจากฮีป ทำให้หน่วยความจำว่างเพื่อนำมาใช้ซ้ำได้

8) ผู้แทนคืออะไร และแตกต่างจากงานกิจกรรมอย่างไร

A ตัวแทน เป็นประเภทที่แสดงการอ้างอิงถึงวิธีการ ในขณะที่ เหตุการณ์ เป็นกลไกที่ทำให้สามารถสื่อสารระหว่างคลาสผ่านตัวแทนได้

แง่มุม ตัวแทน อีเว้นท์
คำนิยาม วัตถุที่ชี้ไปยังวิธีการ กลไกการแจ้งเตือน
การภาวนา สามารถโทรได้โดยตรง เรียกใช้ผ่านสมาชิก
ตัวอย่าง Action<int> myDelegate; event EventHandler myEvent;

ตัวอย่าง:

public delegate void Notify();  
public event Notify OnProcessCompleted;

ที่นี่ OnProcessCompleted เป็นเหตุการณ์ที่เกิดขึ้นตาม Notify ผู้แทน

9) ข้อดีและข้อเสียหลักๆ ของการใช้ .NET Core คืออะไร

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

ตัวอย่าง: .NET Core เหมาะอย่างยิ่งสำหรับการสร้างไมโครเซอร์วิสที่ทำงานบนคอนเทนเนอร์ Docker บน Linux และ Windows เซิร์ฟเวอร์

10) อธิบายวงจรชีวิตของหน้า ASP.NET

วงจรชีวิตของเพจ ASP.NET กำหนดวิธีการเริ่มต้น ประมวลผล และแสดงผลเพจ แต่ละขั้นตอนจะมีเหตุการณ์ที่นักพัฒนาสามารถจัดการเพื่อดำเนินการตามตรรกะที่กำหนดเอง

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

ตัวอย่าง: นักพัฒนามักใช้ Page_Load or Page_Init เหตุการณ์ที่จะเริ่มต้นการควบคุมหรือตั้งค่าการผูกข้อมูล

11) Entity Framework (EF) คืออะไร และช่วยลดความซับซ้อนของการดำเนินการฐานข้อมูลได้อย่างไร

Entity Framework (EF) คือ Microsoft's Object-Relational Mapper (ORM) ซึ่งช่วยลดความจำเป็นในการใช้โค้ดเข้าถึงข้อมูลส่วนใหญ่ โดยอนุญาตให้นักพัฒนาสามารถโต้ตอบกับฐานข้อมูลโดยใช้ .NET Objects จัดการการสร้าง SQL การแมปข้อมูล และการจัดการความสัมพันธ์โดยอัตโนมัติ

คุณสมบัติเด่น:

  • รองรับ LINQ-to-Entities คำสั่ง
  • เสนอ การติดตามการเปลี่ยนแปลงอัตโนมัติ และ ขี้เกียจโหลด.
  • ให้ โค้ดก่อน ฐานข้อมูลก่อนและ นางแบบเป็นอันดับแรก วิธีการ

ตัวอย่าง:

using (var context = new AppDbContext())
{
    var employees = context.Employees.Where(e => e.Salary > 50000).ToList();
}

ที่นี่ EF จะแปลแบบสอบถาม LINQ เป็น SQL ดึงผลลัพธ์ และแมปผลลัพธ์เหล่านั้น Employee วัตถุโดยอัตโนมัติ

12) อธิบายความแตกต่างระหว่างแนวทาง Code-First, Database-First และ Model-First ใน Entity Framework

เข้าใกล้ Descriptไอออน ใช้กรณี
โค้ด-เฟิร์ส กำหนดคลาสและให้ EF สร้างฐานข้อมูล โครงการกรีนฟิลด์
ฐานข้อมูล-ก่อน สร้างฐานข้อมูลก่อน จากนั้น EF จะสร้างคลาสเอนทิตี้ ฐานข้อมูลที่มีอยู่
นางแบบเป็นอันดับแรก ออกแบบเอนทิตีด้วยภาพ และ EF จะสร้างทั้ง DB และคลาส การออกแบบที่ขับเคลื่อนด้วยแผนภาพ

ตัวอย่าง: ในแนวทาง Code-First นักพัฒนาจะสร้างคลาส C# เช่น Customer และ Orderและ EF จะสร้างตารางที่สอดคล้องกันใน SQL Server โดยอัตโนมัติ

13) LINQ คืออะไร และมีข้อดีอะไรบ้างในการพัฒนา .NET?

แบบสอบถามแบบรวมภาษา (LINQ) ช่วยให้สามารถสอบถามข้อมูลจากแหล่งต่างๆ (อ็อบเจ็กต์, XML, ฐานข้อมูล) โดยใช้รูปแบบไวยากรณ์ที่สอดคล้องกันโดยตรงภายใน C# หรือ VB.NET

มันช่วยเพิ่ม การอ่าน, ความปลอดภัยประเภทและ การตรวจสอบเวลาคอมไพล์.

ข้อดีของ LINQ:

  1. รูปแบบไวยากรณ์รวมสำหรับแหล่งข้อมูลที่แตกต่างกัน
  2. ลดความซับซ้อนของโค้ด
  3. มอบ IntelliSense และการตรวจสอบเวลาคอมไพล์
  4. รองรับการดำเนินการที่เลื่อนออกไปเพื่อเพิ่มประสิทธิภาพการทำงาน

ตัวอย่าง:

var highSalaries = employees.Where(e => e.Salary > 70000)
                            .OrderBy(e => e.Name)
                            .ToList();

14) ความแตกต่างระหว่าง IEnumerable, ICollection และ IQueryable ใน .NET คืออะไร

อินเตอร์เฟซ ประเภทการดำเนินการ ใช้กรณี ความแตกต่างที่สำคัญ
IEnumerable การวนซ้ำในหน่วยความจำ คอลเลกชันท้องถิ่น ดำเนินการบนฝั่งไคลเอ็นต์
ไอคอลเล็คชั่น ในหน่วยความจำ รองรับการเพิ่ม/ลบ ปรับเปลี่ยนคอลเลกชัน ขยาย IEnumerable ด้วยการจัดการคอลเลกชัน
ฉันสามารถสอบถามได้ การดำเนินการที่เลื่อนออกไป (ระยะไกล) LINQ ถึง SQL/EF ดำเนินการที่ระดับฐานข้อมูล

ตัวอย่าง: การใช้ IQueryable ใน Entity Framework เปิดใช้งานการกรองด้านฐานข้อมูล ซึ่งมีประสิทธิภาพมากกว่าการใช้ IEnumerable ในความทรงจำ.

15) การเขียนโปรแกรมแบบอะซิงโครนัสคืออะไร และอะซิงโครนัสและอะรอทำงานอย่างไรใน .NET

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

คีย์ Concepts:

  • async ทำเครื่องหมายวิธีการเป็นแบบอะซิงโครนัส
  • await ระงับการดำเนินการวิธีการจนกว่างานที่รอจะเสร็จสิ้น
  • ป้องกันการขาดเธรดและการหยุดทำงานของ UI

ตัวอย่าง:

public async Task<int> GetDataAsync()
{
    var data = await httpClient.GetStringAsync("https://api.example.com");
    return data.Length;
}

ประโยชน์: เธรดหลักยังคงว่างอยู่เพื่อจัดการงานอื่นๆ ในขณะที่การดำเนินการ I/O ดำเนินการในเบื้องหลัง

16) Dependency Injection (DI) คืออะไร และเหตุใดจึงสำคัญใน .NET Core

Dependency Injection (DI) เป็นรูปแบบการออกแบบที่ช่วยให้ ข้อต่อหลวม ระหว่างคลาสโดยการฉีดการอ้างอิงแทนที่จะสร้างขึ้นภายใน

ข้อดี:

  • ปรับปรุงความสามารถในการทดสอบ
  • Promoการออกแบบโมดูลาร์
  • ทำให้การจัดการการกำหนดค่าง่ายขึ้น

ตัวอย่าง:

public class OrderService
{
    private readonly IEmailService _emailService;
    public OrderService(IEmailService emailService)
    {
        _emailService = emailService;
    }
}

ใน .NET Core DI ถูกสร้างขึ้นในกรอบงานผ่าน IServiceCollection ภาชนะที่ใช้ใน Startup.cs.

17) คุณจัดการข้อยกเว้นในแอปพลิเคชัน .NET ได้อย่างมีประสิทธิภาพอย่างไร

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

ตัวอย่าง:

try
{
    int result = 10 / divisor;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("Cannot divide by zero.");
}
finally
{
    Console.WriteLine("Operation completed.");
}

ปฏิบัติที่ดีที่สุด:

  • ควรจับข้อยกเว้นที่เฉพาะเจาะจงก่อนเสมอ
  • ใช้ finally สำหรับตรรกะการล้างข้อมูล
  • หลีกเลี่ยงการบล็อกจับที่ว่างเปล่า
  • ใช้การจัดการข้อยกเว้นทั่วโลกใน ASP.NET Core (UseExceptionHandler() มิดเดิลแวร์)

18) แนวทางปฏิบัติด้านความปลอดภัยที่สำคัญในแอปพลิเคชัน .NET มีอะไรบ้าง

⁠ความปลอดภัย ใน .NET ครอบคลุมหลายชั้น รวมถึงการตรวจสอบสิทธิ์ การอนุญาต การเข้ารหัสข้อมูล และการตรวจสอบอินพุต

แนวทางปฏิบัติที่สำคัญ:

  1. ใช้ เอกลักษณ์ ASP.NET สำหรับการตรวจสอบสิทธิ์และการจัดการบทบาท
  2. ทำให้สามารถ HTTPS (SSL/TLS) เพื่อการเข้ารหัสข้อมูล
  3. สมัครสมาชิก การตรวจสอบข้อมูลและแบบสอบถามแบบพารามิเตอร์ เพื่อป้องกันการแทรก SQL
  4. ใช้ API การปกป้องข้อมูล สำหรับการรักษาความปลอดภัยคุกกี้และโทเค็น
  5. Implement JWT (โทเค็นเว็บ JSON) สำหรับการตรวจสอบสิทธิ์แบบไร้สถานะใน API

ตัวอย่าง: การตรวจสอบสิทธิ์ตาม JWT มักใช้ในไมโครเซอร์วิสเพื่อตรวจสอบตัวตนของผู้ใช้โดยไม่ต้องรักษาสถานะเซสชัน

19) อธิบายความแตกต่างระหว่างคลาสแบบนามธรรมและอินเทอร์เฟซใน C#

ลักษณะ คลาสนามธรรม อินเตอร์เฟซ
การดำเนินงาน สามารถมีการนำวิธีการไปใช้งานได้ การประกาศเท่านั้น (C# 8 อนุญาตให้ใช้ค่าเริ่มต้น)
มรดกหลายรายการ ไม่ได้รับการสนับสนุน ที่สนับสนุน
ตัวสร้าง สามารถมี constructor ได้ ไม่สามารถมี constructor ได้
ใช้กรณี คลาสฐานที่มีโค้ดที่ใช้ร่วมกัน สัญญาสำหรับคลาสที่ไม่เกี่ยวข้องหลายคลาส

ตัวอย่าง:

abstract class Animal { public abstract void Speak(); }
interface IPet { void Play(); }

A Dog คลาสสามารถสืบทอดจาก Animal และนำไปใช้ IPet พร้อมกัน

20) รูปแบบการออกแบบที่ใช้กันทั่วไปใน .NET มีอะไรบ้าง และมีประโยชน์อะไรบ้าง?

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

ประเภทรูปแบบ ตัวอย่าง Descriptไอออน
สร้างสรรค์ ซิงเกิลตัน โรงงาน จัดการการสร้างวัตถุ
โครงสร้าง อะแดปเตอร์, เดคคอร์เรเตอร์ รวมคลาสหรืออ็อบเจ็กต์เข้าด้วยกัน
เกี่ยวกับพฤติกรรม ผู้สังเกตการณ์ กลยุทธ์ กำหนดการสื่อสารวัตถุ

ตัวอย่าง: ใน .NET Core ลายซิงเกิล มักใช้สำหรับบริการที่ใช้ร่วมกัน (เช่น การบันทึก) โดยการลงทะเบียนด้วย AddSingleton() ในการฉีดพึ่งพา

21) .NET MAUI คืออะไร และแตกต่างจาก Xamarin?

.NET MAUI (UI แอปหลายแพลตฟอร์ม) เป็นวิวัฒนาการของ Xamarin.แบบฟอร์ม ช่วยให้นักพัฒนาสามารถสร้าง แอปพลิเคชันข้ามแพลตฟอร์ม สำหรับ AndroidIOS, macOSและ Windows จากฐานรหัสที่ใช้ร่วมกันเพียงอันเดียว

ลักษณะ Xamarin.แบบฟอร์ม .NET เมา
ฐานกรอบ .NET Framework / โมโน .NET 6+ แบบรวม
Archiเทคเจอร์ โครงการเฉพาะแพลตฟอร์ม โครงสร้างโครงการเดี่ยว
ประสิทธิภาพ ปานกลาง ปรับปรุงด้วยรันไทม์ .NET
โหลดซ้ำสุดฮอต ถูก จำกัด รองรับการโหลดซ้ำแบบร้อนเต็มรูปแบบ

ตัวอย่าง: โสด .NET MAUI โครงการสามารถรวมโค้ดเฉพาะแพลตฟอร์มไว้ในโฟลเดอร์เช่น Platforms/Android or Platforms/iOSในขณะที่แบ่งปันส่วนประกอบ UI ทั่วไปข้ามแพลตฟอร์ม

ประโยชน์: ทำให้การพัฒนาข้ามแพลตฟอร์มง่ายขึ้นและปรับปรุงการบำรุงรักษา

22) Blazor คืออะไร และมีรูปแบบโฮสติ้งที่แตกต่างกันอย่างไรบ้าง?

เสื้อคลุม เป็นกรอบงานสำหรับสร้าง UI เว็บแบบโต้ตอบโดยใช้ C# แทน Javaสคริปต์ ช่วยให้สามารถพัฒนาเว็บแบบฟูลสแต็กด้วย .NET

รูปแบบการโฮสต์ Descriptไอออน สถานที่ดำเนินการ
เซิร์ฟเวอร์ Blazor ทำงานบนเซิร์ฟเวอร์ ส่งการอัปเดต UI ผ่านทาง SignalR เซิร์ฟเวอร์
บลาเซอร์เว็บAssembly รันฝั่งไคลเอนต์ในเบราว์เซอร์โดยใช้เว็บAssembly เบราว์เซอร์
เบลเซอร์ ไฮบริด (MAUI) ผสมผสาน UI เว็บกับแอปเดสก์ท็อป/มือถือดั้งเดิม แอปท้องถิ่น

ตัวอย่าง: แอปพลิเคชัน Blazor Server เหมาะสำหรับแดชบอร์ดขององค์กรที่ต้องการการควบคุมแบบรวมศูนย์ที่ปลอดภัย ในขณะที่ Blazor WebAssembly เหมาะกับการใช้งานแบบออฟไลน์

23) ไมโครเซอร์วิสใน .NET คืออะไร และมีข้อดีเหนือสถาปัตยกรรมแบบโมโนลิธิกอย่างไร

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

แง่มุม เป็นเสาหิน Microservices
การใช้งาน หน่วยเดียว บริการอิสระ
scalability แอปทั้งหมดปรับขนาด มาตราส่วนต่อบริการ
กองเทคโนโลยี คงที่ การสนับสนุนหลายภาษา
การแยกตัวไม่เป็นผล ต่ำ จุดสูง

ข้อดี:

  • การปรับใช้และการปรับขนาดแบบอิสระ
  • การแยกข้อผิดพลาดที่ง่ายขึ้นและการกู้คืนที่รวดเร็วยิ่งขึ้น
  • เปิดใช้งาน CI/CD pipeline และแนวทางปฏิบัติ DevOps

ตัวอย่าง: ระบบอีคอมเมิร์ซที่ใช้ .NET อาจแยกออกจากกัน OrderService, InventoryServiceและ PaymentService ในรูปแบบบริการ REST หรือ gRPC แต่ละรายการ

24) gRPC ช่วยปรับปรุงการสื่อสารในไมโครเซอร์วิส .NET เมื่อเทียบกับ REST API ได้อย่างไร

gRPC (การเรียกขั้นตอนระยะไกลของ Google) เป็นกรอบการทำงานการสื่อสารประสิทธิภาพสูงโดยใช้ โปรโตคอล Buffers (โปรโตบัฟ) สำหรับการเรียงลำดับข้อความ

ลักษณะ REST API ก.ร.ป
รูปแบบ JSON ไบนารี (โปรโตบัฟ)
ความเร็ว ช้าลงเนื่องจากการแยกวิเคราะห์ JSON เร็วขึ้นมาก
การสื่อสาร HTTP 1.1 HTTP/2 (แบบสองทิศทาง)
สัญญา OpenAPI ไฟล์ .proto
ใช้กรณี เว็บแอพ การสื่อสารบริการภายใน

ตัวอย่าง: ใน .NET บริการ gRPC ถูกกำหนดโดยใช้ .proto ไฟล์และคอมไพล์เป็นโค้ด C# ช่วยให้การส่งข้อความรวดเร็วและกระชับยิ่งขึ้น เหมาะสำหรับไมโครเซอร์วิสและ IoT

25) แนวทางปฏิบัติที่ดีที่สุดสำหรับการเพิ่มประสิทธิภาพการทำงานในแอปพลิเคชัน .NET มีอะไรบ้าง

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

ปฏิบัติที่ดีที่สุด:

  1. ใช้การเขียนโปรแกรมแบบอะซิงโครนัส (async/await) เพื่อป้องกันการบล็อค
  2. แคชข้อมูลที่ใช้บ่อย การใช้ MemoryCache หรือ Redis
  3. ลดการจัดสรรให้เหลือน้อยที่สุด และการใช้งาน Span<T> หรือการรวบรวมข้อมูลขนาดใหญ่
  4. รหัสโปรไฟล์ โดยใช้เครื่องมือเช่น dotTrace หรือ PerfView
  5. เพิ่มประสิทธิภาพการสอบถาม EF สีสดสวย AsNoTracking() สำหรับข้อมูลที่อ่านอย่างเดียว

ตัวอย่าง:

var users = context.Users.AsNoTracking().ToList();

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

26) มีเทคนิคการแคชอะไรบ้างใน .NET Core?

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

ประเภทแคช Descriptไอออน ตัวอย่างการใช้งาน
แคชในหน่วยความจำ จัดเก็บข้อมูลในหน่วยความจำเซิร์ฟเวอร์ IMemoryCache
แคชแบบกระจาย แคชที่ใช้ร่วมกันระหว่างเซิร์ฟเวอร์ IDistributedCache, เรดิส
การแคชการตอบสนอง แคชการตอบสนอง HTTP ResponseCache คุณลักษณะ
การแคชเอาต์พุต นำเอาท์พุตที่เรนเดอร์เต็มรูปแบบกลับมาใช้ใหม่ มิดเดิลแวร์ ASP.NET Core

ตัวอย่าง:

_cache.Set("EmployeeList", employeeData, TimeSpan.FromMinutes(30));

สำหรับการแคชแบบกระจาย Redis มักใช้สำหรับสภาพแวดล้อมที่มีการโหลดสมดุล

27) คุณนำการบันทึกและการตรวจสอบไปใช้ในแอปพลิเคชัน .NET Core ได้อย่างไร

การบันทึกข้อมูลเป็นสิ่งสำคัญสำหรับการติดตามปัญหาและตรวจสอบสุขภาพของระบบ .NET Core มีการแยกส่วนการบันทึกข้อมูลในตัวที่สามารถบูรณาการกับผู้ให้บริการบุคคลที่สามได้

เทคนิค:

  • ใช้ ไอล็อกเกอร์ อินเทอร์เฟซสำหรับการบันทึกข้อมูลแบบมีโครงสร้าง
  • ผสานรวมกับ เซอร์ล็อก, เอ็นล็อกหรือ Application Insights.
  • จัดเก็บบันทึกในระบบรวมศูนย์เช่น ELK (Elastic Stack).

ตัวอย่าง:

public class UserController
{
    private readonly ILogger<UserController> _logger;
    public UserController(ILogger<UserController> logger)
    {
        _logger = logger;
    }
}

เครื่องมือตรวจสอบ:

  • Azure Application Insights
  • โพรมีธีอุส + กราฟาน่า
  • นิวเรลิค / ดาต้าด็อก

28) ตัวเลือกการปรับใช้หลักที่มีให้สำหรับแอปพลิเคชัน .NET มีอะไรบ้าง

แอปพลิเคชัน .NET สามารถปรับใช้ได้โดยใช้วิธีการยืดหยุ่นหลายวิธี:

ประเภทการทำให้ใช้งานได้ Descriptไอออน ใช้กรณี
การปรับใช้ที่ขึ้นอยู่กับกรอบงาน (FDD) ต้องมีการติดตั้ง .NET Runtime บนโฮสต์ เซิฟเวอร์ที่ใช้ร่วมกัน
การปรับใช้แบบครบวงจร (SCD) รวม .NET runtime ในแพ็คเกจ แอปคลาวด์แบบแยกส่วน
คอนเทนเนอร์นักเทียบท่า แพ็กเกจแอปพร้อมการอ้างอิง ไมโครเซอร์วิสและ CI/CD
Azure บริการแอป โฮสติ้งบนคลาวด์สำหรับแอปบนเว็บ แอป SaaS ที่ปรับขนาดได้

ตัวอย่าง: การปรับใช้ .NET 8 Web API เป็นคอนเทนเนอร์ Docker ช่วยเพิ่มความสามารถในการพกพาและการทำงานอัตโนมัติของ CI/CD

29) เป็นยังไงบ้าง Azure บูรณาการกับแอพพลิเคชั่น .NET สำหรับการพัฒนาบนคลาวด์หรือไม่?

Azure มอบการบูรณาการระดับชั้นนำกับ .NET สำหรับการสร้าง การปรับใช้ และการจัดการแอปพลิเคชันเนทีฟบนคลาวด์

คีย์ Azure บริการสำหรับ .NET:

  1. Azure บริการแอป – โฮสต์แอปพลิเคชันเว็บ
  2. Azure ฟังก์ชั่น – การประมวลผลแบบไร้เซิร์ฟเวอร์สำหรับงานพื้นหลัง
  3. Azure ฐานข้อมูล SQL – ฐานข้อมูลเชิงสัมพันธ์ที่ได้รับการจัดการอย่างเต็มรูปแบบ
  4. Azure รถบัสบริการ – การจัดคิวข้อความสำหรับระบบแบบกระจาย
  5. Azure คีย์ Vault – รักษาความลับและข้อมูลประจำตัวให้ปลอดภัย

ตัวอย่าง: ไมโครเซอร์วิส .NET อาจใช้ Azure คีย์ Vault เพื่อจัดเก็บสตริงการเชื่อมต่อฐานข้อมูลอย่างปลอดภัยในขณะที่ใช้งานผ่าน Azure ไปป์ไลน์ CI/CD ของ DevOps

30) กรอบการทดสอบใดบ้างที่ใช้กันทั่วไปใน .NET และแตกต่างกันอย่างไร?

การทดสอบช่วยให้มั่นใจถึงความน่าเชื่อถือและความสามารถในการบำรุงรักษาของแอปพลิเคชัน .NET รองรับกรอบงานการทดสอบหลายแบบ

กรอบ Descriptไอออน Key Features
เอ็กซ์ยูนิต เครื่องมือทดสอบโอเพ่นซอร์สที่ทันสมัย การดำเนินการทดสอบแบบคู่ขนาน
หน่วย โตเต็มที่ ใช้กันอย่างแพร่หลายในองค์กรต่างๆ การทดสอบตามคุณลักษณะ
เอ็มเอสเทสต์ Microsoftกรอบการทำงานการทดสอบดั้งเดิมของ การบูรณาการกับ Visual Studio

ตัวอย่าง:

[Fact]
public void Add_ReturnsSum()
{
    Assert.Equal(4, Calculator.Add(2, 2));
}

ปฏิบัติที่ดีที่สุด:

  • ใช้ การล้อเลียน (Moq) สำหรับการอ้างอิง
  • เก็บรักษา การครอบคลุมการทดสอบสูง ด้วยการบูรณาการ CI/CD
  • เพิ่ม การทดสอบบูรณาการ สำหรับการตรวจสอบ API

31) ฟีเจอร์ใหม่ที่สำคัญที่เปิดตัวใน .NET 8 มีอะไรบ้าง?

.NET 8 แนะนำ การเพิ่มประสิทธิภาพการทำงาน, AOT ดั้งเดิมและปรับปรุง เมฆพื้นเมือง ความสามารถ มันยังคงดำเนินต่อไป Microsoftเป้าหมายของเราคือการสร้างระบบนิเวศแบบรวมศูนย์และข้ามแพลตฟอร์ม

ไฮไลท์สำคัญ:

  1. AOT ดั้งเดิม (การรวบรวมล่วงหน้า): ลดเวลาในการเริ่มต้นระบบและการใช้หน่วยความจำ
  2. การปรับปรุง ASP.NET Core: การกำหนดเส้นทางที่รวดเร็วขึ้นและการรองรับ HTTP/3 ที่ได้รับการปรับปรุง
  3. แบลซอร์ ยูไนเต็ด: รวมฝั่งเซิร์ฟเวอร์และเว็บAssembly โมเดลสำหรับแอปไฮบริด
  4. เพิ่มประสิทธิภาพการทำงาน: การทำงานของ EF Core และ LINQ เร็วขึ้น 20–30%
  5. การสนับสนุน MAUI ขยาย: ปรับปรุงเครื่องมือสำหรับ UI ข้ามแพลตฟอร์ม

ตัวอย่าง: AOT ดั้งเดิมอนุญาตให้มีไฟล์ปฏิบัติการขนาดเล็กที่แยกจากกัน เหมาะสำหรับไมโครเซอร์วิสและการปรับใช้แบบคอนเทนเนอร์

32) การคอมไพล์แบบ Ahead-of-Time (AOT) ใน .NET คืออะไร และควรใช้เมื่อใด

การรวบรวม AOT คอมไพล์ .NET Intermediate Language (IL) ล่วงหน้าเป็นโค้ดเนทีฟก่อนรันไทม์ ปรับปรุงประสิทธิภาพการเริ่มต้นระบบ และลดการพึ่งพาคอมไพเลอร์ JIT

ประเภท Descriptไอออน กรณีใช้งานที่ดีที่สุด
JIT (ทันเวลา) คอมไพล์ IL ในระหว่างการรันไทม์ แอปเดสก์ท็อปหรือเซิร์ฟเวอร์
AOT (ก่อนเวลา) คอมไพล์ IL ก่อนรันไทม์ ไมโครเซอร์วิส, IoT, ระบบหน่วงเวลาต่ำ

ข้อดี:

  • เวลาเริ่มต้นใช้งานที่รวดเร็วยิ่งขึ้น
  • ขนาดหน่วยความจำเล็กลง
  • ประสิทธิภาพของคอนเทนเนอร์ดีขึ้น

ตัวอย่าง:

dotnet publish -r linux-x64 -p:PublishAot=true

คำสั่งนี้จะสร้างไฟล์ไบนารีที่คอมไพล์โดย AOT ดั้งเดิมสำหรับ Linux

33) นักพัฒนา .NET สามารถบูรณาการความสามารถของ AI หรือ ML เข้ากับแอปพลิเคชันได้อย่างไร

การบูรณาการ AI ใน .NET สามารถทำได้โดยใช้ เอ็มแอล.เน็ต, Azure บริการองค์ความรู้หรือห้องสมุดภายนอก

วิธีการ:

  1. ML.NET: สร้างและฝึกอบรมโมเดลการเรียนรู้ของเครื่องโดยตรงใน .NET
  2. Azure บริการทางปัญญา: ใช้ API ที่ได้รับการฝึกอบรมล่วงหน้าสำหรับการมองเห็น การพูด และภาษา
  3. รันไทม์ ONNX: รันโมเดลที่ได้รับการฝึกอบรมใน Python/TensorFlow ภายในแอป .NET
  4. การรวม API ของ OpenAI: เข้าถึง AI เชิงสร้างสรรค์ (เช่น โมเดล GPT) อย่างปลอดภัยผ่าน REST

ตัวอย่าง (ML.NET):

var mlContext = new MLContext();
var model = mlContext.Model.Load("model.zip", out _);

ใช้กรณี: การคาดการณ์การเปลี่ยนแปลงของผู้ใช้ การตรวจจับความผิดปกติ หรือคำแนะนำอัจฉริยะในระบบองค์กร

34) ความแตกต่างหลักระหว่าง REST API และ Minimal API ใน .NET 8 คืออะไร

API ขั้นต่ำ มอบวิธีน้ำหนักเบาในการสร้าง HTTP API ด้วยโค้ดสำเร็จรูปขั้นต่ำ

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

ตัวอย่าง:

app.MapGet("/hello", () => "Hello, World!");

API ขั้นต่ำเหมาะอย่างยิ่งสำหรับไมโครเซอร์วิสและแอปพลิเคชันที่ไม่มีเซิร์ฟเวอร์เนื่องจากความเรียบง่ายและประสิทธิภาพ

35) หลักการสำคัญของการเขียนโค้ดอย่างปลอดภัยในแอปพลิเคชัน .NET คืออะไร

จะต้องบังคับใช้ความปลอดภัยตั้งแต่ขั้นตอนการพัฒนา .NET มีกลไกในตัวและแนวทางปฏิบัติที่ดีที่สุดสำหรับการเขียนโค้ดที่ปลอดภัย

หลักการสำคัญ:

  1. ตรวจสอบข้อมูลอินพุตทั้งหมด: ป้องกันการโจมตีแบบฉีด
  2. ใช้แบบสอบถามแบบพารามิเตอร์: หลีกเลี่ยงการฉีด SQL
  3. เข้ารหัสข้อมูลที่ละเอียดอ่อน: ใช้ System.Security.Cryptography.
  4. จัดเก็บความลับอย่างปลอดภัย: ใช้ Azure คีย์ Vault หรือความลับของผู้ใช้
  5. ใช้การตรวจสอบและอนุญาต: Implement ASP.NET Identity หรือโทเค็น JWT
  6. ใช้หลักการ HTTPS และ CORS: ป้องกันการรั่วไหลของข้อมูลและการเข้าถึงโดยไม่ได้รับอนุญาต

ตัวอย่าง:

using (var cmd = new SqlCommand("SELECT * FROM Users WHERE Id = @id", conn))
{
    cmd.Parameters.AddWithValue("@id", userId);
}

36) คุณใช้เครื่องมือสร้างโปรไฟล์และวินิจฉัยเพื่อเพิ่มประสิทธิภาพการทำงานของ .NET ได้อย่างไร

การสร้างโปรไฟล์ช่วยระบุปัญหาคอขวดด้านประสิทธิภาพใน CPU, หน่วยความจำ หรือ I/O

เครื่องมือยอดนิยม:

เครื่องมือ จุดมุ่งหมาย
dotTrace / dotMemory การสร้างโปรไฟล์และการตรวจจับการรั่วไหลของหน่วยความจำ
เพอร์ฟวิว การวิเคราะห์ประสิทธิภาพระดับต่ำ
ดอทเน็ตเทรซ การติดตามบรรทัดคำสั่ง
Application Insights การวัดระยะไกลแบบเรียลไทม์ในการผลิต

วิธีการ:

  1. ระบุคอขวดโดยใช้ตัวนับประสิทธิภาพ
  2. เส้นทางโค้ดโปรไฟล์และการจัดสรรหน่วยความจำ
  3. เพิ่มประสิทธิภาพการค้นหา LINQ และลดการสร้างวัตถุ

ตัวอย่าง: ใช้ dotnet-counters monitor เพื่อติดตามเมตริกแบบเรียลไทม์เช่นกิจกรรม CPU และ GC

37) แนวทางปฏิบัติ DevOps ที่มีประสิทธิผลสำหรับแอปพลิเคชัน .NET มีอะไรบ้าง

การบูรณาการ DevOps รับประกันการส่งมอบที่รวดเร็วยิ่งขึ้นและคุณภาพที่ดีขึ้นผ่านระบบอัตโนมัติและการทำงานร่วมกัน

แนวทางปฏิบัติที่สำคัญ:

  • ท่อ CI/CD: ใช้ GitHub Actions หรือ Azure DevOps สำหรับการสร้างและการปรับใช้แบบอัตโนมัติ
  • โครงสร้างพื้นฐานเป็นรหัส (IaC): ปรับใช้ด้วยเทมเพลต ARM, Terraform หรือ Bicep
  • การทดสอบอัตโนมัติ: รวม xUnit/NUnit ในเวิร์กโฟลว์ CI
  • คอนเทนเนอร์: ใช้ Docker Image และ Kubernetes (AKS)
  • การตรวจสอบ: การวัดระยะไกลอย่างต่อเนื่องด้วย Application Insights

ตัวอย่าง: ท่อ CI/CD ใน Azure DevOps สามารถสร้าง ทดสอบ และปรับใช้ .NET API ได้ Azure App Service จะทำงานโดยอัตโนมัติเมื่อมีการคอมมิต Git

38) คุณจะมั่นใจได้อย่างไรว่าระบบแบบกระจายที่ใช้ .NET นั้นมีความสามารถในการปรับขนาดได้และทนต่อข้อผิดพลาด

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

กลยุทธ์:

  1. การปรับขนาดแนวนอน: ปรับใช้อินสแตนซ์หลายตัวไว้ด้านหลังตัวปรับสมดุลการโหลด
  2. รูปแบบเบรกเกอร์: ใช้ไลบรารี Polly เพื่อจัดการกับข้อผิดพลาดชั่วคราว
  3. การแคชและการจัดคิว: ใช้ Redis และ Azure บัสบริการสำหรับการประมวลผลแบบอะซิงโครนัส
  4. การแบ่งฐานข้อมูล: กระจายชุดข้อมูลขนาดใหญ่
  5. ตรวจสุขภาพ: ใช้ AddHealthChecks() มิดเดิลแวร์ใน .NET Core

ตัวอย่าง (เซอร์กิตเบรกเกอร์):

Policy.Handle<HttpRequestException>()
      .CircuitBreaker(3, TimeSpan.FromMinutes(1));

39) การสร้างคอนเทนเนอร์มีบทบาทอย่างไรในระบบ .NET สมัยใหม่?

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

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

  • การปรับใช้ที่คาดเดาได้ (ใช้งานได้บนโฮสต์ใดก็ได้)
  • การปรับขนาดที่ง่ายขึ้นด้วย Kubernetes (AKS)
  • น้ำหนักเบาและเร็วกว่าเครื่องเสมือน
  • รวมเข้ากับเวิร์กโฟลว์ CI/CD ได้อย่างง่ายดาย

ตัวอย่าง (Dockerfile):

FROM mcr.microsoft.com/dotnet/aspnet:8.0
WORKDIR /app
COPY . .
ENTRYPOINT ["dotnet", "MyApp.dll"]

ใช้กรณี: การปรับใช้คลัสเตอร์ไมโครเซอร์วิส .NET ใน Kubernetes ช่วยเพิ่มความสามารถในการปรับขนาดและการแยกข้อผิดพลาด

40) คุณจะออกแบบระบบ .NET ที่ปรับขนาดได้สำหรับผู้ใช้หลายล้านคนได้อย่างไร

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

คีย์ Archiการตัดสินใจด้านโครงสร้าง:

  1. ใช้ไมโครเซอร์วิส: แต่ละบริการสามารถปรับใช้ได้อย่างอิสระ
  2. นำ CQRS มาใช้ + การจัดหาแหล่งข้อมูลเหตุการณ์: แยกโมเดลการอ่าน/การเขียน
  3. การส่งข้อความแบบอะซิงโครนัส: ใช้ Azure รถบัสบริการ หรือ คาฟคา
  4. API เกตเวย์: จัดการการจราจรและความปลอดภัย
  5. เลเยอร์แคช: Redis หรือ MemoryCache เพื่อการเข้าถึงความเร็วสูง
  6. ความสามารถในการปรับขนาดฐานข้อมูล: ใช้ Azure Cosmos DB หรือ SQL แบบแบ่งพาร์ติชั่น
  7. การปรับขนาดอัตโนมัติ: กำหนดค่าผ่าน Azure แอปเซอร์วิส หรือ AKS

ตัวอย่างขั้นตอนการออกแบบ:

ผู้ใช้ → API Gateway → ตัวปรับสมดุลการโหลด → ไมโครเซอร์วิส (.NET 8 API) → ฐานข้อมูล + แคช Redis → การวัดระยะไกลผ่าน Application Insights

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

ด้านล่างนี้คือ 10 คำถามสัมภาษณ์ .NET ที่พบบ่อยและสมจริง พร้อมคำอธิบายเชิงกลยุทธ์และตัวอย่างคำตอบ มีทั้งคำถามเชิงความรู้ คำถามเชิงพฤติกรรม และคำถามเชิงสถานการณ์

วลีที่จำเป็นได้ถูกใช้ไปแล้วครั้งละหนึ่งรายการ

1) คุณสามารถอธิบายความแตกต่างระหว่าง .NET Framework, .NET Core และ .NET 6/7/8 ได้หรือไม่

สิ่งที่คาดหวังจากผู้สมัคร: ทำความเข้าใจเกี่ยวกับวิวัฒนาการของระบบนิเวศ .NET ความสามารถข้ามแพลตฟอร์ม และการสนับสนุนในระยะยาว

ตัวอย่างคำตอบ: “.NET Framework เป็นต้นฉบับ Windows- กรอบงานแบบเฉพาะ ในขณะที่ .NET Core แนะนำความสามารถข้ามแพลตฟอร์มและประสิทธิภาพที่ดีกว่า .NET 6 และรุ่นหลังรวมระบบนิเวศภายใต้ SDK ข้ามแพลตฟอร์มที่ทันสมัยตัวเดียวพร้อมการปรับปรุงที่สำคัญในด้านประสิทธิภาพ ความพร้อมของคลาวด์ และความเร็วในการพัฒนา

2) คุณจะนำการฉีดการอ้างอิงไปใช้ใน .NET ได้อย่างไร และเหตุใดจึงมีประโยชน์

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

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

3) อธิบายโครงการ .NET ที่ท้าทายที่คุณทำงานด้วยและคุณมีส่วนสนับสนุนให้โครงการนั้นประสบความสำเร็จได้อย่างไร

สิ่งที่คาดหวังจากผู้สมัคร: การมีส่วนร่วม การแก้ปัญหา และความเป็นเจ้าของในโลกแห่งความเป็นจริง

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

4) คุณจะมั่นใจได้อย่างไรถึงประสิทธิภาพและความสามารถในการปรับขนาดของแอปพลิเคชัน .NET

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

ตัวอย่างคำตอบ: “ฉันตรวจสอบประสิทธิภาพโดยใช้เครื่องมือสร้างโปรไฟล์ เช่น dotTrace และ Application Insights ใช้การเขียนโปรแกรมแบบอะซิงโครนัสเมื่อเหมาะสม ใช้แคช และใช้รูปแบบสถาปัตยกรรมที่ปรับขนาดได้ เช่น ไมโครเซอร์วิสเมื่อจำเป็น”

5) อธิบายความแตกต่างระหว่าง async/await และ multithreading ใน .NET

สิ่งที่คาดหวังจากผู้สมัคร: ความเข้าใจเกี่ยวกับโมเดลการทำงานพร้อมกัน

ตัวอย่างคำตอบ: “Async และ await ช่วยให้สามารถใช้งานแบบ nonblocking ได้ โดยใช้ประโยชน์จากรูปแบบ Asynchronous ที่อิงตามงาน ในขณะที่มัลติเธรดดิ้งเกี่ยวข้องกับการสร้างเธรดแยกต่างหากที่ทำงานแบบขนาน การเขียนโปรแกรมแบบอะซิงโครนัสเหมาะอย่างยิ่งสำหรับงานที่ผูกติดกับ I/O ในขณะที่มัลติเธรดดิ้งมีประโยชน์สำหรับการทำงานที่ผูกติดกับ CPU”

6) เล่าให้ฟังหน่อยถึงสถานการณ์ที่คุณต้องเรียนรู้เทคโนโลยี .NET ใหม่ ๆ อย่างรวดเร็ว คุณจัดการมันอย่างไร

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

ตัวอย่างคำตอบ: “ในตำแหน่งก่อนหน้านี้ ผมจำเป็นต้องเรียนรู้ Blazor อย่างรวดเร็วสำหรับโปรเจ็กต์ของลูกค้า ผมจึงอุทิศเวลาให้กับ Microsoft การจัดทำเอกสาร ฝึกฝนกับโครงการแซนด์บ็อกซ์ขนาดเล็ก และร่วมมือกับสมาชิกในทีมเพื่อให้แน่ใจว่าฉันจะส่งมอบผลลัพธ์ที่มีคุณภาพตรงเวลา”

7) คุณจะออกแบบ RESTful API ใน ASP.NET Core อย่างไร? คุณยึดหลักการสำคัญอะไรบ้าง?

สิ่งที่คาดหวังจากผู้สมัคร: ความรู้เกี่ยวกับวิธีการ HTTP การกำหนดเส้นทาง การกำหนดเวอร์ชัน และแนวทางปฏิบัติที่ดีที่สุด

ตัวอย่างคำตอบ: ฉันปฏิบัติตามหลักการ REST เช่น การตั้งชื่อทรัพยากรที่ถูกต้อง สถานะไร้รัฐ และการใช้คำกริยา HTTP อย่างถูกต้อง นอกจากนี้ ฉันยังใช้การตรวจสอบความถูกต้องของโมเดล รหัสสถานะที่ถูกต้อง การกำหนดเวอร์ชัน และกลไกการตรวจสอบสิทธิ์ เช่น JWT อีกด้วย

8) คุณจัดการกับกำหนดเวลาที่กระชั้นชิดอย่างไรเมื่อต้องทำงานในโครงการ .NET หลายโครงการพร้อมๆ กัน?

สิ่งที่คาดหวังจากผู้สมัคร: การกำหนดลำดับความสำคัญ การจัดระเบียบ การสื่อสาร

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

9) คุณรักษาคุณภาพโค้ดในแอปพลิเคชัน .NET ได้อย่างไร

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

ตัวอย่างคำตอบ: “ผมรักษาคุณภาพของโค้ดด้วยการทดสอบยูนิตด้วย xUnit การตรวจสอบโค้ด การวิเคราะห์โค้ดแบบคงที่ และการยึดมั่นตามหลักการ SOLID ขั้นตอนเหล่านี้ช่วยให้มั่นใจได้ถึงความสามารถในการบำรุงรักษาและความน่าเชื่อถือในระยะยาว”

10) สมมติว่า API ของ .NET ที่ใช้งานจริงเริ่มส่งคืนข้อผิดพลาด 500 เป็นระยะๆ คุณจะวินิจฉัยปัญหาอย่างไร

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

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

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