Tại sao bạn lại 'chờ đợi' một phương thức, và sau đó thẩm vấn ngay giá trị trả về của nó?

Trong bài viết MSDN này , mã ví dụ sau được cung cấp (được chỉnh sửa một chút cho ngắn gọn):

public async Task<ActionResult> Details(int? id)
{
    if (id == null)
    {
        return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
    }

    Department department = await db.Departments.FindAsync(id);

    if (department == null)
    {
        return HttpNotFound();
    }

    return View(department);
}

Các FindAsyncphương pháp lấy một Departmentđối tượng bằng ID của nó, và trả về một Task<Department>. Sau đó bộ phận được kiểm tra ngay lập tức để xem nếu nó là null. Theo tôi hiểu, việc yêu cầu giá trị của Nhiệm vụ theo cách này sẽ chặn thực thi mã cho đến khi giá trị từ phương thức chờ được trả về, thực sự biến đây thành một cuộc gọi đồng bộ.

Tại sao bạn sẽ làm điều này? Sẽ không đơn giản hơn nếu chỉ gọi phương thức đồng bộ Find(id), nếu bạn định chặn ngay lập tức?

Theo tôi hiểu, việc yêu cầu giá trị của Nhiệm vụ theo cách này sẽ chặn thực thi mã cho đến khi giá trị từ phương thức chờ được trả về, thực sự biến đây thành một cuộc gọi đồng bộ.

Không hẳn.

Khi bạn gọi await db.Departments.FindAsync(id)tác vụ được gửi đi và luồng hiện tại được trả về nhóm để sử dụng cho các hoạt động khác. Luồng thực thi bị chặn (vì nó sẽ không phụ thuộc vào việc sử dụng departmentngay sau đó, nếu tôi hiểu chính xác mọi thứ), nhưng chính luồng này được sử dụng miễn phí bởi những thứ khác trong khi bạn chờ thao tác hoàn tất ngoài máy (và báo hiệu bởi một sự kiện hoặc cổng hoàn thành).

Nếu bạn đã gọi d.Departments.Find(id)thì luồng sẽ ngồi đó và chờ phản hồi, mặc dù hầu hết quá trình xử lý đang được thực hiện trên DB.

Bạn đang giải phóng tài nguyên CPU một cách hiệu quả khi bị ràng buộc đĩa.

Tôi thực sự ghét rằng không có ví dụ nào cho thấy làm thế nào có thể đợi một vài dòng trước khi chờ đợi nhiệm vụ. Xem xét điều này.

Foo foo = await getFoo();
Bar bar = await getBar();

Console.WriteLine(“Do some other stuff to prepare.”);

doStuff(foo, bar);

Đây là loại mã mà các ví dụ khuyến khích, và bạn đã đúng. Có rất ít ý nghĩa trong việc này. Nó không giải phóng chủ đề chính để làm những việc khác, như phản hồi đầu vào UI, nhưng sức mạnh thực sự của async / await là tôi có thể dễ dàng tiếp tục làm những việc khác trong khi tôi đang chờ một nhiệm vụ có khả năng chạy dài hoàn thành. Đoạn mã trên sẽ chặn khối và chờ đợi để thực thi dòng in cho đến khi chúng tôi nhận được Foo & Bar. Không cần phải chờ đợi mặc dù. Chúng tôi có thể xử lý trong khi chúng tôi chờ đợi.

Task<Foo> foo = getFoo();
Task<Bar> bar = getBar();

Console.WriteLine(“Do some other stuff to prepare.”);

doStuff(await foo, await bar);

Bây giờ, với mã được viết lại, chúng tôi không dừng lại và chờ đợi các giá trị của chúng tôi cho đến khi chúng tôi phải. Tôi luôn đề phòng những loại cơ hội này. Trở nên thông minh khi chúng ta chờ đợi có thể dẫn đến những cải tiến hiệu suất đáng kể. Chúng tôi đã có nhiều lõi ngày nay, cũng có thể sử dụng chúng.

Vì vậy, có nhiều điều xảy ra đằng sau hậu trường ở đây. Async / Await là cú pháp đường. Trước tiên hãy xem chữ ký của chức năng FindAsync. Nó trả về một nhiệm vụ. Bạn đã thấy sự kỳ diệu của từ khóa, nó bỏ hộp Nhiệm vụ đó thành Bộ.

Chức năng gọi không chặn. Điều gì xảy ra là việc gán cho bộ phận và mọi thứ theo từ khóa đang chờ được đóng vào một bao đóng và cho tất cả các ý định và mục đích được truyền cho phương thức Task.CContueWith (chức năng FindAsync được tự động thực hiện trên một luồng khác).

Tất nhiên, có nhiều điều xảy ra đằng sau hậu trường vì thao tác được sắp xếp lại theo chủ đề ban đầu (vì vậy bạn không còn phải lo lắng về việc đồng bộ hóa với giao diện người dùng khi thực hiện thao tác nền) và trong trường hợp chức năng gọi là Async ( và được gọi là không đồng bộ) điều tương tự xảy ra với ngăn xếp.

Vì vậy, những gì xảy ra là bạn có được sự kỳ diệu của các hoạt động Async, mà không có những cạm bẫy.

Không, nó không trở lại ngay lập tức. Việc chờ đợi làm cho phương thức gọi không đồng bộ. Khi FindAsync được gọi, phương thức Chi tiết trả về với một tác vụ chưa hoàn thành. Khi FindAsync kết thúc, nó sẽ trả kết quả của nó vào biến bộ phận và tiếp tục phần còn lại của phương thức Chi tiết.

Tôi thích nghĩ về "async" như một hợp đồng, một hợp đồng có nội dung "tôi có thể thực hiện điều này một cách không đồng bộ nếu bạn cần, nhưng bạn cũng có thể gọi tôi như bất kỳ chức năng đồng bộ nào khác".

Có nghĩa là, một nhà phát triển đã thực hiện các chức năng và một số quyết định thiết kế đã khiến họ thực hiện / đánh dấu một loạt các chức năng là "không đồng bộ". Người gọi / người tiêu dùng của các chức năng có quyền tự do sử dụng chúng khi họ quyết định. Như bạn nói, bạn có thể gọi await ngay trước khi gọi hàm và đợi nó, theo cách này bạn đã coi nó như một hàm đồng bộ, nhưng nếu bạn muốn, bạn có thể gọi nó mà không cần chờ

Task<Department> deptTask = db.Departments.FindAsync(id);

và sau đó, giả sử, 10 dòng xuống chức năng bạn gọi

Department d = await deptTask;

do đó coi nó như là một hàm không đồng bộ.

Tuỳ bạn.

"nếu bạn định chặn ngay lập tức" thì anwser là "Có". Chỉ khi bạn cần phản hồi nhanh, await / async mới có ý nghĩa. Ví dụ, luồng UI đến một phương thức không đồng bộ thực sự, luồng UI sẽ quay trở lại và tiếp tục lắng nghe nhấp vào nút, trong khi mã bên dưới "await" sẽ bị loại bỏ bởi luồng khác và cuối cùng nhận được kết quả.