CodeGym /Các khóa học /C# SELF /Đóng stream và giải phóng tài nguyên ( using)

Đóng stream và giải phóng tài nguyên ( using)

C# SELF
Mức độ, Bài học
Có sẵn

1. Làm sao giải phóng tài nguyên đúng cách trong C#?

Hãy tưởng tượng hệ điều hành như một thủ thư khó tính. Bạn mượn sách (mở file/stream), đọc xong rồi... quên trả! Thủ thư sẽ la lên: "Sao sách vẫn còn ở chỗ bạn?!" Stream cũng vậy. Một stream mở sẽ chiếm tài nguyên: file descriptor, một ít bộ nhớ, và còn khóa file lại không cho app khác dùng.

Nếu không đóng stream, hậu quả có thể từ "cái gì đó không chạy" đến "mọi thứ hỏng hết, không ai ghi được vào file này". Nếu chương trình có nhiều stream không đóng — hệ thống có thể bị "rò rỉ" tài nguyên và ngưng hoạt động luôn.

Nguy hiểm ở đâu?

  • File không đóng, lệnh không ghi xuống ổ cứng (ví dụ khi ghi — dữ liệu có thể vẫn nằm trong buffer).
  • File bị khóa với process khác — đồng nghiệp và app khác sẽ bực mình.
  • Giới hạn descriptor: trên Windows/Linux, mỗi process đều có giới hạn file/stream mở cùng lúc.

Interface IDisposable

Bất kỳ class nào làm việc với tài nguyên unmanaged (stream, file, database, socket) đều phải implement interface IDisposable.


public interface IDisposable
{
    void Dispose();
}

Trong method Dispose() thường sẽ giải phóng hết các tài nguyên "tội nghiệp": file cuối cùng cũng được đóng, kết nối bị cắt, bộ nhớ được trả lại.

Stream là object giữ nhiều tài nguyên quan trọng: file, kết nối, bộ nhớ. Nếu không đóng, file có thể bị khóa (Word của bạn sẽ báo "file đang mở bởi ứng dụng khác!"), còn hệ thống thì hết RAM. Vì vậy, rất quan trọng phải giải phóng stream sau khi dùng xong.

Trong .NET, stream implement interface IDisposable. Nghĩa là: phải đóng chúng bằng cách gọi Dispose() (hoặc đơn giản là bọc trong block using).

2. Các cách đóng stream: từ nguy hiểm đến an toàn

Cách 1. Đóng "thủ công": đừng làm vậy!

Đây là cách cũ. Dù mình từng demo ở ví dụ trước, nhưng giờ gần như không ai dùng nữa :P


var stream = new FileStream("file.txt", FileMode.Open);
// Làm việc với stream
stream.Close(); // hoặc stream.Dispose()

Vấn đề: nếu giữa lúc mở và đóng có lỗi/exception, file sẽ bị mở và khóa luôn. Kiểu như bạn chạy khỏi thư viện với cuốn sách vì ngửi thấy mùi pizza...

Cách 2. Dùng try...finally


FileStream stream = null;
try
{
    stream = new FileStream("file.txt", FileMode.Open);
    // Làm việc với stream
}
finally
{
    if (stream != null)
        stream.Dispose();
}

Cách này an toàn: finally luôn chạy kể cả khi có lỗi. Nhưng thú thật, viết vậy hơi lười.

Cách 3. Đẹp và an toàn: dùng using

Cú pháp cổ điển (using ( ... ) { ... })


using (var stream = new FileStream("file.txt", FileMode.Open))
{
    // Làm việc với stream
}
// Ở đây stream.Dispose() sẽ tự động được gọi!

Ý chính — mọi thứ trong block using đều làm việc với stream, và khi block kết thúc — file sẽ được đóng kể cả khi có lỗi (ví dụ, exception bị ném ra).

Cách 4. Cú pháp hiện đại

Cú pháp hiện đại (using var)


using var stream = new FileStream("file.txt", FileMode.Open);
// Làm việc với stream
// ... Dispose sẽ tự động gọi khi biến ra khỏi scope

Quá tuyệt! Không cần thêm dấu ngoặc nhọn hay thụt lề thừa.

Bên trong nó hoạt động thế nào?

Toán tử using thực ra được compiler chuyển thành try...finally cho bạn. Đùa chút: "using viết code sạch thay bạn — chắc sắp tới nó còn uống cà phê và lướt Stack Overflow luôn?".

Khác biệt giữa using cổ điển và hiện đại

Block using cổ điển using var (declaration)
Kiểu
using (var x = ...) { ... }
using var x = ...; ...
Scope Bên trong dấu ngoặc nhọn của block Đến hết block hiện tại (method, vòng lặp, v.v.)
Ngắn gọn Hơi dài dòng Ngắn gọn, ít thụt lề
Bắt đầu từ C# 1.0 C# 8.0 trở lên

3. using-declaration là gì?

5 năm trước, thế giới có thêm cách làm việc với object IDisposable cực kỳ ngắn gọn.

using-declaration — là khi bạn khai báo biến với từ khóa using thay vì block, và nó sẽ tự động giải phóng ở cuối block hiện tại (ví dụ, method hoặc vòng lặp), chứ không phải ở cuối dấu ngoặc nhọn của block phụ.


using var stream = new FileStream("file.txt", FileMode.Open);
// Làm việc với stream
Console.WriteLine(stream.Length);

// Ở đây file vẫn còn mở!

// ... cuối method
// stream.Dispose() sẽ được gọi tự động ở đây

