Come chiamare un metodo asincrono da un getter o setter?

Quale sarebbe il modo più elegante per chiamare un metodo asincrono da un getter o setter in C #?

Ecco alcuni pseudo-codici per aiutare a spiegarmi.

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

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

Non esiste alcun motivo tecnico per cui le asyncproprietà non sono consentite in C #. È stata una decisione progettuale intenzionale, perché "proprietà asincrone" è un ossimoro.

Le proprietà dovrebbero restituire i valori correnti; non dovrebbero iniziare le operazioni in background.

Di solito, quando qualcuno vuole una "proprietà asincrona", quello che vuole veramente è uno di questi:

1. Un metodo asincrono che restituisce un valore. In questo caso, modificare la proprietà in un asyncmetodo.
2. Un valore che può essere utilizzato nell'associazione dati ma che deve essere calcolato / recuperato in modo asincrono. In questo caso, utilizzare un asyncmetodo factory per l'oggetto contenitore o utilizzare un async InitAsync()metodo. Il valore associato ai dati sarà default(T)fino a quando il valore non verrà calcolato / recuperato.
3. Un valore che è costoso da creare, ma deve essere memorizzato nella cache per uso futuro. In questo caso, utilizzare AsyncLazy dal mio blog o dalla libreria AsyncEx . Questo ti darà una awaitproprietà capace.

Aggiornamento: copro le proprietà asincrone in uno dei miei recenti post sul blog "async OOP".

Non è possibile chiamarlo in modo asincrono, poiché non esiste un supporto di proprietà asincrono, ma solo metodi asincroni. Come tale, ci sono due opzioni, entrambe che sfruttano il fatto che i metodi asincroni nel CTP sono in realtà solo un metodo che restituisce Task<T>o Task:

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

O:

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

Avevo davvero bisogno che la chiamata provenisse dal metodo get, a causa della mia architettura disaccoppiata. Quindi ho pensato alla seguente implementazione.

Utilizzo: il titolo si trova in un ViewModel o in un oggetto che è possibile dichiarare staticamente come risorsa di pagina. Associati ad esso e il valore verrà popolato senza bloccare l'interfaccia utente, quando getTitle () restituisce.

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

Penso che possiamo aspettare che il valore restituisca prima il primo null e poi ottenga il valore reale, quindi nel caso di Pure MVVM (progetto PCL per esempio) penso che la seguente sia la soluzione più elegante:

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

Puoi usare Taskcosì:

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

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

Ho pensato .GetAwaiter (). GetResult () era esattamente la soluzione a questo problema, no? per esempio:

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

Poiché la "proprietà asincrona" si trova in un modello di visualizzazione, è possibile utilizzare AsyncMVVM :

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

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

Si occuperà del contesto di sincronizzazione e della notifica di modifica della proprietà per te.

Necromancing.
In .NET Core / NetStandard2, è possibile utilizzare Nito.AsyncEx.AsyncContext.Runinvece di 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"));
    }


}

Se scegli semplicemente System.Threading.Tasks.Task.Runo System.Threading.Tasks.Task<int>.Run, non funzionerebbe.

Penso che il mio esempio di seguito possa seguire l'approccio di @ Stephen-Cleary, ma volevo fare un esempio in codice. Questo è per l'uso in un contesto di associazione dei dati, ad esempio Xamarin.

Il costruttore della classe - o in effetti il ​​setter di un'altra proprietà da cui dipende - può chiamare un vuoto asincrono che popolerà la proprietà al completamento dell'attività senza la necessità di attendere o bloccare. Quando finalmente ottiene un valore, aggiornerà l'interfaccia utente tramite il meccanismo NotifyPropertyChanged.

Non sono sicuro di alcun effetto collaterale di chiamare un vuoto aysnc da un costruttore. Forse un commentatore elaborerà la gestione degli errori ecc.

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


}

Quando ho riscontrato questo problema, il tentativo di eseguire una sincronicità del metodo asincrono da un setter o da un costruttore mi ha messo in un deadlock sul thread dell'interfaccia utente e l'utilizzo di un gestore di eventi ha richiesto troppe modifiche al progetto generale.
La soluzione era, come spesso accade, scrivere esplicitamente ciò che volevo accadesse implicitamente, ovvero avere un altro thread che gestisse l'operazione e ottenere il thread principale in attesa che finisse:

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

Si potrebbe sostenere che io abuso del framework, ma funziona.

Esamino tutte le risposte ma tutte hanno un problema di prestazioni.

ad esempio 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 = await getTitle ();});

usa il dispatcher che non è una buona risposta.

ma esiste una soluzione semplice, basta farlo:

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

È possibile modificare la proprietà in Task<IEnumerable>

e fai qualcosa del tipo:

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

e usalo come aspetto MyList;