Hacer implementaciones de interfaz asincrónicas

Actualmente estoy tratando de hacer mi aplicación usando algunos métodos Async. Todo mi IO se realiza a través de implementaciones explícitas de una interfaz y estoy un poco confundido acerca de cómo hacer que las operaciones sean asincrónicas.

Como veo las cosas tengo dos opciones en la implementación:

interface IIO
{
    void DoOperation();
}

OPCIÓN1: Realice una implementación implícita asíncrona y espere el resultado en la implementación implícita.

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
}

OPCIÓN 2: Realice la implementación explícita de forma asíncrona y espere la tarea de la implementación implícita.

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

    #region IIOAsync Members

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

    #endregion
}

¿Es una de estas implementaciones mejor que la otra o hay otro camino por recorrer en el que no estoy pensando?

Ninguna de estas opciones es correcta. Está intentando implementar una interfaz síncrona de forma asincrónica. No hagas eso. El problema es que cuando DoOperation()regrese, la operación aún no estará completa. Peor aún, si ocurre una excepción durante la operación (que es muy común con las operaciones de E / S), el usuario no tendrá la oportunidad de lidiar con esa excepción.

Lo que debe hacer es modificar la interfaz , para que sea asincrónica:

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

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

De esta forma, el usuario verá que la operación está asyncy podrá awaithacerlo. Esto también obliga a los usuarios de su código a cambiar async, pero eso es inevitable.

Además, supongo que usar StartNew()en su implementación es solo un ejemplo, no debería necesitarlo para implementar IO asincrónico. (Y new Task()es aún peor, que ni siquiera el trabajo, porque no Start()la Task.)

Una mejor solución es introducir otra interfaz para operaciones asíncronas. La nueva interfaz debe heredar de la interfaz original.

Ejemplo:

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

PD: Rediseñe sus operaciones asincrónicas para que devuelvan Task en lugar de void, a menos que realmente deba devolver void.