使接口实现异步

Question

我目前正在尝试使用一些异步方法来制作我的应用程序。 我所有的 IO 都是通过接口的显式实现完成的，我对如何使操作异步有点困惑。

正如我所见，我在实施中有两个选择：

interface IIO
{
    void DoOperation();
}

选项1： 做一个隐式实现异步并在隐式实现中等待结果。

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
}

选项2： 异步执行显式实现并等待来自隐式实现的任务。

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

    #region IIOAsync Members

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

    #endregion
}

这些实现中的一个是否比另一个更好，或者还有其他我没有想到的方法吗？

Answer 1

这些选项都不正确。您正在尝试异步实现同步接口。不要那样做。问题是当DoOperation() 返回时，操作还没有完成。更糟糕的是，如果在操作过程中发生异常（这在 IO 操作中很常见），用户将没有机会处理该异常。

你需要做的是修改接口，使其异步：

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

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

这样，用户将看到操作是async，他们将能够await。这也几乎迫使您代码的用户切换到async，但这是不可避免的。

另外，我假设在您的实现中使用 StartNew() 只是一个示例，您不需要它来实现异步 IO。 （而new Task() 更糟糕，那甚至都行不通，因为你没有Start() 和Task。）

Answer 2

更好的解决方案是为异步操作引入另一个接口。新接口必须继承原接口。

例子：

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);
    }
}

附： 重新设计您的异步操作，使其返回 Task 而不是 void，除非您确实必须返回 void。

Answer 3

我根据 Svick 的回答创建了一个示例应用程序，发现在没有 async 关键字的情况下调用 IOImplementation.DoOperationAsync() 不会导致编译器/Visual Studio 警告。这是基于 Visual Studio 2019 和 .NET Core 3.1。

下面的示例代码。

public interface ISomething
{
    Task DoSomethingAsync();
}

public class Something : ISomething
{
    public async Task DoSomethingAsync()
    {
        await Task.Run(() => Thread.Sleep(2000));
        Console.WriteLine("Message from DoSomethingAsync");

        throw new Exception("Some exception");
    }
}

class Program
{
    static void Main(string[] args)
    {
        ISomething something = new Something();
        
        Console.WriteLine("pre something.DoSomethingAsync() without await");
        something.DoSomethingAsync(); // No compiler warning for missing "await" and exception is "swallowed"
        Console.WriteLine("post something.DoSomethingAsync() without await");

        Thread.Sleep(3000);

        // Output:
        // pre something.DoSomethingAsync() without await
        // post something.DoSomethingAsync() without await
        // Message from DoSomethingAsync
    }
}

Answer 4

可以使用抽象类代替接口（在 C# 7.3 中）。

// Like interface
abstract class IIO
{
    public virtual async Task<string> DoOperation(string Name)
    {
        throw new NotImplementedException(); // throwing exception
        // return await Task.Run(() => { return ""; }); // or empty do
    }
}

// Implementation
class IOImplementation : IIO
{
    public override async Task<string> DoOperation(string Name)
    {
        return await await Task.Run(() =>
        {
            if(Name == "Spiderman")
                return "ok";
            return "cancel";
        }); 
    }
}