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

Quelle serait la façon 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'expliquer.

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

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

Il n'y a aucune raison techniqueasync propriétés ne sont pas autorisées en C #. C'était 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; ils ne devraient pas lancer d'opérations en arrière-plan.

Habituellement, quand quelqu'un veut une «propriété asynchrone», ce qu'il veut vraiment, c'est l'un d'entre eux:

1. Une méthode asynchrone qui renvoie une valeur. Dans ce cas, changez la propriété enasync méthode.
2. Une valeur qui peut être utilisée dans la liaison de données mais doit être calculée / récupérée de manière asynchrone. Dans ce cas, utilisez une asyncméthode d'usine pour l'objet conteneur ou utilisez une async InitAsync()méthode. La valeur liée aux données seradefault(T) jusqu'à ce que la valeur soit calculée / récupérée.
3. Une valeur coûteuse à créer, mais qui doit être mise en cache pour une utilisation future. Dans ce cas, utilisez à AsyncLazy partir de mon blog ou de la bibliothèque AsyncEx . Cela vous donnera une awaitpropriété en mesure.

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

Vous ne pouvez pas l'appeler de manière asynchrone, car il n'y a pas de prise en charge de propriété asynchrone, uniquement des méthodes asynchrones. En tant que tel, il existe deux options, les deux profitant du fait que les méthodes asynchrones dans le CTP ne sont en réalité qu'une méthode qui renvoie Task<T>ou 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;
    }
}

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

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

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

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

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

Vous pouvez utiliser Taskcomme ceci:

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

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

Je pensais que .GetAwaiter (). GetResult () était exactement la solution à ce problème, non? par exemple:

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

Puisque votre "propriété async" est dans un modèle de vue, vous pouvez utiliser AsyncMVVM :

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

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

Il s'occupera du contexte de synchronisation et de la notification de changement de propriété pour vous.

Nécromancement.
Dans .NET Core / NetStandard2, vous pouvez utiliser à la Nito.AsyncEx.AsyncContext.Runplace de 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"));
    }


}

Si vous avez simplement choisi System.Threading.Tasks.Task.Runou System.Threading.Tasks.Task<int>.Run, cela ne fonctionnerait pas.

Je pense que mon exemple ci-dessous peut suivre l'approche de @ Stephen-Cleary mais je voulais donner un exemple codé. Ceci est destiné à être utilisé dans un contexte de liaison de données, par exemple Xamarin.

Le constructeur de la classe - ou bien le poseur d'une autre propriété dont il dépend - peut appeler un vide asynchrone qui remplira la propriété à la fin de la tâche sans avoir besoin d'attendre ou de bloquer. Lorsqu'il obtient enfin une valeur, il met à jour votre interface utilisateur via le mécanisme NotifyPropertyChanged.

Je ne suis pas certain des effets secondaires de l'appel d'un vide aysnc à partir d'un constructeur. Peut-être qu'un intervenant développera la gestion des erreurs, etc.

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


}

Lorsque j'ai rencontré ce problème, essayer d'exécuter une synchronicité de méthode asynchrone à partir d'un setter ou d'un constructeur m'a mis dans une impasse sur le thread d'interface utilisateur, et l'utilisation d'un gestionnaire d'événements a nécessité trop de changements dans la conception générale.
La solution était, comme souvent, d'écrire explicitement ce que je voulais implicitement, c'est-à-dire d'avoir un autre thread pour gérer l'opération et pour que le thread principal attende qu'il se termine:

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

Vous pourriez dire que j'abuse du cadre, mais cela fonctionne.

J'examine toutes les réponses, mais toutes ont un problème de performances.

par exemple dans:

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

utilisez dispatcher qui n'est pas une bonne réponse.

mais il existe une solution simple, faites-le:

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

Vous pouvez changer la propriété en Task<IEnumerable>

et faites quelque chose comme:

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

et l'utiliser comme attendre MyList;