Không phải các hướng dẫn của async / đang chờ sử dụng trong C # có mâu thuẫn với các khái niệm về kiến ​​trúc tốt và phân lớp trừu tượng không?

Câu hỏi này liên quan đến ngôn ngữ C #, nhưng tôi hy vọng nó sẽ bao gồm các ngôn ngữ khác như Java hoặc TypeScript.

Microsoft khuyến nghị thực hành tốt nhất về việc sử dụng các cuộc gọi không đồng bộ trong .NET. Trong số các khuyến nghị này, chúng ta hãy chọn hai:

• thay đổi chữ ký của các phương thức async để chúng trả về Nhiệm vụ hoặc Tác vụ <> (trong TypeScript, đó sẽ là một Lời hứa <>)
• thay đổi tên của các phương thức async để kết thúc bằng xxxAsync ()

Bây giờ, khi thay thế một thành phần đồng bộ, cấp thấp bằng một thành phần không đồng bộ, điều này sẽ tác động đến toàn bộ ứng dụng. Vì async / await chỉ có tác động tích cực nếu được sử dụng "hết cách", điều đó có nghĩa là tên chữ ký và phương thức của mỗi lớp trong ứng dụng phải được thay đổi.

Một kiến ​​trúc tốt thường liên quan đến việc đặt trừu tượng giữa mỗi lớp, sao cho việc thay thế các thành phần cấp thấp bằng các thành phần khác không được nhìn thấy bởi các thành phần cấp trên. Trong C #, trừu tượng có dạng giao diện. Nếu chúng tôi giới thiệu một thành phần mới, mức độ thấp, không đồng bộ, mỗi giao diện trong ngăn xếp cuộc gọi cần phải được sửa đổi hoặc thay thế bằng một giao diện mới. Cách giải quyết vấn đề (không đồng bộ hoặc đồng bộ hóa) trong lớp triển khai không bị ẩn (trừu tượng hóa) đối với người gọi nữa. Người gọi phải biết đó là đồng bộ hóa hay không đồng bộ.

Không đồng bộ / chờ đợi các thực tiễn tốt nhất mâu thuẫn với các nguyên tắc "kiến trúc tốt"?

Điều đó có nghĩa là mỗi giao diện (giả sử IEnumerable, IDataAccessLayer) cần đối tác không đồng bộ của chúng (IAsyncEnumerable, IAsyncDataAccessLayer) sao cho chúng có thể được thay thế trong ngăn xếp khi chuyển sang phụ thuộc async?

Nếu chúng ta đẩy vấn đề đi xa hơn một chút, sẽ không đơn giản hơn khi giả sử mọi phương thức là không đồng bộ (để trả về Tác vụ <> hoặc Lời hứa <>) và cho các phương thức để đồng bộ hóa các cuộc gọi không đồng bộ khi chúng không thực sự không đồng bộ? Đây có phải là một cái gì đó được mong đợi từ các ngôn ngữ lập trình trong tương lai?

Chức năng của bạn màu gì?

Bạn có thể quan tâm đến chức năng ¹ của bạn của Bob Nystrom .

Trong bài viết này, ông mô tả một ngôn ngữ hư cấu trong đó:

• Mỗi chức năng có một màu: xanh hoặc đỏ.
• Một chức năng màu đỏ có thể gọi các chức năng màu xanh hoặc màu đỏ, không có vấn đề.
• Một chức năng màu xanh chỉ có thể gọi các chức năng màu xanh.

Mặc dù hư cấu, điều này xảy ra khá thường xuyên trong các ngôn ngữ lập trình:

• Trong C ++, phương thức "const" chỉ có thể gọi các phương thức "const" khác this.
• Trong Haskell, chức năng không phải IO chỉ có thể gọi các chức năng không phải IO.
• Trong C #, chức năng đồng bộ chỉ có thể gọi chức năng đồng bộ hóa ² .

Như bạn đã nhận ra, vì các quy tắc này, các hàm màu đỏ có xu hướng lan truyền xung quanh cơ sở mã. Bạn chèn một, và từng chút một nó sẽ chiếm toàn bộ cơ sở mã.

¹ Bob Nystrom, ngoài việc viết blog, còn là thành viên của nhóm Dart và đã viết ra serie Phiên dịch thủ công nhỏ này; rất khuyến khích cho bất kỳ ngôn ngữ lập trình / trình biên dịch afficionado.

² Không hoàn toàn đúng, vì bạn có thể gọi một hàm async và chặn cho đến khi nó trả về, nhưng ...

