Phương thức trong C#: tham số, giá trị trả về, params, overload, Main

Phương thức (method) là một khối code có tên, nhận đầu vào (tham số), thực hiện công việc của nó, và có thể trả lại một kết quả (giá trị trả về). Trong C#, mọi phương thức đều nằm bên trong một kiểu; không có hàm đứng độc lập.

using System;

class Program
{
    static decimal PriceWithTax(decimal net, decimal taxRate)
    {
        decimal tax = net * taxRate;
        return net + tax;
    }

    static void PrintReceipt(string item, decimal price)
    {
        Console.WriteLine($"{item,-10}{price,8:F2}");
    }

    static void Main()
    {
        decimal total = PriceWithTax(40m, 0.2m);
        PrintReceipt("Headphones", total);
        PrintReceipt("Cable", PriceWithTax(9.5m, 0.2m));
    }
}

Đầu ra:

Headphones   48.00
Cable        11.40

Cấu tạo của một phương thức

public static decimal PriceWithTax(decimal net, decimal taxRate)
{
    return net * (1 + taxRate);
}

• Access modifier (public, private, ...): ai được phép gọi nó. Nếu bỏ trống, phương thức là private trong kiểu của nó.
• static: phương thức thuộc về kiểu, không thuộc về một đối tượng. Xem thêm bên dưới.
• Kiểu trả về: kiểu của giá trị được trả về, hoặc void nếu không trả về gì.
• Tên: theo quy ước viết PascalCase, thường là một động từ (Calculate, SendEmail, TryParse).
• Danh sách tham số: không hoặc nhiều cặp type name. Mỗi tham số là một biến cục bộ được khởi tạo từ đối số của nơi gọi.
• Thân phương thức: các câu lệnh nằm giữa hai dấu ngoặc nhọn.

Tên cộng với kiểu của các tham số (và mọi modifier ref, out hoặc in) tạo thành chữ ký (signature) của phương thức. Kiểu trả về không thuộc chữ ký, điều này quan trọng khi overload.

Giá trị trả về và void

return kết thúc phương thức ngay lập tức và trả lại một giá trị. Phương thức có kiểu trả về phải trả về một giá trị đúng kiểu đó trên mọi nhánh:

static string Grade(int score)
{
    if (score >= 50)
        return "pass";
}   // error CS0161: 'Program.Grade(int)': not all code paths return a value

Trình biên dịch kiểm tra từng nhánh. Hãy thêm return "fail"; còn thiếu, hoặc một throw nếu việc chạy đến điểm đó là bug.

Phương thức void không trả về gì. Nó vẫn có thể dùng return; trơn để thoát sớm:

using System;

class Program
{
    static void Notify(string email, bool subscribed)
    {
        if (!subscribed)
        {
            Console.WriteLine($"{email}: not subscribed, skipped");
            return;
        }
        Console.WriteLine($"{email}: newsletter sent");
    }

    static bool IsStrongPassword(string pw)
    {
        if (pw.Length < 8) return false;
        foreach (char c in pw)
        {
            if (char.IsDigit(c)) return true;
        }
        return false;
    }

    static void Main()
    {
        Notify("ana@mail.com", true);
        Notify("ben@mail.com", false);
        Console.WriteLine(IsStrongPassword("sunshine"));
        Console.WriteLine(IsStrongPassword("sunshine42"));
    }
}

Đầu ra:

ana@mail.com: newsletter sent
ben@mail.com: not subscribed, skipped
False
True

Phương thức dạng biểu thức

Khi thân phương thức chỉ là một biểu thức, => thay cho dấu ngoặc nhọn và return:

static decimal Discount(decimal price) => price * 0.1m;
static bool IsAdult(int age) => age >= 18;
static void Log(string message) => Console.WriteLine($"[log] {message}");

Đây vẫn là cùng một phương thức, chỉ viết ngắn hơn. Cách này cũng dùng được cho phương thức void, miễn là thân là một biểu thức (một lời gọi, một phép gán).

Tham số là bản sao

Mặc định, đối số được truyền theo giá trị: tham số nhận một bản sao của đối số. Gán cho tham số bên trong phương thức không ảnh hưởng đến biến của nơi gọi:

using System;
using System.Collections.Generic;

class Program
{
    static void Double(int n)
    {
        n = n * 2;
        Console.WriteLine($"inside: {n}");
    }

