getter 또는 setter에서 비동기 메소드를 호출하는 방법은 무엇입니까?

C #의 getter 또는 setter에서 비동기 메서드를 호출하는 가장 우아한 방법은 무엇입니까?

자신을 설명하는 데 도움이되는 의사 코드가 있습니다.

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

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

C #에서 속성을 사용할 수 없는 기술적 이유 async는 없습니다. "비동기 특성"이 옥시 모론이기 때문에 의도적 인 설계 결정이었습니다.

속성은 현재 값을 반환해야합니다. 백그라운드 작업을 시작해서는 안됩니다.

일반적으로 누군가 "비동기 속성"을 원할 때 실제로 원하는 것은 다음 중 하나입니다.

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 ()이 반환 될 때 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과 같은 데이터 바인딩 컨텍스트에서 사용하기위한 것입니다.

클래스의 생성자 또는 클래스가 의존하는 다른 속성의 setter는 대기 또는 블록이 없어도 작업 완료시 속성을 채우는 비동기 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();
    }


}

이 문제가 발생했을 때 setter 또는 생성자에서 비동기 메서드 동기화를 실행하려고하면 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 () => {제목 = 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를 기다리는 것처럼 사용하십시오.