Cấu trúc

Mảng cố định kích thước

Mảng động (có Capacity, tự tăng)

Bảng băm (bucket + hash)

Kích thước

Cố định (khởi tạo xong không đổi)

Linh hoạt (tự tăng Capacity)

Linh hoạt

Truy cập theo index

O(1)

O(1)

Không hỗ trợ

Duyệt tuần tự

O(n)

O(n)

O(n)

Thêm phần tử

Không (phải cấp phát lại)

Cuối danh sách: trung bình O(1); chèn giữa: O(n)

Trung bình O(1)

Tìm

O(n)

O(n)

Trung bình O(1)

Cho phép trùng lặp

Có

Có

Không (tập hợp duy nhất)

Duy trì thứ tự

Thứ tự chỉ số

Giữ thứ tự chèn

Không đảm bảo thứ tự

Khi nên dùng

Kích thước biết trước, tối đa hiệu năng/nhớ

Danh sách tổng quát, thêm/xóa không quá nhiều ở giữa

Kiểm tra tồn tại, phép toán tập hợp (union/intersect/diff)

Hạn chế

Cứng nhắc về kích thước

Thêm/xóa giữa tốn kém O(n)

Không truy cập theo index; overhead bộ nhớ lớn hơn

IsGeneric

Không (non-generic) → boxing với value types

Có (generic) → tránh boxing

Kiểu key/value

object/object

TKey/TValue

Null Key

Không cho phép

Không cho phép

Null Value

Cho phép (kiểu tham chiếu)

Cho phép (kiểu tham chiếu)

Hiệu năng trung bình

Thấp hơn do boxing + cast

Tốt hơn, đặc biệt với value types

An toàn kiểu (type-safety)

Thấp (dễ lỗi cast runtime)
Trả về null

Cao (kiểm tra compile-time)

Trả về exception

Thứ tự

Không đảm bảo

Không đảm bảo (thường là theo thứ tự chèn trên .NET hiện đại, đừng phụ thuộc)

Thread-safety

Không an toàn luồng.
Có thể bọc Hashtable.Synchronized (overhead cao)

Không an toàn luồng.

Dùng ConcurrentDictionary<,> cho đa luồng.

API

Cũ, chủ yếu vì tương thích legacy

Khuyến nghị mặc định trong hầu hết trường hợp

Khi nên dùng

Chỉ khi phải tương thích code cũ

Lựa chọn mặc định cho map/tra cứu key/value.

Loại so sánh mặc định

