1. Constructor đơn giản
Constructor — là một method đặc biệt của class, được gọi tự động khi tạo object. Nó sẽ khởi tạo (setup) object: gán giá trị ban đầu, kiểm tra dữ liệu, thậm chí có thể làm bạn vui nếu bạn viết joke trong đó.
Constructor giúp bạn tạo object ở trạng thái mong muốn ngay từ đầu, không phải gán từng field hay property thủ công. Cách này vừa tiện vừa an toàn, vì bạn truyền hết các tham số quan trọng ngay lúc tạo — không sợ quên cái gì quan trọng đâu.
Không có constructor thì code sẽ cồng kềnh và dễ lỗi lắm:
Person p = new Person();
p.Name = "Yulya";
p.Age = 25; // Nếu quên gán tuổi thì sao?
Có constructor thì:
Person p = new Person("Yulya", 25); // Truyền hết một lần, object sẵn sàng luôn!Cú pháp constructor
Constructor là một "method" đặc biệt, tên giống hệt tên class và không có kiểu trả về (ngay cả void cũng không). Đây là constructor mặc định:
public class Person
{
// Constructor mặc định (không tham số)
public Person()
{
// Viết code khởi tạo ở đây
}
}
Constructor mặc định là một "trợ lý" vô hình, không nhận tham số nào và chỉ khởi tạo các field, property của class với giá trị mặc định:
- Với kiểu số (int, double, float v.v.) sẽ là 0.
- Với kiểu bool (bool) là false.
- Với kiểu tham chiếu (string, các class khác) là null (tức là "không có gì", "không trỏ tới object nào").
- Với DateTime là 01.01.0001 00:00:00.
Làm sao gọi constructor?
Khi bạn viết lệnh new để tạo object, tức là bạn đang gọi constructor đó!
Person p = new Person();
Nếu bạn không tự định nghĩa constructor nào, compiler C# sẽ tạo cho bạn constructor mặc định (không tham số). Nhưng nếu bạn tự viết ít nhất một constructor, constructor mặc định sẽ biến mất, và compiler sẽ nhắc bạn tự thêm vào nếu cần.
Ví dụ
Thêm constructor vào class của app nhé. Đây là version đơn giản của class sinh viên:
public class Student
{
public string Name;
public int Age;
// Constructor với hai tham số (tên và tuổi)
public Student(string name, int age)
{
Name = name; // Gán giá trị cho field
Age = age;
}
}
Bây giờ tạo sinh viên như này:
Student s = new Student("Ivan", 21);
Console.WriteLine($"{s.Name}: {s.Age} tuổi"); // Ivan: 21 tuổi
- Mình khai báo constructor cùng visibility (public) như class.
- Trong constructor gán giá trị cho field bằng tham số truyền vào.
- Cách này giúp tránh quên: compiler sẽ bắt bạn truyền tên và tuổi khi tạo object.
2. Tham số của constructor
Trong C#, bạn có thể khai báo nhiều constructor với các bộ tham số khác nhau. Cái này gọi là overload constructor (overload method sẽ nói sau).
Ví dụ, thêm constructor không tham số:
public class Student
{
public string Name;
public int Age;
// Constructor mặc định
public Student()
{
Name = "KhongTen";
Age = 0;
}
// Constructor có tham số
public Student(string name, int age)
{
Name = name;
Age = age;
}
}
Bây giờ dùng được cả hai kiểu:
Student s1 = new Student(); // Tên: KhongTen, tuổi: 0
Student s2 = new Student("Olya", 22); // Tên: Olya, tuổi: 22
Dùng constructor để kiểm tra dữ liệu
Constructor là chỗ tuyệt vời để kiểm tra "chất lượng" dữ liệu truyền vào. Ví dụ, sinh viên không thể có tuổi âm!
public Student(string name, int age)
{
if (age < 0)
throw new ArgumentException("Tuổi không thể âm!");
Name = name;
Age = age;
}
Giờ nếu ai đó tạo sinh viên Student("Malish", -2), app sẽ ném exception (ArgumentException). Cách này hay dùng để đảm bảo dữ liệu "chắc như bê tông".
3. Khởi tạo object phức tạp
Nhiều khi trong app thực tế, một object không chỉ gồm các kiểu đơn giản mà còn chứa object khác:
public class Group
{
public string GroupName;
public Student[] Students;
public Group(string groupName, Student[] students)
{
GroupName = groupName;
Students = students;
}
}
Bây giờ dễ dàng tạo group với danh sách sinh viên:
var students = new Student[]
{
new Student("Ivan", 20),
new Student("Maria", 19)
};
Group g = new Group("Nhom-101", students);
Khởi tạo field mặc định
Đôi khi bạn muốn gán giá trị mặc định cho một số field nếu không truyền đủ tham số vào constructor. Ví dụ, email không bắt buộc:
public Student(string name, int age)
{
Name = name;
Age = age;
Email = "unknown@noemail.com"; // Giá trị mặc định
}
4. Khởi tạo bằng Object Initializer
Bạn có thể kết hợp constructor với cú pháp tiện lợi khác — object initializer. Gọi constructor xong, trong dấu ngoặc nhọn gán thêm property cho object mới:
public class Student
{
public string Name { get; set; }
public int Age { get; set; }
public string Email { get; set; }
// Vẫn nên có constructor
public Student(string name, int age)
{
Name = name;
Age = age;
Email = "";
}
}
Student s = new Student("Anton", 18) { Email = "anton@domain.com" }; // constructor + property
Cú pháp này rất hợp khi có constructor, một số tham số có giá trị mặc định hoặc không phải lúc nào cũng biết khi tạo object.
5. Lỗi phổ biến và lưu ý
Làm việc với constructor, newbie hay gặp mấy lỗi phổ biến. Cùng xem qua nhé:
Lỗi #1: Trùng tên
Đôi khi nhầm giữa tên tham số và field, nhất là khi chỉ khác nhau chữ hoa/thường.
public Student(string Name, int Age) // Viết hoa!
{
Name = Name; // Ôi! Cả hai Name đều là tham số. Field không được gán giá trị.
}
Cách đúng: Dùng this để trỏ tới field của object:
public Student(string name, int age)
{
this.Name = name;
this.Age = age;
}
Hoặc đặt tên khác (ví dụ nameParam, ageParam), nhưng dùng this. là best practice, nhất là khi làm project lớn.
Lỗi #2: Không có constructor mặc định
Nếu bạn đã khai báo ít nhất một constructor, rồi lại tạo object không truyền tham số — sẽ bị lỗi compile:
public class Student
{
public Student(string name) { /*...*/ }
}
// đâu đó trong code
Student s = new Student(); // Lỗi! Không có constructor không tham số.
Cách giải quyết: Thêm constructor không tham số rõ ràng:
public Student() { /*...*/ }
Lỗi #3: Đệ quy vô hạn — constructor tự gọi chính nó
public Student()
{
// Lỗi! Tự gọi chính mình — đệ quy vô hạn.
new Student();
}
GO TO FULL VERSION