Beginner Book

โหมดมืด

บทที่ 0 — C# + .NET คืออะไร และทำไมต้องเรียน ​

สารบัญ C# | บทที่ 1: Setup + Hello World →

ก่อนเขียนโค้ดบรรทัดแรก เราจะตอบคำถาม 5 ข้อที่ทำให้ C#/.NET ดูเหมือนเวทมนตร์ถ้าไม่เข้าใจตั้งแต่ต้น:

  1. C# กับ .NET ต่างกันยังไง?
  2. .NET Framework, .NET Core, .NET 5/6/7/8/9 — สับสนมาก คืออะไรกันแน่
  3. CLR / BCL / NuGet คืออะไร
  4. ทำไม Microsoft ลงทุน C# มากขนาดนี้
  5. เลือก C# เมื่อไหร่ vs Java/Go/TypeScript

👤 อ่านก่อน — บทนี้เหมาะกับใคร ​

หมวด C# เริ่มจากศูนย์ได้ แต่บท 0 นี้จะเทียบ C# กับ Java/TypeScript เป็นระยะ เพราะช่วยคนที่ย้ายภาษาให้เข้าใจเร็ว

  • ✅ เคยเขียนภาษาอื่นมาก่อน — การเทียบจะมีประโยชน์มาก
  • 🌱 มือใหม่จริง ๆ ไม่เคยเขียนอะไรเลย — ตรงไหนเทียบกับ Java/JVM แล้วไม่เข้าใจ ข้ามได้ ไม่ใช่สาระสำคัญ เดี๋ยวบท 1 เริ่มสอนจากศูนย์ — ถ้ายังใหม่มากและงงบทนี้ทั้งหมด ข้ามมาเริ่ม บทที่ 1 ได้เลย ค่อยกลับมาอ่านบทนี้ทีหลัง

📖 ตัวย่อที่จะเจอรัว ๆ ในบทนี้ (กางไว้ก่อน ไม่ต้องท่อง) ​

ตัวย่อย่อมาจากคืออะไรแบบสั้นที่สุด
.NET—แพลตฟอร์มที่รันโปรแกรม C# (เหมือน "สนาม" ที่ภาษาลงไปเล่น)
CLRCommon Language Runtimeตัวจริงที่รันโค้ด — จัดการ memory/ความปลอดภัย (เทียบ JVM = Java Virtual Machine ของ Java)
BCLBase Class Libraryกล่องเครื่องมือมาตรฐานที่ใช้ได้เลย (อ่านไฟล์, จัดการ list ฯลฯ)
ILIntermediate Languageโค้ดกลางที่ C# ถูกแปลงเป็นก่อน (ยังไม่ใช่ภาษาเครื่อง)
JITJust-In-Time compilerตัวแปลง IL → ภาษาเครื่อง "ตอนรัน"
GCGarbage Collectorตัวเก็บกวาด memory ที่ไม่ใช้แล้วอัตโนมัติ
AOTAhead-Of-Time compileแปลงเป็นภาษาเครื่องตั้งแต่ตอน build (ตรงข้ามกับ JIT)
SDKSoftware Development Kitชุดเครื่องมือสำหรับเขียน/build/รัน
NuGet—ตัวจัดการ library ของ .NET (เทียบ npm ของ Node / Maven ของ Java)

(ตารางนี้แค่ให้เปิดอ้างอิงเวลาเจอคำ — แต่ละตัวมีอธิบายเต็มในข้อ 3–4)

1. C# กับ .NET — แยกให้ชัด ​

C# = ภาษา — เขียนเป็นไฟล์ .cs ภาษาเขียนโปรแกรมมี 2 ส่วน: syntax (ไวยากรณ์ — รูปแบบการเขียน) และ semantics (ความหมาย — ผลลัพธ์ตอนรัน) ตัวอย่างง่าย ๆ: = หมายถึงการกำหนดค่า (เช่น x = 5 คือเอา 5 ใส่ตัวแปร x) ส่วน == หมายถึงการเปรียบเทียบ (เช่น x == 5 คือถามว่า x เท่ากับ 5 ไหม) .NET = platform / runtime (ตัวที่คอยรันโปรแกรม) ที่ทำงานรองรับภาษา — รัน C#, F#, VB.NET

เปรียบเทียบ:

  • Java (ภาษา) ↔ JVM (runtime)
  • C# (ภาษา) ↔ .NET (runtime)