    static void AddBonus(List<int> scores)
    {
        scores.Add(100);
    }

    static void Main()
    {
        int points = 21;
        Double(points);
        Console.WriteLine($"after:  {points}");

        var scores = new List<int> { 70, 85 };
        AddBonus(scores);
        Console.WriteLine($"scores: {string.Join(", ", scores)}");
    }
}

Đầu ra:

inside: 42
after:  21
scores: 70, 85, 100

List bị thay đổi vì với kiểu tham chiếu, giá trị được sao chép chính là tham chiếu: phương thức và nơi gọi cùng trỏ đến một đối tượng list. Gán lại scores = new List<int>() bên trong phương thức sẽ không ảnh hưởng đến nơi gọi. Để phương thức gán được cho biến của nơi gọi, dùng ref hoặc out; để đặt giá trị mặc định cho tham số và gọi theo tên, dùng tham số tùy chọn và đối số có tên.

Trả về nhiều giá trị bằng tuple

Từ C# 7.0, phương thức có thể trả về một tuple với các phần tử có tên, và nơi gọi có thể tách nó thành các biến riêng:

using System;

class Program
{
    static (int Min, int Max, double Average) Stats(int[] values)
    {
        int min = values[0], max = values[0], sum = 0;
        foreach (int v in values)
        {
            if (v < min) min = v;
            if (v > max) max = v;
            sum += v;
        }
        return (min, max, (double)sum / values.Length);
    }

    static void Main()
    {
        int[] temps = { 18, 24, 21, 15, 27 };

        var stats = Stats(temps);
        Console.WriteLine($"min {stats.Min}, max {stats.Max}, avg {stats.Average:F1}");

        var (lo, hi, _) = Stats(temps);
        Console.WriteLine($"range {hi - lo}");
    }
}

Đầu ra:

min 15, max 27, avg 21.0
range 12

_ bỏ đi phần tử bạn không cần. Với kết quả dùng ở nhiều nơi, một lớp nhỏ hoặc record với các thuộc tính có tên mô tả cấu trúc rõ hơn tuple.

Overload

Nhiều phương thức có thể dùng chung một tên nếu danh sách tham số khác nhau về số lượng, kiểu hoặc thứ tự các kiểu. Trình biên dịch chọn phương thức khớp nhất cho mỗi lời gọi:

using System;

class Program
{
    static double Area(double radius) => Math.PI * radius * radius;
    static double Area(double width, double height) => width * height;
    static int Area(int side) => side * side;

    static void Main()
    {
        Console.WriteLine(Area(2.0).ToString("F2"));
        Console.WriteLine(Area(3.0, 4.5).ToString("F2"));
        Console.WriteLine(Area(5));
    }
}

Đầu ra:

12.57
13.50
25

Area(5) chọn phiên bản int vì khớp chính xác; Area(2.0) chọn phiên bản double. Các phương thức không thể chỉ khác nhau ở kiểu trả về: hai phương thức Area(int) trả về int và double là lỗi CS0111, Type 'Program' already defines a member called 'Area' with the same parameter types, vì một lời gọi như Area(5) không thể phân biệt được chúng.

Một lời gọi không overload nào chấp nhận cũng lỗi lúc biên dịch: Area(1, 2, 3) là CS1501, No overload for method 'Area' takes 3 arguments, còn Area("big") là CS1503, Argument 1: cannot convert from 'string' to 'double'.

params: số lượng đối số tùy ý

Tham số mảng params nhận bao nhiêu đối số cũng được, kể cả không có đối số nào. Trình biên dịch tạo mảng giúp bạn:

using System;

class Program
{
    static decimal Total(string label, params decimal[] prices)
    {
        decimal sum = 0m;
        foreach (decimal p in prices) sum += p;
        Console.WriteLine($"{label}: {prices.Length} item(s), {sum}");
        return sum;
    }

    static void Main()
    {
        Total("empty cart");
        Total("one item", 9.99m);
        Total("three items", 4.50m, 12.00m, 3.25m);

        decimal[] saved = { 20m, 30m };
        Total("from array", saved);
    }
}

Đầu ra:

empty cart: 0 item(s), 0
one item: 1 item(s), 9.99
three items: 3 item(s), 19.75
from array: 2 item(s), 50

