Comment appeler une méthode asynchrone depuis un getter ou un setter ?

Question

Quelle serait la manière la plus élégante d'appeler une méthode asynchrone à partir d'un getter ou d'un setter en C# ?

Voici un pseudo-code pour m'aider à m'expliquer.

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

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

Answer 1

Il n'y a pas technique raison pour laquelle async ne sont pas autorisées en C#. Il s'agit d'une décision de conception délibérée, car les "propriétés asynchrones" sont un oxymore.

Les propriétés doivent renvoyer les valeurs actuelles ; elles ne doivent pas déclencher d'opérations en arrière-plan.

En général, lorsque quelqu'un veut une "propriété asynchrone", ce qu'il veut vraiment, c'est une de ces propriétés :

1. Une méthode asynchrone qui renvoie une valeur. Dans ce cas, changez la propriété en une async méthode.
2. Une valeur qui peut être utilisée dans la liaison de données mais qui doit être calculée/récupérée de manière asynchrone. Dans ce cas, il faut soit utiliser un async pour l'objet contenant ou utiliser une méthode d'usine async InitAsync() méthode. La valeur liée aux données sera default(T) jusqu'à ce que la valeur soit calculée/récupérée.
3. Une valeur dont la création est coûteuse, mais qui doit être mise en cache pour une utilisation ultérieure. Dans ce cas, utilisez AsyncLazy de mon blog o Bibliothèque AsyncEx . Cela vous donnera un await de la propriété.

Mise à jour : Je couvre propriétés asynchrones dans l'un de mes récents billets de blog "async OOP".

Answer 2

Vous ne pouvez pas l'appeler de manière asynchrone, car il n'y a pas de support pour les propriétés asynchrones, seulement pour les méthodes asynchrones. En tant que tel, il existe deux options, toutes deux tirant parti du fait que les méthodes asynchrones dans la PTC sont en réalité simplement une méthode qui renvoie Task<T> o Task :

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

Ou :

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

Answer 3

J'avais vraiment besoin que l'appel provienne de la méthode get, en raison de mon architecture découplée. J'ai donc créé l'implémentation suivante.

Uso: Titre est dans un ViewModel ou un objet que vous pourriez déclarer statiquement comme ressource de page. Liez-le et la valeur sera remplie sans bloquer l'interface utilisateur, lorsque getTitle() revient.

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

Answer 4

Vous pouvez utiliser Task comme ceci :

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

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

Answer 5

Je pense que nous pouvons attendre la valeur en retournant d'abord null et ensuite obtenir la vraie valeur, donc dans le cas de Pure MVVM (projet PCL par exemple) je pense que la solution suivante est la plus élégante :

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