Kiểu tham chiếu (class): mặc định so sánh tham chiếu (trừ khi kiểu đó overload == (Ví dụ: string, record).

Kiểu giá trị (struct): chỉ một số kiểu dựng sẵn (int, double, bool, enum, char, …) có == sẵn và so sánh giá trị; với struct tự định nghĩa, không có == mặc định — muốn dùng phải tự overload.

Kiểu tham chiếu (class): mặc định là tham chiếu như == (trừ khi kiểu override Equals). string.Equals mặc định so sánh theo nội dung (giá trị).

Kiểu giá trị (struct): mặc định so sánh giá trị (field-by-field) thông qua ValueType.Equals, trừ khi bạn override/IEquatable.

Ghi đè / tuỳ biến

Có thể overload (không phải override) bằng cách khai báo public static bool operator ==(...).

Khi overload == phải overload luôn !=, và thường nên override Equals + GetHashCode cho nhất quán.

Có thể override (virtual method System.Object).

Với generics/hiệu năng, nên triển khai IEquatable<T>.Equals(T other) và đảm bảo tương thích với Equals(object) + GetHashCode().

Tính linh hoạt

Ít linh hoạt hơn (chỉ 1 toán tử; phải cẩn thận tương thích với Equals/GetHashCode).

Linh hoạt hơn: có thể override/triển khai IEquatable<T>, và có thêm object.Equals(a,b) (static) an toàn null. Với string.Equals có overload chọn StringComparison.

Tốc độ

Không có quy tắc “nhanh hơn” nói chung. Với string, == thực chất gọi string.Equals(a,b). Chênh lệch thường không đáng kể sau JIT inline.

Tương tự: phụ thuộc kiểu cụ thể và triển khai Equals. Dùng EqualityComparer<T>.Default để nhận cách so sánh tối ưu cho T.

Sử dụng với

null

An toàn (không ném NRE); a == null hợp lệ. Nếu tự overload, nhớ xử lý null đúng cách.

Gọi instance a.Equals(b) sẽ ném NRE nếu a là null. Dùng object.Equals(a,b) hoặc a?.Equals(b) ?? false để an toàn null.

Khái niệm

Là kiểu dữ liệu truyền thống. Không khai báo cụ thể khi định nghĩa class, method, interface. Kiểu dữ liệu thực tế được xác định khi sử dụng.

Là kiểu dữ liệu được tham số hoá bởi một hoặc nhiều kiểu khác nhau. Cho phép khai báo class, method, interface với kiểu cụ thể. Kiểu này sẽ được định nghĩa và sử dụng xuyên suốt.

Ưu điểm

Đơn giản, dễ hiểu

Hiệu quả cao hơn với các kiểu dữ liệu nguyên thuỷ

Tăng khả năng tái sử dụng code

Đảm bảo an toàn dữ liệu vào và ra khi sử dụng

Tốt hơn do được tối ưu hoá cho kiểu dữ liệu cụ thể

Nhược điểm

Kém linh hoạt, khó tái sử dụng.

Thiếu an toàn do có thể sử dụng sai kiểu dữ liệu

Phức tạp hơn so với non-generic.

Có thể ảnh hưởng hiệu suất với những kiểu dữ liệu phức tạp.

Sử dụng

Khi cần code đơn giản dễ hiểu, không yêu cầu tái sử dụng cao, không yêu cầu an toàn dữ liệu cao.

Khi cần code có khả năng tái sử dụng cao và yêu cầu tính an toàn dữ liệu cao.

- Là một tham chiếu đại diện cho phương thức.

- Có thể gọi trực tiếp từ bất kỳ đâu có quyền truy cập.

- Có thể gọi trực tiếp mà không có cơ chế bảo vệ nào nên có thể dẫn đến lỗi.

- Ưu tiên tính linh hoạt.

- Là thành phần của lớp sử dụng delegate để quản lý danh sách các phương thức.

- Chỉ có thể kích hoạt bên trong lớp mà nó được khai báo.

- Có cơ chế bảo vệ ngăn chặn gọi từ bên ngoài. Chỉ cho phép đăng ký bên trong class thông quan

+=

hoặc huỷ đăng ký qua

-=

- Ưu tiên an toàn và kiểm soát.

Bản chất

Kiểu giá trị (value type)

Kiểu tham chiếu (reference type)

Cấp phát & bộ nhớ

Nằm trên stack hoặc heap tùy vào nơi nó sống.

Sao chép theo giá trị

Luôn cấp phát trên heap, biến giữ tham chiếu

Sao chép tham chiếu

Vòng đời & GC

Không tạo đối tượng riêng trên heap ⇒ ít áp lực GC (trừ khi bị boxing)

Đối tượng do GC quản lý; cần cân nhắc phân bổ/thu hồi.

Kế thừa

Không kế thừa class; chỉ implement interface

Có inheritance + implement interface

Constructor mặc định

Luôn có default (zero-init); từ C# 10 có thể

tự định nghĩa constructor không tham số

Tự do định nghĩa constructor; không có zero-init bắt buộc

Nullability

Không thể null (trừ nullable struct T?)

Có thể null (nullable reference types)

Equality mặc định

So sánh theo giá trị (field-by-field)

So sánh tham chiếu (trừ khi override/record)

Boxing

Bị boxing khi chuyển sang object/interface (nếu không dùng generics ràng buộc) → phát sinh cấp phát

Không có khái niệm boxing

Bất biến/biến đổi

Nên thiết kế nhỏ & bất biến (immutable) để tránh chi phí copy

Linh hoạt cho đối tượng phức tạp, nhiều trạng thái

Hiệu năng (quy tắc thực tế)

Tốt cho dữ liệu nhỏ (≈ ≤ 16–32 byte), sống ngắn, dùng thường xuyên; tránh struct lớn/mutable vì tốn copy

Tốt cho mô hình phức tạp, cần chia sẻ qua tham chiếu, vòng đời dài

Generics

Tránh boxing với where T : struct; hỗ trợ Nullable<T>

Ràng buộc where T : class cho API dùng tham chiếu

Khi nên dùng

Để lưu những dữ liệu đơn giản, bất biến.

Đa phần các đối tượng có đối tượng có dữ liệu, hành vi phức tạp..

Unity lưu ý

Dùng struct (hoặc readonly struct) cho dữ liệu để giảm GC

Cẩn thận copy trong Update

Dùng class cho MonoBehaviour, managers, asset refs; quản lý GC bằng pooling

Định nghĩa

Là lớp nền tảng có biến chung và một phần code sẵn. Lớp con kế thừa và hoàn thiện.

Là bản hợp đồng liệt kê chức năng. Lớp/struct thực hiện (implement) các chức năng đó.

Access Modifiers

Có

Không. Mặc định là public

Field, Method dùng chung

Có

Có thể có method mặc định (từ C# 8 trở lên), nhưng không có field, constructor

Kế thừa / triển khai

Mỗi lớp chỉ kế thừa 1 abstract class.

Một lớp/struct có thể implement nhiều interface.

Dùng cho struct

Không dùng cho struct.

Dùng được cho struct.

Khi nên dùng

Dùng để tạo một bản thiết kế chung cho các đối tượng liên quan đến nhau. Cung cấp các chi tiết mà các đối tượng đó phải tuân theo.

Khi cần constructor.

Tạo ra một vai trò/chức năng mà các đối tượng triển khai nó sẽ đảm nhiệm.

Ưu điểm

Tái sử dụng code mạnh, quản lý chung dễ, thêm thành viên thường ít phá vỡ lớp con.

Linh hoạt, áp dụng rộng (kể cả struct), hỗ trợ nhiều vai trò, rất hợp cho test/DI.

Nhược điểm

Ràng buộc thừa kế (chỉ 1 lớp cha), dễ tạo cây thừa kế sâu nếu lạm dụng.

Không có dữ liệu chung; nếu thêm phương thức mới có thể ảnh hưởng kiểu đã implement (giảm rủi ro nhờ “method mặc định” từ C# 8).

Ví dụ Unity

BaseController, BaseState chứa biến/logic chung cho nhiều state.

IService, IRepository, ISaveSystem để tiêm phụ thuộc và viết unit test.

Bản chất

Vùng nhớ tạm cho biến cục bộ & method

Vùng nhớ động cho đối tượng sống lâu

Lưu gì

Giá trị của biến cục bộ (bao gồm struct nhỏ), con trỏ return address

Object của class, mảng, struct nằm trong object/mảng, dữ liệu boxed

Cấp phát/giải phóng

Rất nhanh theo kiểu LIFO, trong method

Linh hoạt: cấp phát tự do, thu gom bởi GC

Quản lý

Tự động khi vào/ra hàm (không có GC)

Managed heap do GC quản lý (Gen0/1/2, LOH)

Tốc độ

Rất nhanh, liên tục, cache-friendly

Chậm hơn stack; có thể bị tạm dừng (GC pause)

Kích thước

Giới hạn (stack size)

Rộng hơn, tùy RAM/GC

Thời gian sống

Ngắn, theo phạm vi hàm

Dài/linh hoạt, theo tham chiếu còn sống

Khi nào xảy ra

Biến cục bộ, tham số, struct cục bộ

new class, mảng; struct là field trong class/mảng; boxing

Lưu ý quan trọng

Dữ liệu biến mất khi ra khỏi hàm

Tránh rác nhiều/đối tượng lớn gây áp lực GC/LOH

Khái niệm

Vòng lặp theo index (i = 0..n-1)

Vòng lặp duyệt từng phần tử qua enumerator.

Cách hoạt động

Truy cập collection[i] mỗi bước

Gọi GetEnumerator() → MoveNext() → Current

Truy cập theo index

Có

Không có

Sửa phần tử

Có thể

Sửa phần tử chỉ định qua index

Không thể sửa trong vòng lặp

Thêm/Xóa khi lặp

Có thể làm được (cẩn thận cập nhật chỉ số; thường lặp ngược khi xóa)

Không được thay đổi collection đang duyệt → dễ ném InvalidOperationException

Hiệu năng (thực tế)

Rất nhanh cho mảng và khi cần truy cập ngẫu nhiên

Rất nhanh cho List (enumerator là struct, thường

không cấp phát); nhìn chung chênh lệch nhỏ, chọn theo độ rõ ràng

Độ rõ ràng mã

Tốt khi cần index/điều kiện bước nhảy tùy biến

Ngắn gọn, dễ đọc khi chỉ duyệt

Khi nên dùng

Cần index, cần chèn/xóa trong lúc lặp, hoặc cần nhảy bước

Duyệt đọc, không chỉnh sửa cấu trúc collection, code gọn

Lỗi thường gặp

Quên cập nhật i, truy cập vượt biên

Thêm/xóa trong vòng lặp.

Khởi tạo

Không thể new; không có instance

Có thể new; nhiều instance

Thành viên

Tất cả phải là static

Có cả instance và static

Kế thừa

Không kế thừa/không implement interface; ngầm sealed

Có thể kế thừa/implement interface

Dùng khi

Nhóm hàm tiện ích/hằng số không cần state riêng

Mô hình đối tượng có state/đa hình

Thuộc về

Class

Instance

Truy cập

Type.Member

obj.Member

Vòng đời

Tồn tại suốt thời gian chạy

Sống theo vòng đời instance (GC)

Trạng thái

Chung toàn cục → cần chú ý thread-safety

Tách biệt theo từng đối tượng

Dùng khi

Cấu hình bất biến, cache dùng chung, hằng số

Dữ liệu/hành vi gắn với một đối tượng