Khác biệt chính với using cổ điển:

  • Không cần dấu ngoặc nhọn, không tạo block lồng nhau.
  • Biến tồn tại đến hết block nơi nó được khai báo (thường là method, đôi khi là vòng lặp, class nếu khai báo ở cấp class).
  • Giải phóng tài nguyên chỉ khi block thực thi kết thúc.

Tại sao nó xịn?

  • Ít lồng nhau hơn — code ngắn và dễ đọc hơn nhiều.
  • Dễ làm việc với nhiều tài nguyên — khai báo nhiều biến using liên tiếp, tất cả sẽ được giải phóng khi method kết thúc.
  • Ít bị lỗi hơn — không quên vùng mà lẽ ra phải gọi Dispose().

4. So sánh: using cổ điển vs. hiện đại

Cùng xem so sánh qua code nhé.

Cách cổ điển


using (var reader = new StreamReader("input.txt"))
{
    using (var writer = new StreamWriter("output.txt"))
    {
        string line;
        while ((line = reader.ReadLine()) != null)
        {
            writer.WriteLine(line.ToUpper());
        }
    }
} // Ở đây cả hai file sẽ được đóng

Cách hiện đại (C# 8+)


using var reader = new StreamReader("input.txt");
using var writer = new StreamWriter("output.txt");

string line;
while ((line = reader.ReadLine()) != null)
{
    writer.WriteLine(line.ToUpper());
}
// Cả hai file sẽ đóng ở đây, khi thoát khỏi method

Nhìn đơn giản hơn hẳn đúng không? Đặc biệt nếu lồng nhiều hơn — cách hiện đại giúp cuộc sống dễ thở hơn nhiều.

5. Khi nào Dispose() được gọi?

Chỗ này sinh viên hay nhầm: tưởng Dispose sẽ gọi ngay sau dòng sử dụng — nhưng không phải vậy!

Xem ví dụ này nhé:


void MyMethod()
{
    using var fileStream = new FileStream("data.bin", FileMode.Open);
    // ... nhiều code, có thể cả vòng lặp và gọi hàm lồng nhau
    // fileStream vẫn còn mở!

    // Ở đây vẫn truy cập được fileStream
}
// Ở đây, tại dấu } của method, fileStream.Dispose() mới được gọi

Lưu ý: Nếu khai báo biến using trong vòng lặp, Dispose sẽ được gọi sau mỗi vòng lặp.


foreach (var path in filePaths)
{
    using var reader = new StreamReader(path);
    // làm việc với reader
} // reader.Dispose() sẽ được gọi sau mỗi vòng lặp (đóng file)

6. Lỗi khi chuyển code cũ

Đôi khi bạn chuyển code cũ hoặc copy ví dụ dùng using cổ điển, nhưng biến lại cần "sống" lâu hơn scope của dấu ngoặc nhọn. Khi đó, cách cổ điển không hợp, còn using-declaration thì hoàn hảo.

Nhưng cũng có lưu ý. Ví dụ, nếu trong vòng lặp bạn có hai tài nguyên, nhưng một cái cần "sống" lâu hơn cái kia — hãy khai báo theo thứ tự phù hợp:


using var resource1 = ...;
for (int i = 0; i < 10; i++)
{
    using var resource2 = ...;
    // resource2 sống một vòng lặp
    // resource1 — cả function
}

7. Thực hành

Tiếp tục phát triển app học tập của mình — một simulator order cà phê nhỏ mà bạn đã cải tiến mấy hôm trước. Giờ nó sẽ lưu lịch sử order vào file text và đọc lại khi khởi động.

Bước 1: Lưu order vào file


using var writer = new StreamWriter("orders.txt", append: true);
writer.WriteLine("Cà phê: Latte; Sữa: Yến mạch; Size: Lớn");

// Tham số thứ hai của constructor StreamWriter append: true nghĩa là mình muốn ghi thêm, không ghi đè file.

Bước 2: Đọc lịch sử order


using var reader = new StreamReader("orders.txt");
string? line;
while ((line = reader.ReadLine()) != null)
{
    Console.WriteLine($"Order: {line}");
}

Và khi chương trình chạy xong method này, file sẽ tự động đóng.

8. Best practice khi dùng using-declaration

1. Luôn dùng using cho object implement IDisposable
Trong .NET, hầu hết class làm việc với file, stream, tài nguyên đều implement interface này. Đó là tín hiệu: hãy giải phóng mình bằng using!

2. Nhớ về scope: đừng khai báo using-var ở nơi biến có thể "vướng"
Nếu biến chỉ dùng cho vài dòng — khai báo đúng chỗ cần, đừng sớm quá.

3. Đừng quên thứ tự giải phóng
Nếu khai báo nhiều biến using liên tiếp — Dispose sẽ gọi ngược thứ tự:


using var first = new Resource("First");
using var second = new Resource("Second");
// ... làm việc
// Dispose cho second trước, rồi đến first

Đôi khi quan trọng, ví dụ một tài nguyên phụ thuộc tài nguyên khác (stream ghi phải giải phóng trước file).

4. Không dùng using-declaration ngoài method
using-declaration bị cấm ở cấp class (ví dụ, cho field). Chỉ dùng được trong method, constructor, v.v.

5. Kết hợp với xử lý lỗi
Nhớ rằng ngay cả với using cũng không bắt được hết exception — nên thêm try-catch nếu cần kiểm soát lỗi đọc/ghi.

2
Nhiệm vụ
C# SELF, mức độ, bài học
Đã khóa
Đọc file bằng `using var`
Đọc file bằng `using var`
Bình luận
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION