The History Of Async/Await In C# (Part I)

Lập trình không đồng bộ (asynchronous programming) đã trở thành một phần không thể thiếu trong phát triển phần mềm hiện đại, đặc biệt trong các lĩnh vực như ứng dụng web, mạng và giao diện người dùng, nơi khả năng đáp ứng (responsiveness) là yếu tố then chốt. Nhưng liệu bạn đã bao giờ tự hỏi chúng ta đã đạt đến trình độ này như thế nào chưa? Hãy cùng nhau quay ngược thời gian để khám phá sự tiến hóa của lập trình không đồng bộ.

Những ngày đầu: Callback và APM

Thời kỳ đầu của lập trình không đồng bộ, các nhà phát triển chủ yếu dựa vào callback để xử lý các hoạt động mất thời gian hoàn thành, như yêu cầu mạng (network requests) hay thao tác tệp (file I/O). Điều này đồng nghĩa với việc viết mã (code) sẽ được thực thi sau khi hoạt động không đồng bộ kết thúc. Mặc dù hữu ích, nhưng callback có thể nhanh chóng dẫn đến mã phức tạp và lồng nhau, thường được gọi là “callback hell”.

Để giải quyết vấn đề này, Microsoft đã giới thiệu Mô hình Lập trình Không đồng bộ (APM) trong .NET Framework 1.1. APM cung cấp một cách tiêu chuẩn hóa để viết mã không đồng bộ sử dụng cặp phương thức Begin và End. Ví dụ, để đọc một tệp không đồng bộ, bạn sẽ gọi BeginRead để khởi tạo thao tác và cung cấp một hàm callback. Khi thao tác hoàn tất, runtime sẽ gọi lại callback của bạn, và bạn sẽ gọi EndRead để nhận kết quả.

void ReadAgain()
{
    stream.BeginRead(buffer, 0, 1, iar =>
    {
        if (stream.EndRead(iar) != 0)
        {
            ReadAgain(); // uh oh!
        }
        else
        {
            mres.Set();
        }
    }, null);
};
ReadAgain();

Những thách thức của APM

Mặc dù APM mang lại một cải tiến đáng kể so với callback thuần túy, nhưng nó không phải là không có nhược điểm:

1. Độ phức tạp (Complexity)

Mặc dù APM đã giúp cải thiện tính dễ đọc của mã so với cách sử dụng callback truyền thống, việc viết và bảo trì code không đồng bộ với APM vẫn có thể là một thử thách. Đặc biệt là khi có nhiều tác vụ không đồng bộ diễn ra đồng thời, việc quản lý luồng thực thi và đảm bảo tính đúng đắn của chương trình trở nên khó khăn hơn.

Ví dụ, hãy tưởng tượng bạn đang xây dựng một ứng dụng tải xuống nhiều tệp tin cùng lúc. Với APM, bạn sẽ cần viết các hàm callback riêng cho từng tệp tin. Khi số lượng tệp tin tăng lên, việc quản lý và đồng bộ các callback này trở nên phức tạp và dễ dẫn đến lỗi.

// APM: Downloading multiple files
void DownloadFiles(string[] urls)
{
    foreach (var url in urls)
    {
        var request = WebRequest.Create(url);
        request.BeginGetResponse(
            new AsyncCallback(DownloadComplete), 
            new DownloadState { Request = request, Url = url }
        );
    }
}

void DownloadComplete(IAsyncResult ar)
{
    var state = (DownloadState)ar.AsyncState;
    var response = state.Request.EndGetResponse(ar);

    // ... Handle response and save file content
}

class DownloadState
{
    public WebRequest Request;
    public string Url;
}

2. Xử lý lỗi (Error Handling)

