Arabirim uygulamalarını eşzamansız yapma

Şu anda bazı Async yöntemlerini kullanarak uygulamamı yapmaya çalışıyorum. Tüm IO'm, bir arayüzün açık uygulamaları aracılığıyla yapılıyor ve işlemleri eşzamansız hale getirme konusunda biraz kafam karıştı.

Gördüğüm kadarıyla uygulamada iki seçeneğim var:

interface IIO
{
    void DoOperation();
}

SEÇENEK1: Zaman uyumsuz örtük bir uygulama yapın ve örtük uygulamada sonucu bekleyin.

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
}

SEÇENEK2: Açık uygulamayı zaman uyumsuz yapın ve görevi örtük uygulamadan bekleyin.

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

    #region IIOAsync Members

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

    #endregion
}

Bu uygulamalardan biri diğerinden daha mı iyi yoksa benim düşünmediğim başka bir yol var mı?

Bu seçeneklerin hiçbiri doğru değil. Zaman uyumsuz bir arayüz uygulamaya çalışıyorsunuz. Bunu yapma. Sorun şu ki, DoOperation()geri döndüğünde işlem henüz tamamlanmayacak. Daha da kötüsü, işlem sırasında bir istisna olursa (ki bu, IO işlemlerinde çok yaygındır), kullanıcının bu istisnayla başa çıkma şansı olmayacaktır.

Yapmanız gereken , arabirimi eşzamansız olacak şekilde değiştirmektir :

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

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

Bu şekilde kullanıcı işlemin olduğunu asyncgörecek ve yapabilecektir await. Bu aynı zamanda kodunuzun kullanıcılarını geçiş yapmaya zorlar async, ancak bu kaçınılmazdır.

Ayrıca, StartNew()uygulamanızda kullanmanın sadece bir örnek olduğunu varsayıyorum , asenkron IO uygulamak için buna ihtiyacınız olmamalı. (Ve new Task()değil mi, çünkü o bile işleyecek, daha da kötü .)Start()Task

Daha iyi çözüm, zaman uyumsuz işlemler için başka bir arabirim sunmaktır. Yeni arayüz, orijinal arayüzden miras almalıdır.

Misal:

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 Eşzamansız işlemlerinizi, gerçekten void döndürmeniz gerekmedikçe, void yerine Task döndürecek şekilde yeniden tasarlayın.