Ngày 1 — C# cơ bản

┌─────────────────────────────────────┐
│           PROCESS MEMORY            │
├─────────────────────────────────────┤
│  STACK (1MB mặc định / thread)      │  ← grows downward
│  ┌─────────────────────┐            │
│  │ Frame of Main()     │            │
│  ├─────────────────────┤            │
│  │ Frame of CalcSum()  │            │
│  ├─────────────────────┤            │
│  │ Frame of GetUser()  │  ← active  │
│  └─────────────────────┘            │
│         ...                         │
│                                     │
│         (free space)                │
│                                     │
│                                     │
│           HEAP                      │  ← grows upward
│  ┌─────────────┐                    │
│  │ User obj    │                    │
│  └─────────────┘                    │
│  ┌─────────────────────┐            │
│  │ string "hello"      │            │
│  └─────────────────────┘            │
│  ┌──┐                               │
│  │..│  Gen 0, Gen 1, Gen 2 (GC)     │
│  └──┘                               │
└─────────────────────────────────────┘

class User {
    public int Id;
    public string Name;
}

void Run() {
    int x = 5;
    User u = new User { Id = 1, Name = "Alice" };
}

STACK (frame của Run)             HEAP
┌────────────────────┐           ┌─────────────────────────┐
│ x = 5              │           │ User object             │
│ u = 0x7f3a1c00 ────┼─────────► │   Id = 1                │
│ (con trỏ heap)     │           │   Name = 0x7f3a2400 ────┼──┐
└────────────────────┘           │   (con trỏ tới string)  │  │
                                 └─────────────────────────┘  │
                                 ┌─────────────────────────┐  │
                                 │ string "Alice" ◄────────┼──┘
                                 └─────────────────────────┘

int a = 5;
int b = a;       // copy giá trị 5 vào b
b = 10;          // chỉ b đổi, a giữ nguyên
Console.WriteLine(a);    // 5
Console.WriteLine(b);    // 10

Trước b = 10:           Sau b = 10:
a = 5                   a = 5
b = 5                   b = 10

int[] arr1 = { 1, 2, 3 };
int[] arr2 = arr1;       // arr2 và arr1 trỏ CÙNG mảng
arr2[0] = 99;            // sửa qua arr2
Console.WriteLine(arr1[0]);    // 99 (cùng object!)

STACK                    HEAP
arr1 ──┐                 ┌───────────────┐
       ├──► [1, 2, 3] →  │ [99, 2, 3]    │
arr2 ──┘                 └───────────────┘

void ModifyInt(int x) { x = 100; }
void ModifyArr(int[] a) { a[0] = 100; }
void ReplaceArr(int[] a) { a = new int[] { 99 }; }   // gán parameter

int n = 5;
ModifyInt(n);
Console.WriteLine(n);          // 5 — không đổi (value type copy)

int[] arr = { 1, 2, 3 };
ModifyArr(arr);
Console.WriteLine(arr[0]);     // 100 — thay đổi (sửa qua reference cùng object)

ReplaceArr(arr);
Console.WriteLine(arr[0]);     // 100 — không phải 99! ReplaceArr chỉ đổi con trỏ local

Trước ReplaceArr:
caller: arr ──► [100, 2, 3]
              ▲
ReplaceArr:   a ┘    (cùng object)

Sau `a = new int[]{99}` bên trong ReplaceArr:
caller: arr ──► [100, 2, 3]
ReplaceArr:   a ──► [99]   (a giờ trỏ object mới, không động arr)

void ReplaceArrRef(ref int[] a) { a = new int[] { 99 }; }
int[] arr = { 1, 2, 3 };
ReplaceArrRef(ref arr);
Console.WriteLine(arr[0]);     // 99 — vì ref truyền địa chỉ của con trỏ

string a = "hello";
string b = "hello";
Console.WriteLine(a == b);              // True — overloaded == so sánh nội dung
Console.WriteLine(ReferenceEquals(a, b)); // True — string interning!

