Wie rufe ich eine asynchrone Methode von einem Getter oder Setter auf?

Was wäre die eleganteste Art, eine asynchrone Methode von einem Getter oder Setter in C # aufzurufen?

Hier ist ein Pseudocode, der mir hilft, mich zu erklären.

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

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

Es gibt keinen technischen Grund, warum asyncEigenschaften in C # nicht zulässig sind. Es war eine gezielte Entwurfsentscheidung, da "asynchrone Eigenschaften" ein Oxymoron sind.

Eigenschaften sollten aktuelle Werte zurückgeben. Sie sollten keine Hintergrundoperationen starten.

Wenn jemand eine "asynchrone Eigenschaft" möchte, möchte er normalerweise Folgendes:

1. Eine asynchrone Methode, die einen Wert zurückgibt. Ändern Sie in diesem Fall die Eigenschaft in eine asyncMethode.
2. Ein Wert, der für die Datenbindung verwendet werden kann, aber asynchron berechnet / abgerufen werden muss. Verwenden Sie in diesem Fall entweder eine asyncFactory-Methode für das enthaltende Objekt oder eine async InitAsync()Methode. Der datengebundene Wert bleibt so lange bestehen, default(T)bis der Wert berechnet / abgerufen wurde.
3. Ein Wert, dessen Erstellung teuer ist, der jedoch für die zukünftige Verwendung zwischengespeichert werden sollte. In diesem Fall verwenden Sie AsyncLazy aus meinem Blog oder meiner AsyncEx-Bibliothek . Dies gibt Ihnen eine awaitfähige Eigenschaft.

Update: Ich beschreibe asynchrone Eigenschaften in einem meiner letzten " asynchronen OOP" -Blogposts.

Sie können es nicht asynchron aufrufen, da es keine Unterstützung für asynchrone Eigenschaften gibt, sondern nur asynchrone Methoden. Daher gibt es zwei Optionen, die beide die Tatsache ausnutzen, dass asynchrone Methoden im CTP eigentlich nur eine Methode sind, die zurückgibt Task<T>oder Task:

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

Oder:

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

Aufgrund meiner entkoppelten Architektur brauchte ich den Aufruf wirklich, um von der get-Methode zu stammen. Also habe ich mir die folgende Implementierung ausgedacht.

Verwendung: Der Titel befindet sich in einem ViewModel oder einem Objekt, das Sie statisch als Seitenressource deklarieren können. Wenn Sie daran binden, wird der Wert gefüllt, ohne die Benutzeroberfläche zu blockieren, wenn getTitle () zurückkehrt.

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

Ich denke, wir können darauf warten, dass der Wert zuerst null zurückgibt und dann den tatsächlichen Wert erhält. Im Fall von Pure MVVM (z. B. PCL-Projekt) halte ich Folgendes für die eleganteste Lösung:

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

Sie können Taskwie folgt verwenden:

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

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

Ich dachte. GetAwaiter (). GetResult () war genau die Lösung für dieses Problem, nein? z.B:

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

Da sich Ihre "asynchrone Eigenschaft" in einem Ansichtsmodell befindet, können Sie AsyncMVVM verwenden :

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

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

Es kümmert sich für Sie um den Synchronisationskontext und die Benachrichtigung über Eigenschaftsänderungen.

Nekromantie.
In .NET Core / NetStandard2 können Sie Nito.AsyncEx.AsyncContext.Runanstelle von 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"));
    }


}

Wenn Sie einfach System.Threading.Tasks.Task.Runoder System.Threading.Tasks.Task<int>.Runwählen würden, würde es nicht funktionieren.

Ich denke, mein Beispiel unten folgt möglicherweise dem Ansatz von @ Stephen-Cleary, aber ich wollte ein codiertes Beispiel geben. Dies dient zur Verwendung in einem Datenbindungskontext, beispielsweise Xamarin.

Der Konstruktor der Klasse - oder tatsächlich der Setter einer anderen Eigenschaft, von der er abhängig ist - kann eine asynchrone Leere aufrufen, die die Eigenschaft nach Abschluss der Aufgabe auffüllt, ohne dass ein Warten oder Blockieren erforderlich ist. Wenn es endlich einen Wert erhält, aktualisiert es Ihre Benutzeroberfläche über den NotifyPropertyChanged-Mechanismus.

Ich bin mir nicht sicher, welche Nebenwirkungen es hat, wenn ein Konstruktor eine aysnc-Leere aufruft. Vielleicht wird ein Kommentator die Fehlerbehandlung usw. näher erläutern.

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


}

Als ich auf dieses Problem stieß, führte der Versuch, eine asynchrone Methodensynchronität von einem Setter oder einem Konstruktor aus auszuführen, zu einem Deadlock im UI-Thread, und die Verwendung eines Ereignishandlers erforderte zu viele Änderungen im allgemeinen Design.
Die Lösung bestand, wie so oft, darin, explizit zu schreiben, was ich implizit tun wollte, nämlich einen anderen Thread die Operation abwickeln zu lassen und den Haupt-Thread dazu zu bringen, auf den Abschluss zu warten:

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

Sie könnten argumentieren, dass ich das Framework missbrauche, aber es funktioniert.

Ich überprüfe alle Antworten, aber alle haben ein Leistungsproblem.

zum Beispiel in:

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 = warte auf getTitle ();});

Verwenden Sie einen Dispatcher, der keine gute Antwort ist.

Aber es gibt eine einfache Lösung, machen Sie es einfach:

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

Sie können die Eigenschaft in ändern Task<IEnumerable>

und mache so etwas wie:

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

und benutze es wie auf MyList warten;