Ngày 3 — C# nâng cao

List<int> list = new();
list.Add(1);                  // không boxing — int lưu thẳng
// list.Add("hello");          // ❌ compile error — type safety

int x = list[0];               // không cast

// Generic method
public static T Identity<T>(T x) => x;

Identity(42);              // T = int (inferred)
Identity<string>("hi");    // T = string (explicit)

// Generic class
public class Box<T> {
    public T Value { get; }
    public Box(T value) => Value = value;
    public Box<U> Map<U>(Func<T, U> fn) => new Box<U>(fn(Value));
}

var intBox = new Box<int>(42);
var strBox = intBox.Map(n => n.ToString());     // Box<string>

// Generic interface
public interface IRepository<T> where T : class {
    Task<T?> GetByIdAsync(int id);
    Task AddAsync(T entity);
}

// T phải có constructor để new() được
public class Factory<T> where T : new() {
    public T Create() => new T();
}

// Combine — Repository chỉ chấp nhận class implement IEntity, có ctor
public abstract class Repository<T> where T : class, IEntity, new() {
    public T CreateBlank() => new T();
    // ...
}

var list = new List<int>();    // Capacity = 0
list.Add(1);                   // Capacity = 4 (default initial)
list.Add(2); list.Add(3); list.Add(4);    // Capacity = 4
list.Add(5);                   // Capacity = 8 (×2)
// ... đầy 8 → next 16 → 32 → 64...

IEnumerable<T>            ← chỉ foreach
    ↓
ICollection<T>            ← thêm Count, Add, Remove
    ↓
IList<T>                  ← thêm indexer [i], Insert, RemoveAt
    ↓
List<T>                   ← concrete

public IEnumerable<int> EvenNumbers(int max) {
    for (int i = 0; i <= max; i += 2) {
        yield return i;
    }
}

foreach (var n in EvenNumbers(10)) Console.WriteLine(n);

var users = new List<User> {
    new("Alice", 25, "HCM"),
    new("Bob",   30, "HN"),
    new("Charlie", 22, "HCM"),
};

// Filter
users.Where(u => u.City == "HCM");

// Project
users.Select(u => new { u.Name, u.Age });

// Sort
users.OrderBy(u => u.City).ThenByDescending(u => u.Age);

// Group
users.GroupBy(u => u.City)
     .Select(g => new { City = g.Key, Count = g.Count() });

// Aggregate
users.Count();
users.Sum(u => u.Age);
users.Average(u => u.Age);
users.Min(u => u.Age);
users.Max(u => u.Age);

// Predicate
users.Any(u => u.Age > 25);          // có ai > 25?
users.All(u => u.Age >= 18);         // tất cả >= 18?

// Element
users.First(u => u.Name == "Alice");           // không có → exception
users.FirstOrDefault(u => u.Name == "X");      // không có → null/default
users.Single(u => u.City == "HCM");            // CHÍNH XÁC 1 phần tử, khác → exception

// Set
users.Distinct();
users.Skip(2).Take(3);                          // pagination

// Join
var orders = new List<Order> { /*...*/ };
users.Join(orders,
    u => u.Id, o => o.UserId,
    (u, o) => new { u.Name, o.Total });

// ❌ Lấy HẾT user về client rồi mới filter
IEnumerable<User> all = dbContext.Users;    // .AsEnumerable() ép thành IEnumerable
var hcm = all.Where(u => u.City == "HCM").ToList();
// → SQL: SELECT * FROM Users (lấy hết 1 triệu user về RAM!)

// ✅ Filter ở DB
IQueryable<User> q = dbContext.Users;       // mặc định là IQueryable
var hcm = q.Where(u => u.City == "HCM").ToList();
// → SQL: SELECT * FROM Users WHERE City = 'HCM' (chỉ lấy data cần)

var q = users.Where(u => u.Age > 25);     // CHƯA chạy
users.Add(new("Eve", 50, "HCM"));         // thêm sau

foreach (var u in q) Console.WriteLine(u.Name);
// Eve xuất hiện! Vì query chạy lúc foreach.

var q = dbContext.Users.Where(u => u.Active);

Console.WriteLine(q.Count());         // SELECT COUNT(*) FROM Users WHERE Active = 1
foreach (var u in q) { ... }          // SELECT * FROM Users WHERE Active = 1 — gọi LẦN 2!

public static IEnumerable<T> Where<T>(this IEnumerable<T> src, Func<T, bool> pred) {
    foreach (var item in src) {
        if (pred(item)) yield return item;
    }
}

src.Where(...).Select(...).Take(5)
// = Where wraps src
// = Select wraps Where
// = Take wraps Select
// Khi enumerate Take → pull 1 phần tử qua Select → qua Where → từ src

// Định nghĩa delegate type
public delegate int MathOp(int a, int b);

// Tạo instance
MathOp add = (a, b) => a + b;
MathOp sub = (a, b) => a - b;

// Gọi như method
Console.WriteLine(add(2, 3));    // 5
Console.WriteLine(sub(5, 2));    // 3

// Truyền delegate vào method khác
int Apply(MathOp op, int x, int y) => op(x, y);
Apply(add, 10, 20);              // 30

Action<string> log = msg => Console.WriteLine(msg);
Func<int, int, int> mul = (a, b) => a * b;
Func<string, bool> isEmpty = s => string.IsNullOrEmpty(s);