Giới hạn ngôn ngữ

Về cơ bản, đây là một giới hạn về ngôn ngữ / thời gian chạy.

Ví dụ, ngôn ngữ có luồng M: N, chẳng hạn như Erlang và Go, không có asyncchức năng: mỗi chức năng có khả năng không đồng bộ và "sợi" của nó sẽ đơn giản bị treo, tráo đổi và đổi chỗ khi nó sẵn sàng trở lại.

C # đã đi với mô hình luồng 1: 1, và do đó quyết định hiển thị tính đồng bộ bề mặt trong ngôn ngữ để tránh vô tình chặn các luồng.

Khi có sự hạn chế về ngôn ngữ, các hướng dẫn mã hóa phải thích nghi.

Bạn đúng là có một mâu thuẫn ở đây, nhưng nó không phải là "thực hành tốt nhất" là xấu. Đó là bởi vì chức năng không đồng bộ về cơ bản không có gì khác với chức năng đồng bộ. Thay vì chờ kết quả từ các phụ thuộc của nó (thường là một số IO), nó tạo ra một tác vụ được xử lý bởi vòng lặp sự kiện chính. Đây không phải là một sự khác biệt có thể được ẩn giấu dưới sự trừu tượng.

Một phương thức không đồng bộ hoạt động khác với một phương thức đồng bộ, vì tôi chắc chắn rằng bạn biết. Trong thời gian chạy, để chuyển đổi một cuộc gọi không đồng bộ thành một cuộc gọi đồng bộ là chuyện nhỏ, nhưng điều ngược lại không thể nói. Vì vậy, logic sau đó trở thành, tại sao chúng ta không tạo ra các phương thức không đồng bộ của mọi phương thức có thể yêu cầu nó và để người gọi "chuyển đổi" khi cần thiết thành một phương thức đồng bộ?

Theo một nghĩa nào đó, nó giống như có một phương pháp đưa ra các ngoại lệ và một phương pháp khác là "an toàn" và sẽ không ném ngay cả trong trường hợp có lỗi. Tại thời điểm nào thì lập trình viên quá mức để cung cấp các phương thức này mà nếu không thì có thể chuyển đổi cái này sang cái khác?

Trong đó có hai trường phái tư duy: một là tạo ra nhiều phương thức, mỗi phương thức gọi một phương thức riêng tư khác có thể cho phép khả năng cung cấp các tham số tùy chọn hoặc thay đổi nhỏ cho hành vi như không đồng bộ. Cách khác là tối thiểu hóa các phương thức giao diện đến các yếu tố cần thiết để cho người gọi tự thực hiện các sửa đổi cần thiết.

Nếu bạn thuộc trường đầu tiên, sẽ có một logic nhất định để dành một lớp cho các cuộc gọi đồng bộ và không đồng bộ để tránh nhân đôi mỗi cuộc gọi. Microsoft có xu hướng ủng hộ trường phái tư tưởng này và theo quy ước, để phù hợp với phong cách mà Microsoft ưa thích, bạn cũng sẽ phải có phiên bản Async, giống như cách mà giao diện hầu như luôn bắt đầu bằng chữ "I". Hãy để tôi nhấn mạnh rằng điều đó không sai , vì sẽ tốt hơn nếu giữ một phong cách nhất quán trong một dự án thay vì làm "đúng cách" và thay đổi hoàn toàn phong cách cho sự phát triển mà bạn thêm vào một dự án.

Điều đó nói rằng, tôi có xu hướng ủng hộ trường thứ hai, đó là giảm thiểu các phương thức giao diện. Nếu tôi nghĩ một phương thức có thể được gọi theo cách không đồng bộ, thì phương thức đó đối với tôi là không đồng bộ. Người gọi có thể quyết định có chờ đợi nhiệm vụ đó kết thúc hay không trước khi tiếp tục. Nếu giao diện này là giao diện cho thư viện, sẽ hợp lý hơn khi thực hiện theo cách này để giảm thiểu số lượng phương thức bạn cần để loại bỏ hoặc điều chỉnh. Nếu giao diện được sử dụng nội bộ trong dự án của tôi, tôi sẽ thêm một phương thức cho mọi cuộc gọi cần thiết trong suốt dự án của mình cho các tham số được cung cấp và không có phương thức "phụ", và thậm chí sau đó, chỉ khi hành vi của phương thức chưa được bao phủ bằng một phương pháp hiện có.