Quy tắc: params phải là tham số cuối cùng (nếu không sẽ gặp CS0231), mỗi phương thức có tối đa một, và truyền vào một mảng có sẵn thì mảng đó được chuyển nguyên vẹn. Console.WriteLine("{0} and {1}", a, b) và string.Format là các phương thức params object[]. C# 13 mở rộng params cho các kiểu collection khác như List<T> và ReadOnlySpan<T>; trước đó chỉ cho phép mảng.

Phương thức static và instance

Phương thức static thuộc về kiểu và được gọi qua tên kiểu: Math.Max(3, 7), Program.Total(...). Phương thức instance thuộc về một đối tượng và có thể dùng các field của đối tượng đó:

using System;

class Counter
{
    private int count;

    public void Increment() => count++;          // instance: uses this object's field
    public int Value() => count;

    public static Counter StartingAt(int n)       // static: no object needed to call it
    {
        var c = new Counter();
        c.count = n;
        return c;
    }
}

class Program
{
    static void Main()
    {
        Counter visits = Counter.StartingAt(10);
        visits.Increment();
        visits.Increment();
        Console.WriteLine(visits.Value());
    }
}

Đầu ra:

12

Gọi một phương thức instance từ một phương thức static mà không có đối tượng là lỗi phổ biến nhất của người mới học C#:

class Program
{
    void Greet() => Console.WriteLine("hi");

    static void Main()
    {
        Greet();
        // error CS0120: An object reference is required for the non-static field, method, or property 'Program.Greet()'
    }
}

Hãy đánh dấu Greet là static, hoặc tạo một đối tượng rồi gọi trên đó: new Program().Greet();. Trang về static trình bày kỹ hơn về thành viên static và lớp static.

Phương thức Main

Main là nơi chương trình bắt đầu. Nó phải là static, và các chữ ký sau đều hợp lệ:

static void Main() { }
static void Main(string[] args) { }            // command-line arguments
static int Main(string[] args) { return 0; }   // exit code for the shell
static async Task Main() { }                    // C# 7.1 and later

Dạng async Task Main cho phép điểm bắt đầu dùng await trực tiếp (xem async và await). Từ C# 9, một tệp có thể chứa top-level statement thay thế: code hoàn toàn không có lớp hay Main, như trong một dự án dotnet new console mới. Trình biên dịch sinh lớp và phương thức Main bao quanh nó, nên đây vẫn là cùng một thứ được viết ngắn hơn; args vẫn dùng được.

Đệ quy

Một phương thức có thể tự gọi chính nó. Mỗi lời gọi có tham số và biến cục bộ riêng, và phải có một trường hợp cơ sở để dừng chuỗi gọi:

using System;

class Program
{
    static long Factorial(int n)
    {
        if (n <= 1) return 1;            // base case
        return n * Factorial(n - 1);
    }

    static int DigitSum(int n) => n < 10 ? n : n % 10 + DigitSum(n / 10);

    static void Main()
    {
        Console.WriteLine(Factorial(5));
        Console.WriteLine(Factorial(20));
        Console.WriteLine(DigitSum(98765));
    }
}

Đầu ra:

120
2432902008176640000
35

Không có trường hợp cơ sở, hoặc với đầu vào quá sâu, mỗi lời gọi thêm một stack frame cho đến khi chương trình chết với StackOverflowException. Ngoại lệ này không bắt được, nên với đầu vào có độ sâu không biết trước, hãy viết lại đệ quy thành vòng lặp.

Hàm cục bộ

C# 7.0 giới thiệu hàm cục bộ (local function): phương thức khai báo bên trong một phương thức khác và chỉ thấy được ở đó. Chúng có thể dùng biến của phương thức bao quanh:

// C# 7.0 and later
static int CountValid(string[] codes)
{
    int count = 0;
    foreach (string code in codes)
    {
        if (IsValid(code)) count++;
    }
    return count;

    bool IsValid(string c) => c.Length == 6 && char.IsLetter(c[0]);
}

Chúng giữ một hàm phụ ngay cạnh nơi gọi duy nhất của nó mà không lộ ra cho phần còn lại của lớp. Từ C# 8 chúng có thể được đánh dấu static để cấm capture biến bên ngoài. Khi không dùng được hàm cục bộ, một phương thức private static trong cùng lớp làm được việc tương tự, như trong các ví dụ khác trên trang này.