// Truyền vào LINQ
var names = users.Select((Func<User, string>)(u => u.Name));    // hiếm khi cần cast — tự inferred

// Lambda expression — 1 expression
Func<int, int> sq = x => x * x;

// Lambda statement — nhiều dòng, dùng {}
Func<int, int> abs = x => {
    if (x < 0) return -x;
    return x;
};

// Không tham số
Action greet = () => Console.WriteLine("Hi");

// Nhiều tham số
Func<int, int, int> add = (a, b) => a + b;

// Type explicit (đôi khi cần)
Func<int, int> doubled = (int x) => x * 2;

int multiplier = 3;
Func<int, int> times = x => x * multiplier;    // bắt `multiplier`

multiplier = 10;
Console.WriteLine(times(5));    // 50 — đọc giá trị MỚI của multiplier!

public class StockTicker {
    // Event = delegate được wrap để class ngoài chỉ += / -=, không Invoke
    public event EventHandler<PriceChangedEventArgs>? PriceChanged;
    
    public void UpdatePrice(string symbol, decimal newPrice) {
        // Class chủ tự fire event
        PriceChanged?.Invoke(this, new PriceChangedEventArgs(symbol, newPrice));
    }
}

public class PriceChangedEventArgs : EventArgs {
    public string Symbol { get; }
    public decimal NewPrice { get; }
    public PriceChangedEventArgs(string s, decimal p) { Symbol = s; NewPrice = p; }
}

// Subscribe
var ticker = new StockTicker();
ticker.PriceChanged += (sender, e) => Console.WriteLine($"{e.Symbol}: {e.NewPrice}");
ticker.PriceChanged += SaveToDatabase;       // method reference

ticker.UpdatePrice("AAPL", 150.5m);
// 2 subscriber chạy lần lượt

public static class StringExtensions {
    public static bool IsValidEmail(this string s) {
        return s.Contains('@') && s.Contains('.');
    }
    
    public static string Repeat(this string s, int times) {
        return string.Concat(Enumerable.Repeat(s, times));
    }
}

// Dùng như method của string
"a@b.com".IsValidEmail();    // true
"Ha".Repeat(3);              // "HaHaHa"

"hi".Repeat(3)
// thành:
StringExtensions.Repeat("hi", 3)

namespace System.Linq {
    public static class Enumerable {
        public static IEnumerable<T> Where<T>(this IEnumerable<T> src, Func<T, bool> pred) {...}
        public static IEnumerable<U> Select<T, U>(this IEnumerable<T> src, Func<T, U> sel) {...}
        // ...
    }
}

public async Task<string> GetUserAsync(int id) {
    var http = new HttpClient();
    var json = await http.GetStringAsync($"/api/users/{id}");
    return json;
}

public Task<string> GetUserAsync(int id) {
    var sm = new GetUserStateMachine {
        id = id,
        state = -1
    };
    sm.MoveNext();     // start
    return sm.Task;
}

class GetUserStateMachine : IAsyncStateMachine {
    public int state;
    public int id;
    public TaskCompletionSource<string> Task;
    public HttpClient http;
    public TaskAwaiter<string> awaiter;
    
    public void MoveNext() {
        switch (state) {
            case -1:
                http = new HttpClient();
                var task = http.GetStringAsync($"/api/users/{id}");
                awaiter = task.GetAwaiter();
                if (!awaiter.IsCompleted) {
                    state = 0;
                    awaiter.OnCompleted(MoveNext);    // schedule callback, return!
                    return;
                }
                goto case 0;
                
            case 0:
                string json = awaiter.GetResult();
                Task.SetResult(json);
                return;
        }
    }
}

// ✅ I/O bound — async trực tiếp
public async Task<User> GetUserAsync(int id) {
    return await _db.Users.FindAsync(id);
}

// ✅ CPU bound — offload
public async Task<int> CalculatePrimesAsync(int limit) {
    return await Task.Run(() => CountPrimes(limit));    // CountPrimes nặng CPU
}

// ❌ Sai — Task.Run cho I/O work là vô nghĩa
public async Task<User> GetUserBad(int id) {
    return await Task.Run(() => _db.Users.FindAsync(id));    // thêm 1 thread vô ích
}

// Thread thủ công — hiếm dùng
var t = new Thread(() => HeavyWork());
t.Start();
t.Join();    // chờ xong

// Task — chuẩn hiện đại
var task = Task.Run(() => HeavyWork());
await task;

// Multiple parallel
var tasks = users.Select(u => FetchOrdersAsync(u.Id)).ToList();
await Task.WhenAll(tasks);

// ❌ Deadlock kinh điển ASP.NET classic
public IActionResult Index() {
    var user = GetUserAsync(1).Result;    // deadlock!
    return View(user);
}

// ✅ Async all the way
public async Task<IActionResult> Index() {
    var user = await GetUserAsync(1);
    return View(user);
}

// ❌ Thường sai
public async void DoStuff() {
    await SomeAsync();
}

// ✅ Đúng — không await được, exception khó catch
public async Task DoStuff() {
    await SomeAsync();
}

// ✅ Event handler — exception case
button.Click += async (sender, e) => {
    await SaveAsync();    // OK
};

// Library code — không depend SynchronizationContext của caller
public async Task<User> GetUserAsync(int id) {
    var data = await _http.GetStringAsync(...).ConfigureAwait(false);
    return Parse(data);
}