ภาษาอื่นที่ทำงานบน .NET:

  • F# — functional first (เน้น functional programming คือเขียนแบบฟังก์ชัน หลีกเลี่ยง state)
  • VB.NET — Visual Basic แบบ modern (Microsoft กำลังลดการลงทุนพัฒนาเพิ่ม)
  • C++/CLI — interop กับ C++ (C++/CLI = ภาษา C++ รุ่นพิเศษที่รันบน .NET — ตัว CLI ในที่นี้ย่อมาจาก Common Language Infrastructure ไม่ใช่ command line) (interop = interoperability คือทำให้โค้ดต่างภาษาเรียกหากันได้)

แต่ในทางปฏิบัติ 95%+ ของโค้ดบน .NET = C#

2. ประวัติฉบับย่อ — .NET เวอร์ชันต่าง ๆ ที่สับสน ​

(last reviewed: 2026-06 — ตรวจ release notes ทางการก่อนใช้ เนื้อหาในเล่มอ้างอิง feature ของ C# 12–13 / .NET 8–10 เป็นหลัก feature ใหม่ของ .NET 9/10 บางส่วนอาจยังไม่ครอบคลุมเต็ม)

สิ่งที่ต้องรู้:

  • .NET Framework = legacy, Windows only — รหัสเก่า ๆ ใน enterprise
  • .NET (ตั้งแต่ 5+) = ใหม่ cross-platform — ใช้สำหรับโปรเจกต์ใหม่ทั้งหมด
  • LTS = Long Term Support (ปัจจุบัน 3 ปีนับจาก GA ตาม policy ของ Microsoft — เคยมีการปรับเปลี่ยนมาก่อน ตรวจสอบ .NET support policy ล่าสุดก่อนใช้จริง) — เลือก LTS สำหรับ production
  • STS = Standard Term Support (18 เดือน) — เช่น .NET 7, .NET 9 เหมาะกับโปรเจกต์ที่ตามฟีเจอร์ใหม่และอัปเดตบ่อย
  • ภาษา C# version (12, 13, ...) ออกพร้อม .NET version

💡 ในหนังสือนี้เราใช้ .NET 8 LTS เป็นพื้น (modern .NET) — ตัวอย่างควรรันได้บน .NET 9 และ .NET 10 LTS ที่ออกปลายปี 2026 ด้วย ตอนใช้คำว่า ".NET" หมายถึงตัวใหม่เสมอ ถ้าพูดถึงตัวเก่าจะใช้ "Framework"

3. Architecture — .NET ทำงานยังไง ​

อ่านแผนภาพข้างบนแบบยืนได้ด้วยตัวเอง (ยังไม่ต้องเทียบกับอะไร):

  • เขียนโค้ด .cs → compiler (ตัวแปลภาษา) แปลงเป็น IL (Intermediate Language — ภาษากลาง ยังไม่ใช่ภาษาเครื่อง 0/1) เก็บไว้ในไฟล์ .dll/.exe
  • ตอนรัน CLR (Common Language Runtime — ตัวที่คอยรันโค้ดของ .NET) เอา IL มาให้ JIT (Just-In-Time compiler) แปลงเป็นภาษาเครื่อง "ตอนรัน" ทีละส่วน แล้วสั่งให้ OS ทำงาน
  • CLR ยังดูแลให้อัตโนมัติอีกหลายเรื่อง:
    • GC (Garbage Collector — เก็บกวาด memory ที่ไม่ใช้แล้ว)
    • threading (การทำงานหลายเส้นพร้อมกัน)
    • ความปลอดภัย (ป้องกันโค้ดทำสิ่งที่ไม่ควรทำกับ memory ของโปรแกรมอื่น)
    • Reflection — กลไกที่ให้โปรแกรมส่องดูโครงสร้างของ type/method ตัวเองตอนรันได้ เช่น library แปลง JSON หรือ dependency injection (DI) ใช้ reflection เพื่อรู้ว่า object มี field/method อะไรบ้างโดยไม่ต้องเขียนโค้ดระบุตายตัว

สำหรับคนเคยเขียน Java (ไม่เคยก็ข้ามได้) ​

ใกล้ ๆ กับ JVM:

  • IL ≈ Java bytecode (รหัสกลางที่ Java แปลงโค้ดเป็นก่อน)
  • CLR ≈ JVM
  • JIT ≈ JIT
  • BCL (Base Class Library — ห้องสมุดมาตรฐานที่ติดมากับ .NET) ≈ Java standard library

Native AOT (Ahead-Of-Time — แปลงเป็นภาษาเครื่องตั้งแต่ตอน build ไม่รอตอนรัน; ตั้งแต่ .NET 7+) คือการ compile เป็น native code (ภาษาเครื่อง) ตั้งแต่ตอน build โดยไม่ต้องพึ่ง JIT ตอนรัน ผลที่ได้คือ:

  • startup (เวลาเริ่มโปรแกรม) เร็วขึ้น
  • binary (ไฟล์ที่รันได้) มีขนาดเล็กลง

เหมาะกับงานที่โปรแกรมต้อง "เริ่มเร็ว" บ่อย ๆ เช่น serverless (ฟังก์ชันที่รันบน cloud โดยไม่ต้องดูแล server เอง) และ container (กล่องที่แพ็คโปรแกรม + dependency ทั้งหมดไว้ในชุดเดียว)

4. ส่วนประกอบที่ต้องรู้ ​

4.1 BCL — Base Class Library ​

ห้องสมุดมาตรฐานที่ติดมากับ .NET — System.*, Microsoft.* รายการข้างล่างเป็นแค่ "preview" ให้รู้ว่ามีอะไร — ยังไม่ต้องเข้าใจรายละเอียดตอนนี้:

  • System.Collections.Generic — List, Dictionary (โครงสร้างเก็บข้อมูลหลายค่า)
  • System.IO — อ่าน/เขียนไฟล์, stream (สายข้อมูล)
  • System.Net.Http — HttpClient (ใช้ยิง HTTP request)
  • System.Text.Json — แปลงข้อมูลไป-กลับระหว่าง C# object และ JSON
  • System.Threading.Tasks — Task กับ async (Task = ตัวแทนของงานที่อาจยังไม่เสร็จ, async = วิธีเขียนโค้ดที่รองานโดยไม่บล็อก — เรียนเต็มในบทที่ 11)

4.2 NuGet — package manager ​

เหมือนร้านค้าออนไลน์ของ code — รวม library สำเร็จรูปที่คนอื่นเขียนไว้ เพียงแค่รันคำสั่งก็เพิ่มเข้าโปรเจกต์ได้ทันที (เหมือน npm ของ Node.js หรือ Maven ของ Java)

bash
dotnet add package <ชื่อ library>   # ดาวน์โหลดและติดตั้ง library เข้าโปรเจกต์

Repository: nuget.org

4.3 dotnet CLI ​

bash
dotnet new console -n hello   # สร้างโปรเจกต์ console app ใหม่ชื่อ hello
dotnet run                    # compile แล้วรันในคราวเดียว
dotnet build                  # compile เท่านั้น ไม่รัน (ตรวจ error)
dotnet test                   # รัน unit test ทั้งหมดในโปรเจกต์
dotnet publish -c Release     # แพ็คโปรแกรมให้พร้อม deploy บน server

4.4 SDK vs Runtime ​

  • SDK = compiler + tool + runtime → ใช้สำหรับ develop
  • Runtime = แค่รันโปรแกรม → server ที่ deploy เพียงพอ

5. ทำไม Microsoft ทุ่มขนาดนี้ ​

C# เป็นยุทธศาสตร์สำคัญของ Microsoft — ใช้บน:

  • Azure (cloud service ของ Microsoft) — function, app service, container
  • Office (Outlook, Teams desktop)
  • Game engine (Unity ใช้ C# — Unity 2022 LTS และก่อนหน้ารันบน Mono / IL2CPP ไม่ใช่ .NET runtime ตัวใหม่ตรง ๆ; Unity 6+ กำลังย้ายไปใช้ .NET 6 CoreCLR — ตรวจสอบ release notes ของ Unity สำหรับเวอร์ชันที่ใช้)
  • Enterprise (banking, government เยอะใน Asia/EU)

ผลลัพธ์:

  • ภาษาพัฒนาเร็วมาก — มี feature ใหม่ทุกปี (เดี๋ยวเจอในบทต่อ ๆ ไป)
  • ecosystem ใหญ่ — มี library เกือบทุกเรื่อง
  • Documentation ดีที่สุดในกลุ่มภาษา mainstream

6. C# vs Java — เทียบให้เห็นภาพ ​

🌱 ไม่รู้จัก Java? ข้ามตารางนี้ไปได้เลย — อ่านแค่ หัวข้อ 7 (vs TypeScript) ซึ่งเข้าใจง่ายกว่า ตารางนี้มีประโยชน์เมื่อคุณย้ายมาจาก Java เท่านั้น

JavaC#
RuntimeJVMCLR
Package mgrMaven/GradleNuGet
Property syntaxgetter/setterpublic string Name { get; set; }
Delegate / function pointerFunctional interface[^funcif]delegate, Func<>, Action<>
AsyncCompletableFuture / virtual thread[^async]async/await (เก่ากว่า, ผูกใน language)
NullableOptional<T>string? (NRT = Nullable Reference Types) — compiler ตรวจให้
LINQ / StreamStream APILINQ (เก่ากว่า + integrated)
Recordrecord (Java 16+)record + record struct
Pattern matching(basic)rich (เรียนเต็มในบทที่ 3 และ 10)
Modern syntaxแบบระมัดระวัง (conservative)แบบกล้าเปลี่ยน (aggressive)

[^funcif]: ตระกูล delegate, Func/Action, Functional interface เรียนเต็มในบทที่ 9 (Lambda + Delegate + LINQ) ตอนนี้แค่รู้ว่าเป็น "function ที่เก็บใส่ตัวแปรได้" — สั้น ๆ: delegate = ชนิดข้อมูลที่เก็บ method ไว้ได้, Func<> = shorthand สำหรับ delegate ที่คืนค่า, Action<> = shorthand สำหรับ delegate ที่ไม่คืนค่า [^async]: async/await เรียนเต็มในบทที่ 11 ตอนนี้แค่รู้ว่าเป็นวิธี "ทำงานแบบไม่ต้องรอคิวเดียว" ทั้งสองภาษาทำได้แต่ syntax ต่างกัน

ความรู้สึกหลังเขียน 2 อย่าง:

  • Java = stable, conservative, "ภาษามาตรฐาน"
  • C# = ภาษาที่ "อยากให้คุณเขียนน้อยลง" — มี syntactic sugar (ศัพท์ฝรั่งแปลตรง ๆ ว่า "น้ำตาล" ที่ทำให้โค้ดหวานขึ้น = เขียนสั้นลง อ่านง่ายขึ้น โดยไม่เปลี่ยนความหมาย) เยอะกว่า

7. C# vs TypeScript ​

C# มีหลายอย่างที่ TS อิงตาม (Anders Hejlsberg เป็นผู้ออกแบบหลักของทั้งสองภาษา):

  • Type inference (var)
  • Generic
  • Async/await
  • Decorator (TS) ↔ Attribute (C#)
  • Discriminated union = ชนิดข้อมูลที่เป็นได้หลาย "รูปแบบ" ที่กำหนดไว้ล่วงหน้า เช่น ผลลัพธ์อาจเป็น Success หรือ Error ก็ได้ — คล้าย enum แต่แต่ละรูปแบบมีข้อมูลต่างกัน C# 13 ยังไม่มี discriminated union เป็น syntax ในตัวภาษาโดยตรง แนวทางที่แนะนำแทนคือจำลองผ่าน abstract record + sealed subclasses คู่กับ exhaustive switch expression (ดูหัวข้อ Pattern matching ในบท 3 และ 10)

ความต่าง:

  • C# = compile → IL → JIT → native (real type at runtime)
  • TS = transpile → JS (type หายตอน runtime)
  • C# มี AOT + GC + threading + native interop ครบในตัว — ใช้แทน TS/Node สำหรับ backend ได้ (ความหมายของแต่ละตัวดูในตาราง gloss ต้นบท)

8. เลือก C# / .NET เมื่อไหร่ ​

✅ เลือกเมื่อ:

  • ทีมคุ้น C# / .NET อยู่แล้ว
  • ระบบ enterprise (banking, insurance, government)
  • Cloud-first บน Azure (best integration)
  • ต้องการ unified stack (web + desktop + mobile + game ภาษาเดียว)
  • ต้องการ performance สูง — .NET 8+ มี throughput (ปริมาณ request ที่รับไหวต่อวินาที) อยู่ในกลุ่มท็อปเทียบเคียงกับ Java/Go ในหลาย benchmark มาตรฐาน (รายละเอียดดูหัวข้อ 9)

❌ ข้ามไปก่อน:

  • ทีมส่วนใหญ่เป็น JS/Python — ใช้ Node/FastAPI ง่ายกว่า
  • งานที่ ecosystem JS ดีกว่าชัดเจน (frontend, low-code, AI tooling เร็ว ๆ)
  • shell script / CLI tool เล็ก ๆ (Go เร็วกว่า)

9. Performance ของ .NET (จริงไหมที่ว่าเร็ว?) ​

TechEmpower benchmarks — ชุดทดสอบที่เทียบ framework ของหลายภาษาแบบ apples-to-apples (เทียบกันแบบแฟร์ — workload เดียวกัน เครื่องเดียวกัน) แต่ละ category (หมวด) ใช้ workload ต่างกัน เช่น plaintext (ตอบ "Hello") หรือ JSON serialization (แปลง object เป็น JSON)

ASP.NET Core อยู่ในกลุ่มอันดับต้น ๆ ของทุกภาษาในหลาย category โดยเฉพาะ plaintext และ JSON serialization เทียบเคียงกับ framework ระดับท็อปของ Java/Rust/Go (ตัวเลข exact ranking และ round ขึ้นกับเวลา — flagged 2026-06, ตรวจ techempower.com/benchmarks round ล่าสุดก่อนอ้าง)

เหตุผล (ระดับ chapter-0 — ยังไม่ต้องเข้าใจรายละเอียด):

  • JIT compiler ดีมาก — แปล IL → native ตอนรันได้เร็วและมี optimization หลายชั้น
  • GC (Garbage Collector) ดี — เก็บกวาด memory โดยไม่ทำให้แอปสะดุดบ่อย
  • BCL ถูก optimized สำหรับ workload production — ใช้เครื่องมือจัดการ memory ขั้นสูงอย่าง Span<T>, Memory<T>, SIMD, unsafe (โหมดที่ยอมให้เข้าถึง memory ตรง ๆ แบบ C/C++) เพื่อลดการ copy ข้อมูล
  • AOT (Native AOT) ตัดงาน JIT ออกตอนรัน → startup เร็ว binary เล็ก
  • Kestrel (web server ของ .NET) เขียนใหม่ใน C# ใช้ pattern memory ขั้นสูงข้างต้น

💡 ศัพท์ Span<T> / Memory<T> / SIMD / unsafe ไม่ต้องเข้าใจตอนนี้ ให้รู้แค่ว่าเป็น "เครื่องมือจัดการ memory ขั้นสูง" ที่ทีม runtime ใช้ปรับ performance — ใน app ทั่วไปไม่ต้องเขียนเอง

❗ แต่ "ภาษาเร็ว" ไม่ได้แปลว่า "app ของคุณจะเร็ว" — database query / network / business logic ต่างหากที่เป็นจุดคอขวด (bottleneck) ส่วนใหญ่

10. โครงเรื่องของหนังสือเล่มนี้ ​

หนังสือเล่มนี้สอน C# ในฐานะภาษา ก่อน — ไม่แตะ ASP.NET Core, EF Core, Blazor — เพราะถ้าภาษาแน่นแล้ว framework เรียนต่อง่ายมาก

ส่วน C# มีบท 0–12 รวม 13 บท — ดูรายการบทครบทั้งหมดได้ที่ สารบัญ C#

ส่วน ASP.NET Core (REST API, web app) อยู่ในเล่ม dotnet/ แยก

ลำดับการเรียนรู้แนะนำ:

text
csharp/ บท 0-12 → dotnet/ บท 0-8 → [database](../database/README.md) → [api-design](../api-design/README.md)

🛠️ Checkpoint 0 — ก่อนไปบทถัดไป ​

ไม่ต้องเขียนโค้ด แต่ตอบคำถามต่อไปนี้ในใจ (หรือจดไว้):

  1. .NET Framework กับ .NET (5+) ต่างกันยังไง? เลือกอะไรสำหรับโปรเจกต์ใหม่?
  2. C# คืออะไร — เทียบกับ .NET ได้อย่างไร
  3. CLR ทำหน้าที่อะไร เปรียบเทียบกับ JVM ได้ไหม
  4. NuGet คืออะไร
  5. ถ้าทีมคุณใช้ Azure อยู่แล้ว — C# น่าสนใจขึ้นไหม เพราะอะไร

สรุปบทที่ 0 ​

  • C# = ภาษา, .NET = runtime
  • ใช้ .NET 8+ สำหรับโปรเจกต์ใหม่ (cross-platform, open source)
  • CLR + JIT + GC = engine ที่ทำให้ C# ปลอดภัย + เร็ว
  • C# = ภาษาที่ modern ที่สุดในกลุ่ม mainstream — feature ใหม่ทุกปี
  • Performance .NET 8+ อยู่ใน top tier

→ บทที่ 1: Setup + Hello World

🔤 Glossary · 📋 Style guide · 📅 last_verified: 2026-06-12