Thực hiện triển khai giao diện không đồng bộ

Tôi hiện đang cố gắng tạo ứng dụng của mình bằng một số phương pháp Async. Tất cả IO của tôi được thực hiện thông qua việc triển khai rõ ràng một giao diện và tôi hơi bối rối về cách làm cho các hoạt động không đồng bộ.

Khi tôi thấy những điều, tôi có hai tùy chọn trong việc triển khai:

interface IIO
{
    void DoOperation();
}

TÙY CHỌN1: Thực hiện không đồng bộ triển khai ngầm định và chờ đợi kết quả trong quá trình triển khai ngầm định.

class IOImplementation : IIO
{

     async void DoOperation()
    {
        await Task.Factory.StartNew(() =>
            {
                //WRITING A FILE OR SOME SUCH THINGAMAGIG
            });
    }

    #region IIO Members

    void IIO.DoOperation()
    {
        DoOperation();
    }

    #endregion
}

TÙY CHỌN 2: Thực hiện không đồng bộ triển khai rõ ràng và chờ tác vụ từ triển khai ngầm định.

class IOAsyncImplementation : IIO
{
    private Task DoOperationAsync()
    {
        return new Task(() =>
            {
                //DO ALL THE HEAVY LIFTING!!!
            });
    }

    #region IIOAsync Members

    async void IIO.DoOperation()
    {
        await DoOperationAsync();
    }

    #endregion
}

Một trong những cách triển khai này có tốt hơn cách triển khai kia không hay có cách nào khác để thực hiện mà tôi chưa nghĩ đến?

Cả hai tùy chọn này đều không đúng. Bạn đang cố gắng triển khai giao diện đồng bộ một cách không đồng bộ. Đừng làm vậy. Vấn đề là khi DoOperation()trả về, hoạt động vẫn chưa hoàn tất. Tệ hơn nữa, nếu một ngoại lệ xảy ra trong quá trình hoạt động (điều này rất phổ biến với các hoạt động IO), người dùng sẽ không có cơ hội đối phó với ngoại lệ đó.

Những gì bạn cần làm là sửa đổi giao diện để nó không đồng bộ:

interface IIO
{
    Task DoOperationAsync(); // note: no async here
}

class IOImplementation : IIO
{
    public async Task DoOperationAsync()
    {
        // perform the operation here
    }
}

Bằng cách này, người dùng sẽ thấy rằng hoạt động là asyncvà họ sẽ có thể thực hiện được await. Điều này cũng buộc người dùng mã của bạn phải chuyển sang async, nhưng điều đó là không thể tránh khỏi.

Ngoài ra, tôi cho rằng việc sử dụng StartNew()trong triển khai của bạn chỉ là một ví dụ, bạn không cần điều đó để triển khai IO không đồng bộ. (Và new Task()thậm chí còn tồi tệ hơn, đó sẽ thậm chí không làm việc, bởi vì bạn không Start()những Task.)

Giải pháp tốt hơn là giới thiệu một giao diện khác cho các hoạt động không đồng bộ. Giao diện mới phải kế thừa từ giao diện gốc.

Thí dụ:

interface IIO
{
    void DoOperation();
}

interface IIOAsync : IIO
{
    Task DoOperationAsync();
}


class ClsAsync : IIOAsync
{
    public void DoOperation()
    {
        DoOperationAsync().GetAwaiter().GetResult();
    }

    public async Task DoOperationAsync()
    {
        //just an async code demo
        await Task.Delay(1000);
    }
}


class Program
{
    static void Main(string[] args)
    {
        IIOAsync asAsync = new ClsAsync();
        IIO asSync = asAsync;

        Console.WriteLine(DateTime.Now.Second);

        asAsync.DoOperation();
        Console.WriteLine("After call to sync func using Async iface: {0}", 
            DateTime.Now.Second);

        asAsync.DoOperationAsync().GetAwaiter().GetResult();
        Console.WriteLine("After call to async func using Async iface: {0}", 
            DateTime.Now.Second);

        asSync.DoOperation();
        Console.WriteLine("After call to sync func using Sync iface: {0}", 
            DateTime.Now.Second);

        Console.ReadKey(true);
    }
}

PS Thiết kế lại các hoạt động không đồng bộ của bạn để chúng trả về Tác vụ thay vì vô hiệu, trừ khi bạn thực sự phải trả về giá trị vô hiệu.