Method, tham số và overloading hoạt động như thế nào?

Question

Accepted Answer

**Method** là các hàm được định nghĩa trong một class. C# hỗ trợ các tính năng tham số phong phú — đối số tùy chọn/đặt tên, các modifier `ref`/`out`/`in`, mảng `params` — và **method overloading** (nhiều method cùng tên nhưng khác tham số).

## Định nghĩa method

```csharp
public int Add(int a, int b) => a + b;          // dạng biểu thức (gọn)

public string Greet(string name, string greeting = "Hello")   // tham số mặc định
{
    return $"{greeting}, {name}";
}
Greet("Ann");                       // "Hello, Ann"
Greet("Ann", greeting: "Hi");        // đối số đặt tên
```

Method chỉ định một kiểu trả về, tên và tham số. **Tham số mặc định** làm cho đối số trở nên tùy chọn, còn **đối số đặt tên** cho phép truyền theo tên (rõ ràng hơn, có thể bỏ qua tham số tùy chọn).

## Các modifier tham số: ref, out, in

```csharp
// ref — truyền theo tham chiếu (method có thể sửa biến của caller)
void Increment(ref int x) { x++; }
int n = 5; Increment(ref n);   // n giờ là 6

// out — để trả về nhiều giá trị (phải được gán trong method)
bool TryParse(string s, out int result) { result = ...; return true; }
if (int.TryParse("42", out int value)) { }   // mẫu TryX phổ biến

// in — truyền theo tham chiếu nhưng CHỈ-ĐỌC (hiệu năng cho struct lớn)
void Process(in LargeStruct data) { }
```

`out` được dùng rộng rãi trong **mẫu TryParse** (trả về một cờ thành công cùng kết quả một cách an toàn); `ref` cho phép sửa biến của caller; `in` truyền struct lớn hiệu quả mà không sao chép.

## params và overloading

```csharp
// params — số lượng đối số thay đổi
int Sum(params int[] numbers) => numbers.Sum();
Sum(1, 2, 3, 4);    // số lượng bất kỳ

// OVERLOADING — cùng tên, khác tham số
void Print(int x) { }
void Print(string s) { }
void Print(int x, int y) { }
Print(5);           // gọi phiên bản int — phân giải theo kiểu đối số
```

**Overloading** cho phép nhiều method dùng chung một tên, phân biệt theo kiểu/số lượng tham số — compiler chọn cái khớp. `params` chấp nhận số lượng đối số thay đổi.

## Tại sao điều này quan trọng

Method là các viên gạch xây nên hành vi trong C#, và hiểu các tính năng tham số phong phú của chúng là quan trọng để viết code linh hoạt, biểu cảm.

Biết cách định nghĩa method (gồm cú pháp dạng biểu thức gọn), dùng **tham số mặc định và đặt tên** (cho đối số tùy chọn và lời gọi dễ đọc), và áp dụng **method overloading** (cùng tên, khác tham số — cho các API trực quan xử lý các kiểu đối số khác nhau) là kiến thức hằng ngày.

Các **modifier tham số** đặc biệt quan trọng để hiểu: **`out`** được dùng rộng rãi trong **mẫu TryParse** phổ biến (`int.TryParse(s, out var result)` — trả về cờ thành công và kết quả một cách an toàn không cần exception, một mẫu C# phổ biến, đúng thành ngữ), **`ref`** cho phép sửa biến của caller, và **`in`** truyền struct lớn theo tham chiếu để có hiệu năng.

Hiểu những điều này — method, các tính năng tham số (tùy chọn/đặt tên/params), overloading cho API linh hoạt, và các modifier ref/out/in (đặc biệt là thành ngữ TryParse dựa trên out) — là nền tảng cả khi viết method C# lẫn khi dùng nhiều API .NET vốn dựa vào các tính năng này.

Vì method và tham số của chúng là trung tâm của mọi code C#, và vì các tính năng như overloading, tham số tùy chọn và mẫu TryX xuất hiện liên tục, làm chủ chúng là kiến thức cốt lõi, bắt buộc phải biết để phát triển C# hiệu quả.