Como chamar um método assíncrono de um getter ou setter?

Qual seria a maneira mais elegante de chamar um método assíncrono de um getter ou setter em C #?

Aqui estão alguns pseudo-códigos para ajudar a me explicar.

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

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

Não há razão técnica para que asyncpropriedades não sejam permitidas em C #. Foi uma decisão de projeto proposital, porque "propriedades assíncronas" é um oxímoro.

Propriedades devem retornar valores atuais; eles não devem iniciar operações em segundo plano.

Normalmente, quando alguém deseja uma "propriedade assíncrona", o que realmente deseja é um destes:

1. Um método assíncrono que retorna um valor. Nesse caso, altere a propriedade para um asyncmétodo
2. Um valor que pode ser usado na ligação de dados, mas deve ser calculado / recuperado de forma assíncrona. Nesse caso, use um asyncmétodo de fábrica para o objeto que contém ou use um async InitAsync()método. O valor vinculado aos dados será default(T)até que o valor seja calculado / recuperado.
3. Um valor que é caro para criar, mas deve ser armazenado em cache para uso futuro. Nesse caso, use AsyncLazy no meu blog ou na biblioteca AsyncEx . Isso lhe dará uma awaitpropriedade capaz.

Update: Eu cobrir propriedades assíncronas em um dos meus últimos "assíncronos OOP" posts.

Você não pode chamá-lo de forma assíncrona, pois não há suporte a propriedades assíncronas, apenas métodos assíncronos. Como tal, existem duas opções, ambas aproveitando o fato de que os métodos assíncronos no CTP são realmente apenas um método que retorna 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;
    }
}

Eu realmente precisava da chamada para se originar do método get, devido à minha arquitetura desacoplada. Então, eu vim com a seguinte implementação.

Uso: o título está em um ViewModel ou em um objeto que você pode declarar estaticamente como um recurso de página. Associe-se a ele e o valor será preenchido sem bloquear a interface do usuário, quando getTitle () retornar.

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

Acho que podemos aguardar o valor retornando primeiro nulo e, em seguida, obtendo o valor real, portanto, no caso do Pure MVVM (projeto PCL por exemplo), acho que a seguinte é a solução mais 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();
}

Você pode usar Taskassim:

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

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

Eu pensei que. GetAwaiter (). GetResult () era exatamente a solução para este problema, não? por exemplo:

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

Como sua "propriedade assíncrona" está em um modelo de exibição, você pode usar o AsyncMVVM :

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

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

Ele cuidará do contexto de sincronização e da notificação de alteração de propriedade para você.

Necromante.
No .NET Core / NetStandard2, você pode usar em Nito.AsyncEx.AsyncContext.Runvez 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"));
    }


}

Se você simplesmente escolheu System.Threading.Tasks.Task.Runou System.Threading.Tasks.Task<int>.Run, então não funcionaria.

Acho que meu exemplo abaixo pode seguir a abordagem de Stephen-Cleary, mas eu queria dar um exemplo codificado. Isso é para uso em um contexto de ligação de dados, por exemplo, Xamarin.

O construtor da classe - ou mesmo o criador de outra propriedade da qual depende - pode chamar um vazio assíncrono que preencherá a propriedade após a conclusão da tarefa sem a necessidade de aguardar ou bloquear. Quando finalmente obtiver um valor, atualizará sua interface do usuário por meio do mecanismo NotifyPropertyChanged.

Não tenho certeza sobre nenhum efeito colateral de chamar um aysnc de um construtor. Talvez um comentarista elabore um tratamento de erro, 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();
    }


}

Quando me deparei com esse problema, tentar executar uma sincronicidade de método assíncrono de um setter ou de um construtor me levou a um impasse no encadeamento da interface do usuário, e o uso de um manipulador de eventos exigiu muitas alterações no design geral.
A solução era, como sempre é, escrever explicitamente o que eu queria que acontecesse implicitamente, que era ter outro thread para lidar com a operação e fazer com que o thread principal esperasse o término:

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

Você poderia argumentar que eu abusei da estrutura, mas funciona.

Analiso todas as respostas, mas todas têm um problema de desempenho.

por exemplo em:

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

use despachante que não é uma boa resposta.

mas existe uma solução simples, basta fazê-lo:

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

Você pode alterar a propriedade para Task<IEnumerable>

e faça algo como:

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

e use-o como aguarde MyList;