Як викликати метод асинхронізації від геттера чи сетера?

Що може бути найелегантнішим способом викликати метод асинхрування від геттера чи сетера в 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");
        }
    }
}

Я думаю, що ми можемо чекати, коли значення просто поверне нуль, а потім отримає реальне значення, тож у випадку 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");
        }
    }
}

Оскільки ваше "властивість асинхронізації" перебуває у моделі перегляду, ви можете використовувати AsyncMVVM :

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

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

Він подбає про контекст синхронізації та повідомлення про зміну властивості для вас.

Некромантування.
У .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, то це не вийде.

Я думаю, що мій приклад нижче може слідувати підходу Стефана-Клірі, але я хотів навести закодований приклад. Це для використання в контексті зв'язування даних, наприклад, Xamarin.

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

Я не впевнений у будь-яких побічних ефектах виклику айсн-пустоти від конструктора. Можливо, коментатор розробить питання щодо помилок тощо.

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 () => {Заголовок = очікуємо 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;