Bagaimana cara memanggil metode async dari pengambil atau penyetel?

Apa cara paling elegan untuk memanggil metode async dari pengambil atau penyetel di C #?

Berikut ini beberapa pseudo-code untuk membantu menjelaskan diri saya.

async Task<IEnumerable> MyAsyncMethod()
{
    return await DoSomethingAsync();
}

public IEnumerable MyList
{
    get
    {
         //call MyAsyncMethod() here
    }
}

Tidak ada alasan teknis bahwa asyncproperti tidak diizinkan dalam C #. Itu adalah keputusan desain yang disengaja, karena "sifat asinkron" adalah sebuah oxymoron.

Properti harus mengembalikan nilai saat ini; mereka seharusnya tidak memulai operasi latar belakang.

Biasanya, ketika seseorang menginginkan "properti asinkron", yang sebenarnya mereka inginkan adalah salah satunya:

1. Metode asinkron yang mengembalikan nilai. Dalam hal ini, ubah properti menjadi asyncmetode.
2. Nilai yang dapat digunakan dalam pengikatan data tetapi harus dihitung / diambil secara tidak sinkron. Dalam hal ini, gunakan asyncmetode pabrik untuk objek yang berisi atau gunakan async InitAsync()metode. Nilai yang terikat data akan default(T)sampai nilai dihitung / diambil.
3. Nilai yang mahal untuk dibuat, tetapi harus di-cache untuk digunakan di masa mendatang. Dalam hal ini, gunakan AsyncLazy dari blog saya atau perpustakaan AsyncEx . Ini akan memberi Anda awaitproperti yang bisa.

Pembaruan: Saya membahas properti asinkron di salah satu posting blog "async OOP" terbaru saya.

Anda tidak dapat menyebutnya asinkron, karena tidak ada dukungan properti asinkron, hanya metode asinkron. Dengan demikian, ada dua opsi, keduanya mengambil keuntungan dari fakta bahwa metode asinkron dalam CTP benar-benar hanya metode yang mengembalikan Task<T>atau Task:

// Make the property return a Task<T>
public Task<IEnumerable> MyList
{
    get
    {
         // Just call the method
         return MyAsyncMethod();
    }
}

Atau:

// Make the property blocking
public IEnumerable MyList
{
    get
    {
         // Block via .Result
         return MyAsyncMethod().Result;
    }
}

Saya benar-benar membutuhkan panggilan untuk berasal dari metode get, karena arsitektur dipisahkan saya. Jadi saya datang dengan implementasi berikut.

Penggunaan: Judul dalam ViewModel atau objek yang bisa Anda deklarasikan secara statis sebagai sumber halaman. Ikat padanya dan nilainya akan dipopulasi tanpa memblokir UI, ketika getTitle () kembali.

string _Title;
public string Title
{
    get
    {
        if (_Title == null)
        {   
            Deployment.Current.Dispatcher.InvokeAsync(async () => { Title = await getTitle(); });
        }
        return _Title;
    }
    set
    {
        if (value != _Title)
        {
            _Title = value;
            RaisePropertyChanged("Title");
        }
    }
}

Saya pikir kita bisa menunggu nilainya hanya mengembalikan nol pertama dan kemudian mendapatkan nilai nyata, jadi dalam kasus Pure MVVM (proyek PCL misalnya) saya pikir yang berikut ini adalah solusi paling elegan:

private IEnumerable myList;
public IEnumerable MyList
{
  get
    { 
      if(myList == null)
         InitializeMyList();
      return myList;
     }
  set
     {
        myList = value;
        NotifyPropertyChanged();
     }
}

private async void InitializeMyList()
{
   MyList = await AzureService.GetMyList();
}

Anda bisa menggunakan Taskseperti ini:

public int SelectedTab
        {
            get => selected_tab;
            set
            {
                selected_tab = value;

                new Task(async () =>
                {
                    await newTab.ScaleTo(0.8);
                }).Start();
            }
        }

Saya pikir .GetAwaiter (). GetResult () adalah solusi tepat untuk masalah ini, bukan? misalnya:

string _Title;
public string Title
{
    get
    {
        if (_Title == null)
        {   
            _Title = getTitle().GetAwaiter().GetResult();
        }
        return _Title;
    }
    set
    {
        if (value != _Title)
        {
            _Title = value;
            RaisePropertyChanged("Title");
        }
    }
}

Karena "properti async" Anda ada dalam model tampilan, Anda bisa menggunakan AsyncMVVM :

class MyViewModel : AsyncBindableBase
{
    public string Title
    {
        get
        {
            return Property.Get(GetTitleAsync);
        }
    }

    private async Task<string> GetTitleAsync()
    {
        //...
    }
}

Ini akan menangani konteks sinkronisasi dan pemberitahuan perubahan properti untuk Anda.

