Как вызвать асинхронный метод из метода получения или установки?

Каков был бы самый элегантный способ вызова асинхронного метода из метода получения или установки в C #?

Вот некоторый псевдокод, чтобы объяснить себя.

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

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

Нет технической причиныasync свойства не разрешены в C #. Это было целенаправленное дизайнерское решение, потому что «асинхронные свойства» - это оксюморон.

Свойства должны возвращать текущие значения; они не должны начинать фоновые операции.

Обычно, когда кто-то хочет «асинхронное свойство», он действительно хочет получить один из них:

1. Асинхронный метод, который возвращает значение. В этом случае измените свойство на asyncметод.
2. Значение, которое может использоваться в привязке данных, но должно вычисляться / извлекаться асинхронно. В этом случае либо используйте asyncфабричный метод для содержащего объекта, либо используйте async InitAsync()метод. Значение, привязанное к данным, будет default(T)до тех пор, пока значение не будет вычислено / получено.
3. Значение, которое дорого создать, но должно быть кэшировано для будущего использования. В этом случае используйте AsyncLazy из моего блога или библиотеки AsyncEx . Это даст вам awaitспособную собственность.

Обновление: я рассматриваю асинхронные свойства в одной из моих недавних публикаций в блоге "async OOP".

Вы не можете вызывать его асинхронно, поскольку нет поддержки асинхронных свойств, только асинхронные методы. Таким образом, есть две опции, каждая из которых использует тот факт, что асинхронные методы в CTP - это на самом деле просто метод, который возвращает Task<T>или Task:

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

Или:

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

Мне действительно нужно, чтобы вызов происходил из метода get из-за моей отделенной архитектуры. Поэтому я придумал следующую реализацию.

Использование: Заголовок находится в ViewModel или объекте, который вы можете статически объявить как ресурс страницы. Привязка к нему и значение будет заполнено без блокировки пользовательского интерфейса, когда getTitle () вернется.

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

Я думаю, что мы можем подождать, пока значение вернет сначала значение null, а затем получит реальное значение, поэтому в случае Pure MVVM (например, проект PCL) я думаю, что наиболее элегантным решением является следующее:

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

Вы можете использовать Taskкак это:

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

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

Я думал, что .GetAwaiter (). GetResult () был именно этим решением, не так ли? например:

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

Поскольку ваше «свойство async» находится в модели представления, вы можете использовать AsyncMVVM :

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

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

Он позаботится об уведомлении о контексте синхронизации и уведомлении об изменении свойства.

Necromancing.
В .NET Core / NetStandard2 вы можете использовать Nito.AsyncEx.AsyncContext.Runвместо 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"));
    }


}

Если вы просто выбрали System.Threading.Tasks.Task.Runили System.Threading.Tasks.Task<int>.Run, то это не сработает.

Я думаю, что мой пример ниже может следовать подходу @ Stephen-Cleary, но я хотел бы привести закодированный пример. Это для использования в контексте привязки данных, например, Xamarin.

Конструктор класса - или, на самом деле, установщик другого свойства, от которого он зависит, - может вызвать асинхронную пустоту, которая заполнит свойство по завершении задачи без необходимости ожидания или блокировки. Когда он наконец получит значение, он обновит ваш пользовательский интерфейс с помощью механизма NotifyPropertyChanged.

Я не уверен в каких-либо побочных эффектах вызова aysnc void от конструктора. Возможно, комментатор остановится на обработке ошибок и т. Д.

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


}

Когда я столкнулся с этой проблемой, попытка запустить синхронность асинхронных методов из установщика или конструктора привела меня в тупик в потоке пользовательского интерфейса, а использование обработчика событий потребовало слишком много изменений в общем проекте.
Решением было, как часто, было просто написать явно то, что я хотел, чтобы происходило неявно, а именно, чтобы другой поток обрабатывал операцию и чтобы основной поток ожидал ее завершения:

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

Можно утверждать, что я злоупотребляю фреймворком, но это работает.

Я просматриваю все ответы, но у всех есть проблемы с производительностью.

например в:

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

используйте диспетчер, который не является хорошим ответом.

но есть простое решение, просто сделайте это:

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

Вы можете изменить свойство на Task<IEnumerable>

и сделать что-то вроде:

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

и используйте его как ожидание MyList;