Xử lý lỗi trong APM cũng là một vấn đề nan giải. Các ngoại lệ (exception) được ném ra trong callback có thể khó nắm bắt và xử lý một cách hiệu quả. Điều này đòi hỏi các nhà phát triển phải viết thêm mã để kiểm tra và xử lý các lỗi có thể xảy ra, làm tăng độ phức tạp và giảm tính dễ đọc của mã.

Ví dụ, nếu một trong các tệp tin tải xuống gặp lỗi, callback tương ứng sẽ được gọi và thông báo lỗi. Tuy nhiên, việc truyền đạt lỗi này đến các phần khác của chương trình và thực hiện các hành động xử lý phù hợp (như thông báo cho người dùng hoặc thử lại tải xuống) không phải là một việc đơn giản.

// APM: Error handling
void BeginOperation(AsyncCallback callback)
{
    try
    {
        // Start asynchronous operation
    }
    catch (Exception ex)
    {
        // Exception thrown during asynchronous operation
        callback(new AsyncResult(false, ex)); // Signal error in callback
    }
}

void EndOperation(IAsyncResult ar)
{
    if (!ar.CompletedSynchronously)
    {
        var ex = (Exception)ar.AsyncState;
        if (ex != null)
        {
            throw ex; // Re-throw exception
        }
    }

    // ... Process results if successful
}

3. Stack Dives

APM sử dụng callback để thông báo khi một tác vụ không đồng bộ hoàn thành. Mỗi callback sẽ thêm một frame mới vào call stack. Trong trường hợp có nhiều hoạt động không đồng bộ lồng nhau, call stack có thể tăng lên đáng kể, thậm chí dẫn đến lỗi tràn stack (stack overflow).

// APM: Error handling
void BeginOperation(AsyncCallback callback)
{
    try
    {
        // Start asynchronous operation
    }
    catch (Exception ex)
    {
        // Exception thrown during asynchronous operation
        callback(new AsyncResult(false, ex)); // Signal error in callback
    }
}

void EndOperation(IAsyncResult ar)
{
    if (!ar.CompletedSynchronously)
    {
        var ex = (Exception)ar.AsyncState;
        if (ex != null)
        {
            throw ex; // Re-throw exception
        }
    }

    // ... Process results if successful
}

4. Khó kiểm tra và gỡ lỗi (Testing and Debugging)

Do tính chất không đồng bộ của APM, việc kiểm tra và gỡ lỗi mã APM thường khó khăn hơn so với mã đồng bộ. Việc tái hiện lại các lỗi xảy ra trong môi trường không đồng bộ đòi hỏi sự kiên nhẫn và công cụ hỗ trợ phù hợp.

Sự cần thiết của một giải pháp tốt hơn

Những vấn đề trên đây đã thúc đẩy sự ra đời của các giải pháp tốt hơn để xử lý lập trình không đồng bộ. Các nhà phát triển mong muốn một cách tiếp cận giúp viết mã không đồng bộ một cách dễ dàng, trực quan và ít lỗi hơn.

Tóm lại

Hành trình của lập trình không đồng bộ từ callback đến async/await là một quá trình cải tiến và đơn giản hóa liên tục. Mặc dù callback và APM đã phục vụ mục đích của chúng, nhưng async/await đã nổi lên như một cách tiếp cận ưa thích cho hầu hết các phát triển C# hiện đại, cung cấp một cách trực quan và dễ bảo trì hơn để viết mã không đồng bộ. Trong bài đăng trên blog tiếp theo, chúng ta sẽ đi sâu hơn vào các vấn đề của APM và khám phá cách async/await đã giải quyết chúng.

Trong bài viết tiếp theo, chúng ta sẽ khám phá sự ra đời của async/await trong C# 5, một tính năng đã cách mạng hóa lập trình không đồng bộ và giải quyết các vấn đề tồn tại trong APM. Async/await cho phép viết mã không đồng bộ theo cách gần giống với mã đồng bộ, mang lại sự tiện lợi, dễ đọc và dễ bảo trì hơn.

Hãy đón đọc phần tiếp theo!