string c = new string("hello".ToCharArray());     // ép tạo object mới
Console.WriteLine(a == c);                        // True — nội dung giống
Console.WriteLine(ReferenceEquals(a, c));         // False — 2 object khác nhau

int x = 42;          // x là value type, trên stack
object o = x;        // BOXING: tạo object trên heap chứa giá trị 42, o trỏ tới object đó
int y = (int)o;      // UNBOXING: ép o về int, copy giá trị ra

STACK              HEAP
x = 42             ┌──────────────┐
o ───────────────► │ box: int 42  │
y = 42             └──────────────┘

// 1. Gán value type vào object hoặc interface
object o = 42;
IComparable c = 42;

// 2. Truyền vào method nhận object
Console.WriteLine("x = " + 42);     // 42 boxed thành object để + với string

// 3. Lưu vào collection non-generic (legacy)
ArrayList list = new ArrayList();
list.Add(42);                        // boxing!
list.Add(true);                      // boxing!

// 4. Format string nhiều khi
string s = string.Format("x = {0}", 42);   // 42 boxed (less so với interpolation modern)

// ❌ Boxing mỗi lần Add
ArrayList legacy = new ArrayList();
for (int i = 0; i < 1_000_000; i++) {
    legacy.Add(i);          // 1 triệu lần boxing!
}

// ✅ Không boxing
List<int> modern = new List<int>();
for (int i = 0; i < 1_000_000; i++) {
    modern.Add(i);          // không boxing — int lưu thẳng trong array
}

string s = "Hello";
s = s + " World";        // KHÔNG sửa "Hello" — tạo chuỗi mới "Hello World"
                         // s giờ trỏ tới chuỗi mới
                         // "Hello" cũ thành rác

Bước 1 — string s = "Hello":
STACK            HEAP
s ─────────────► "Hello"

Bước 2 — s = s + " World":
STACK            HEAP
s ─────────────► "Hello World"   (mới)
                 "Hello"           (rác)
                 " World"          (literal, có thể intern)

string result = "";
for (int i = 0; i < 10_000; i++) {
    result += i.ToString();
}

var sb = new StringBuilder();
for (int i = 0; i < 10_000; i++) {
    sb.Append(i);
}
string result = sb.ToString();        // 1 lần tạo chuỗi cuối

STACK            HEAP
sb ────────────► StringBuilder { char[] buffer = [...mutable...] }
                 Khi đầy → cấp array mới gấp đôi, copy sang

class Point { public int X, Y; }

var p1 = new Point { X = 1, Y = 2 };
var p2 = new Point { X = 1, Y = 2 };
var p3 = p1;

p1 == p2;            // False — 2 object khác nhau, không override ==
p1 == p3;            // True  — cùng object
p1.Equals(p2);       // False — default Equals = reference
ReferenceEquals(p1, p2);   // False
ReferenceEquals(p1, p3);   // True

class Point : IEquatable<Point> {
    public int X, Y;
    
    public override bool Equals(object? obj) => obj is Point p && Equals(p);
    public bool Equals(Point? other) => other != null && X == other.X && Y == other.Y;
    public override int GetHashCode() => HashCode.Combine(X, Y);
    
    public static bool operator ==(Point a, Point b) => a.Equals(b);
    public static bool operator !=(Point a, Point b) => !a.Equals(b);
}

public class Config {
    public const double Pi = 3.14159;                       // compile inline
    public readonly DateTime CreatedAt;                     // per-instance
    public static readonly string Version = LoadVersion();  // 1 lần khi class load
    
    public Config() {
        CreatedAt = DateTime.UtcNow;                        // mỗi new Config(), CreatedAt khác
    }
    
    private static string LoadVersion() => "1.0.0";
}

int? age = null;
Console.WriteLine(age.HasValue);     // False
// Console.WriteLine(age.Value);     // throws

age = 25;
Console.WriteLine(age.HasValue);     // True
Console.WriteLine(age.Value);        // 25

// Cú pháp tắt
int safeAge = age ?? 0;              // ?? trả 0 nếu null

string name = null;       // ⚠ Compiler warning: CS8600
string? maybeName = null; // OK

void Print(string s) {
    Console.WriteLine(s.Length);          // OK — compiler tin s không null
}

void PrintMaybe(string? s) {
    Console.WriteLine(s.Length);          // ⚠ Warning: s có thể null
    Console.WriteLine(s?.Length ?? 0);    // OK — null-safe
}

string? GetName() => /* maybe null */;

// Chain an toàn
int len = GetName()?.Trim().Length ?? 0;

// Nếu chắc chắn không null (vd. vừa check) — dùng ! để tắt warning
if (name != null) {
    var upper = name!.ToUpper();   // hoặc compiler tự suy luận sau check
}

try {
    DoSomething();
}
catch (FileNotFoundException ex) {
    // Bắt cụ thể trước
    logger.Warn($"Missing file: {ex.FileName}");
    throw;        // rethrow — giữ stack trace gốc
}
catch (IOException ex) when (ex.HResult == -2147024864) {
    // Filter — chỉ catch nếu điều kiện đúng
    HandleSharingViolation();
}
catch (Exception ex) {
    // Catch-all — cuối cùng
    logger.Error(ex);
    throw new ApplicationException("Wrapped", ex);  // wrap với inner
}
finally {
    Cleanup();    // luôn chạy, kể cả exception hay return
}

try {
    File.ReadAllText("/missing.txt");
}
catch (FileNotFoundException ex) {
    // ❌ throw ex;  → stack trace chỉ tới dòng này, mất chỗ ReadAllText
    
    // ✅ Đúng
    throw;
    
    // ✅ Hoặc wrap có chủ ý — giữ inner exception
    throw new DataLoadException("Couldn't load config", ex);
}

// Cú pháp block
using (var stream = new FileStream("a.txt", FileMode.Open)) {
    // ...
}   // tự gọi stream.Dispose() ở đây

// C# 8+ — using declaration (tắt block, scope theo enclosing)
void Read() {
    using var stream = new FileStream("a.txt", FileMode.Open);
    // ... 
}   // stream.Dispose() khi method return

{
    var stream = new FileStream("a.txt", FileMode.Open);
    try { /* ... */ }
    finally { stream.Dispose(); }
}

for (int i = 1; i <= 100; i++) {
    if (i % 15 == 0) Console.WriteLine("FizzBuzz");
    else if (i % 3 == 0) Console.WriteLine("Fizz");
    else if (i % 5 == 0) Console.WriteLine("Buzz");
    else Console.WriteLine(i);
}

public static string Reverse(string s) {
    var arr = s.ToCharArray();
    Array.Reverse(arr);
    return new string(arr);
}

public static string ReverseManual(string s) {
    var arr = s.ToCharArray();
    int l = 0, r = arr.Length - 1;
    while (l < r) {
        (arr[l], arr[r]) = (arr[r], arr[l]);   // swap qua tuple
        l++;
        r--;
    }
    return new string(arr);
}

public static Dictionary<char, int> CountChars(string s) {
    var dict = new Dictionary<char, int>();
    foreach (var c in s) {
        if (dict.ContainsKey(c)) dict[c]++;
        else dict[c] = 1;
    }
    return dict;
}

public static Dictionary<char, int> CountChars(string s) {
    var dict = new Dictionary<char, int>();
    foreach (var c in s) {
        dict[c] = dict.GetValueOrDefault(c) + 1;
    }
    return dict;
}

public static bool IsPalindrome(string s) {
    int l = 0, r = s.Length - 1;
    while (l < r) {
        if (char.ToLower(s[l]) != char.ToLower(s[r])) return false;
        l++;
        r--;
    }
    return true;
}