ゲッターまたはセッターから非同期メソッドを呼び出す方法は？

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有能な財産を与えるでしょう。

更新：私は最近の「非同期OOP」ブログ投稿の1つで非同期プロパティを取り上げています。

非同期プロパティのサポートはなく、非同期メソッドのみなので、非同期に呼び出すことはできません。そのため、2つのオプションがあり、どちらも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（）が戻るときに、UIをブロックせずに値が入力されます。

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

「非同期プロパティ」はビューモデルにあるため、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では機能しません。

以下の私の例は@ Stephen-Clearyのアプローチに従うかもしれないと思いますが、コード化された例を挙げたかったのです。これは、Xamarinなどのデータバインディングコンテキストで使用するためのものです。

クラスのコンストラクター-または実際に、それが依存する別のプロパティのセッター-は、待機またはブロックを必要とせずにタスクの完了時にプロパティを設定する非同期voidを呼び出すことができます。最終的に値を取得すると、NotifyPropertyChangedメカニズムを介してUIを更新します。

コンストラクターから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();
    }


}

この問題に遭遇したとき、セッターまたはコンストラクターのいずれかから非同期メソッドの同期を実行しようとすると、UIスレッドでデッドロックが発生し、イベントハンドラーを使用すると、一般的な設計に必要な変更が多すぎます。
多くの場合、解決策は、暗黙的に発生させたいことを明示的に書き込むことでした。これは、別のスレッドに操作を処理させ、メインスレッドに操作の完了を待機させることでした。

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のように使用します。