Necromancing.
Di .NET Core / NetStandard2, Anda bisa menggunakan Nito.AsyncEx.AsyncContext.Runalih-alih System.Windows.Threading.Dispatcher.InvokeAsync:

class AsyncPropertyTest
{

    private static async System.Threading.Tasks.Task<int> GetInt(string text)
    {
        await System.Threading.Tasks.Task.Delay(2000);
        System.Threading.Thread.Sleep(2000);
        return int.Parse(text);
    }


    public static int MyProperty
    {
        get
        {
            int x = 0;

            // /programming/6602244/how-to-call-an-async-method-from-a-getter-or-setter
            // /programming/41748335/net-dispatcher-for-net-core
            // https://github.com/StephenCleary/AsyncEx
            Nito.AsyncEx.AsyncContext.Run(async delegate ()
            {
                x = await GetInt("123");
            });

            return x;
        }
    }


    public static void Test()
    {
        System.Console.WriteLine(System.DateTime.Now.ToString("dd.MM.yyyy HH:mm:ss.fff"));
        System.Console.WriteLine(MyProperty);
        System.Console.WriteLine(System.DateTime.Now.ToString("dd.MM.yyyy HH:mm:ss.fff"));
    }


}

Jika Anda hanya memilih System.Threading.Tasks.Task.Runatau System.Threading.Tasks.Task<int>.Run, maka itu tidak akan berhasil.

Saya pikir contoh saya di bawah ini mungkin mengikuti pendekatan @ Stephen-Cleary tetapi saya ingin memberikan contoh kode. Ini untuk digunakan dalam konteks pengikatan data misalnya Xamarin.

Konstruktor kelas - atau memang setter properti lain di mana ia bergantung - dapat menyebut kekosongan async yang akan mengisi properti pada penyelesaian tugas tanpa perlu menunggu atau memblokir. Ketika akhirnya mendapatkan nilai, itu akan memperbarui UI Anda melalui mekanisme NotifyPropertyChanged.

Saya tidak yakin tentang efek samping dari memanggil aysnc batal dari konstruktor. Mungkin komentator akan menguraikan penanganan kesalahan dll.

class MainPageViewModel : INotifyPropertyChanged
{
    IEnumerable myList;

    public event PropertyChangedEventHandler PropertyChanged;

    public MainPageViewModel()
    {

        MyAsyncMethod()

    }

    public IEnumerable MyList
    {
        set
        {
            if (myList != value)
            {
                myList = value;

                if (PropertyChanged != null)
                {
                    PropertyChanged(this, new PropertyChangedEventArgs("MyList"));
                }
            }
        }
        get
        {
            return myList;
        }
    }

    async void MyAsyncMethod()
    {
        MyList = await DoSomethingAsync();
    }


}

Ketika saya mengalami masalah ini, mencoba menjalankan sinkronisasi metode async baik dari setter atau konstruktor membuat saya menemui jalan buntu pada utas UI, dan menggunakan event handler memerlukan terlalu banyak perubahan dalam desain umum.
Solusinya adalah, seperti sering, hanya menulis secara eksplisit apa yang saya inginkan terjadi secara implisit, yaitu memiliki utas lain menangani operasi dan mendapatkan utas utama untuk menunggu sampai selesai:

string someValue=null;
var t = new Thread(() =>someValue = SomeAsyncMethod().Result);
t.Start();
t.Join();

Anda bisa membantah bahwa saya menyalahgunakan kerangka kerja, tetapi itu berhasil.

Saya meninjau semua jawaban tetapi semua memiliki masalah kinerja.

misalnya di:

string _Title;
public string Title
{
    get
    {
        if (_Title == null)
        {   
            Deployment.Current.Dispatcher.InvokeAsync(async () => { Title = await getTitle(); });
        }
        return _Title;
    }
    set
    {
        if (value != _Title)
        {
            _Title = value;
            RaisePropertyChanged("Title");
        }
    }
}

Deployment.Current.Dispatcher.InvokeAsync (async () => {Judul = menunggu getTitle ();});

gunakan operator yang bukan jawaban yang baik.

tetapi ada solusi sederhana, lakukan saja:

string _Title;
    public string Title
    {
        get
        {
            if (_Title == null)
            {   
                Task.Run(()=> 
                {
                    _Title = getTitle();
                    RaisePropertyChanged("Title");
                });        
                return;
            }
            return _Title;
        }
        set
        {
            if (value != _Title)
            {
                _Title = value;
                RaisePropertyChanged("Title");
            }
        }
    }

Anda dapat mengubah proerty menjadi Task<IEnumerable>

dan lakukan sesuatu seperti:

get
{
    Task<IEnumerable>.Run(async()=>{
       return await getMyList();
    });
}

dan gunakan seperti menunggu MyList;