Tuy nhiên, giống như nhiều thứ trong lĩnh vực này, nó chủ yếu là chủ quan. Cả hai phương pháp đều có ưu và nhược điểm của chúng. Microsoft cũng bắt đầu quy ước thêm các chữ cái chỉ loại ở đầu tên biến và "m_" để chỉ ra nó là thành viên, dẫn đến tên biến như thế nào m_pUser. Quan điểm của tôi là thậm chí Microsoft không thể sai lầm và cũng có thể mắc lỗi.

Điều đó nói rằng, nếu dự án của bạn tuân theo quy ước Async này, tôi sẽ khuyên bạn nên tôn trọng nó và tiếp tục phong cách. Và chỉ khi bạn được giao một dự án của riêng bạn, bạn có thể viết nó theo cách tốt nhất mà bạn thấy phù hợp.

Hãy tưởng tượng có một cách để cho phép bạn gọi các chức năng theo cách không đồng bộ mà không thay đổi chữ ký của chúng.

Điều đó sẽ rất tuyệt và không ai khuyên bạn nên thay đổi tên của họ.

Nhưng, các hàm không đồng bộ thực tế, không chỉ các hàm đang chờ một hàm async khác, mà ở mức thấp nhất có một số cấu trúc để chúng đặc trưng cho bản chất không đồng bộ của chúng. ví dụ

public class HTTPClient
{
    public HTTPResponse GET()
    {
        //send data
        while(!timedOut)
        {
            //check for response
            if(response) { 
                this.GotResponse(response); 
            }
            this.YouCanWait();
        }
    }

    //tell calling code that they should watch for this event
    public EventHander GotResponse
    //indicate to calling code that they can go and do something else for a bit
    public EventHander YouCanWait;
}

Đó là hai bit thông tin mà mã gọi cần để chạy mã theo cách không đồng bộ mà mọi thứ thích Taskvà asyncgói gọn.

Có nhiều hơn một cách để thực hiện các hàm không đồng bộ, async Taskchỉ là một mẫu được tích hợp trong trình biên dịch thông qua các kiểu trả về để bạn không phải liên kết thủ công các sự kiện

Tôi sẽ giải quyết vấn đề chính theo cách ít C # ness và chung chung hơn:

Không đồng bộ / chờ đợi các thực tiễn tốt nhất mâu thuẫn với các nguyên tắc "kiến trúc tốt"?

Tôi sẽ nói rằng nó chỉ phụ thuộc vào lựa chọn bạn đưa ra trong thiết kế API của bạn và những gì bạn cho người dùng.

Nếu bạn muốn một chức năng của API của mình chỉ là không đồng bộ thì sẽ không có nhiều hứng thú để tuân theo quy ước đặt tên. Chỉ cần luôn trả về Nhiệm vụ <> / Lời hứa <> / Tương lai <> / ... là loại trả về, đó là tài liệu tự. Nếu muốn có một câu trả lời đồng bộ, anh ta vẫn có thể làm điều đó bằng cách chờ đợi, nhưng nếu anh ta luôn làm điều đó, nó sẽ tạo ra một chút sôi nổi.

Tuy nhiên, nếu bạn chỉ thực hiện đồng bộ hóa API, điều đó có nghĩa là nếu người dùng muốn nó không đồng bộ, anh ta sẽ phải tự quản lý phần không đồng bộ của nó.

Điều này có thể tạo ra khá nhiều công việc phụ, tuy nhiên nó cũng có thể cung cấp thêm quyền kiểm soát cho người dùng về số lượng cuộc gọi đồng thời mà anh ta cho phép, đặt thời gian chờ, retrys, v.v.

Trong một hệ thống lớn với API khổng lồ, việc triển khai hầu hết chúng để được đồng bộ hóa theo mặc định có thể dễ dàng và hiệu quả hơn so với việc quản lý độc lập từng phần của API của bạn, đặc biệt nếu chúng chia sẻ các nguồn tài nguyên (hệ thống tệp, CPU, cơ sở dữ liệu, ...).

Trong thực tế đối với các phần phức tạp nhất, bạn hoàn toàn có thể có hai triển khai cùng một phần API của mình, một phần đồng bộ thực hiện các công cụ tiện dụng, một phần không đồng bộ dựa trên phần đồng bộ thực hiện xử lý công cụ và chỉ quản lý đồng thời, tải, hết thời gian và thử lại .

Có lẽ ai đó khác có thể chia sẻ kinh nghiệm của mình với điều đó vì tôi thiếu kinh nghiệm với các hệ thống như vậy.