Jak wywołać metodę asynchroniczną z gettera lub settera?

Jaki byłby najbardziej elegancki sposób wywołania metody asynchronicznej z modułu pobierającego lub ustawiającego w języku C #?

Oto pseudo-kod, który pomoże mi się wyjaśnić.

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

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

Nie ma technicznego powodu, aby asyncwłaściwości nie były dozwolone w języku C #. Była to celowa decyzja projektowa, ponieważ „właściwości asynchroniczne” to oksymoron.

Właściwości powinny zwracać bieżące wartości; nie powinny rozpoczynać operacji w tle.

Zwykle, gdy ktoś chce „właściwości asynchronicznej”, tak naprawdę chce jednej z tych rzeczy:

1. Metoda asynchroniczna, która zwraca wartość. W takim przypadku zmień właściwość na asyncmetodę.
2. Wartość, która może zostać użyta w powiązaniu danych, ale musi zostać obliczona / pobrana asynchronicznie. W takim przypadku użyj asyncmetody fabrycznej dla obiektu zawierającego lub użyj async InitAsync()metody. Wartość powiązana z danymi będzie obowiązywać default(T)do momentu obliczenia / pobrania wartości.
3. Wartość, której utworzenie jest kosztowne, ale należy ją zapisać w pamięci podręcznej do wykorzystania w przyszłości. W takim przypadku skorzystaj AsyncLazy z mojego bloga lub biblioteki AsyncEx . To da ci awaitwłaściwość.

Aktualizacja: I obejmować właściwości asynchronicznych w jednym z moich ostatnich „asynchronicznych OOP” blogach.

Nie można go nazwać asynchronicznie, ponieważ nie ma asynchronicznej obsługi właściwości, tylko metody asynchroniczne. Jako takie istnieją dwie opcje, obie wykorzystujące fakt, że metody asynchroniczne w CTP są tak naprawdę tylko metodą zwracającą Task<T>lub Task:

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

Lub:

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

Naprawdę potrzebowałem wywołania, aby pochodziło z metody get, ze względu na moją oddzieloną architekturę. Więc wymyśliłem następującą implementację.

Użycie: Tytuł znajduje się w ViewModel lub obiekcie, który można statycznie zadeklarować jako zasób strony. Powiąż z nim, a wartość zostanie zapełniona bez blokowania interfejsu użytkownika, gdy funkcja getTitle () zwróci.

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

Myślę, że możemy poczekać na wartość zwracającą najpierw zero, a następnie uzyskaną prawdziwą wartość, więc w przypadku Pure MVVM (na przykład projekt PCL) uważam, że najbardziej eleganckim rozwiązaniem jest:

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

Możesz użyć w Taskten sposób:

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

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

Myślałem, że .GetAwaiter (). GetResult () było właśnie rozwiązaniem tego problemu, nie? na przykład:

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

Ponieważ Twoja „właściwość asynchroniczna” znajduje się w modelu widoku, możesz użyć AsyncMVVM :

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

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

Zadba o kontekst synchronizacji i powiadomienie o zmianie właściwości.

Nekromancja.
W .NET Core / NetStandard2 możesz użyć Nito.AsyncEx.AsyncContext.Runzamiast 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"));
    }


}

Jeśli po prostu wybierzesz System.Threading.Tasks.Task.Runlub System.Threading.Tasks.Task<int>.Run, to nie zadziała.

Myślę, że mój przykład poniżej może być zgodny z podejściem Stephena-Cleary'ego, ale chciałem podać zakodowany przykład. Jest to używane w kontekście powiązania danych, na przykład Xamarin.

Konstruktor klasy - a nawet ustawiający inną właściwość, od której jest zależny - może wywołać pustkę asynchroniczną, która zapełni właściwość po zakończeniu zadania bez potrzeby oczekiwania lub bloku. Kiedy w końcu uzyska wartość, zaktualizuje interfejs użytkownika za pośrednictwem mechanizmu NotifyPropertyChanged.

Nie jestem pewien co do jakichkolwiek skutków ubocznych wywołania aysnc void od konstruktora. Być może komentator opracuje obsługę błędów itp.

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


}

Kiedy natknąłem się na ten problem, próba uruchomienia synchronizacji metody asynchronicznej z narzędzia ustawiającego lub konstruktora doprowadziła mnie do impasu w wątku interfejsu użytkownika, a użycie procedury obsługi zdarzeń wymagało zbyt wielu zmian w ogólnym projekcie.
Rozwiązaniem było, jak to często bywa, po prostu jawne napisanie, co chciałem, niejawnie, co miało mieć inny wątek obsługujący operację i sprawienie, aby główny wątek czekał na zakończenie:

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

Można argumentować, że nadużywam frameworka, ale działa.

Sprawdzam wszystkie odpowiedzi, ale wszystkie mają problem z wydajnością.

na przykład w:

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 () => {Title = czekaj na getTitle ();});

użyj dyspozytora, co nie jest dobrą odpowiedzią.

ale istnieje proste rozwiązanie, po prostu zrób to:

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

Możesz zmienić właściwość na Task<IEnumerable>

i zrób coś takiego:

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

i używaj go tak, jak czekasz na MyList;