Làm thế nào để gọi một phương thức async từ getter hoặc setter?

Điều gì là cách thanh lịch nhất để gọi một phương thức async từ getter hoặc setter trong C #?

Đây là một số mã giả để giúp giải thích bản thân mình.

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

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

Không có lý do kỹ thuật rằng asynccác thuộc tính không được phép trong C #. Đó là một quyết định thiết kế có mục đích, bởi vì "tính chất không đồng bộ" là một oxymoron.

Các thuộc tính nên trả về giá trị hiện tại; họ không nên khởi động các hoạt động nền.

Thông thường, khi ai đó muốn có "tài sản không đồng bộ", điều họ thực sự muốn là một trong những điều sau:

1. Một phương thức không đồng bộ trả về một giá trị. Trong trường hợp này, thay đổi thuộc tính thành một asyncphương thức.
2. Một giá trị có thể được sử dụng trong liên kết dữ liệu nhưng phải được tính toán / truy xuất không đồng bộ. Trong trường hợp này, hoặc sử dụng một asyncphương thức xuất xưởng cho đối tượng chứa hoặc sử dụng một async InitAsync()phương thức. Giá trị giới hạn dữ liệu sẽ default(T)cho đến khi giá trị được tính / lấy.
3. Một giá trị đắt tiền để tạo, nhưng nên được lưu trữ để sử dụng trong tương lai. Trong trường hợp này, sử dụng AsyncLazy từ thư viện blog hoặc AsyncEx của tôi . Điều này sẽ cung cấp cho bạn một awaittài sản có thể.

Cập nhật: Tôi bao gồm các thuộc tính không đồng bộ trong một trong các bài đăng blog "async OOP" gần đây của tôi.

Bạn không thể gọi nó là không đồng bộ, vì không có hỗ trợ thuộc tính không đồng bộ, chỉ có các phương thức không đồng bộ. Như vậy, có hai tùy chọn, cả hai đều lợi dụng thực tế là các phương thức không đồng bộ trong CTP thực sự chỉ là một phương thức trả về Task<T>hoặc Task:

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

Hoặc là:

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

Tôi thực sự cần cuộc gọi bắt nguồn từ phương thức get, do kiến ​​trúc tách rời của tôi. Vì vậy, tôi đã đưa ra cách thực hiện sau đây.

Cách sử dụng: Tiêu đề nằm trong ViewModel hoặc một đối tượng bạn có thể khai báo tĩnh dưới dạng tài nguyên trang. Liên kết với nó và giá trị sẽ được điền mà không chặn UI, khi getTitle () trả về.

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

Tôi nghĩ rằng chúng ta có thể chờ đợi giá trị chỉ trả về null đầu tiên và sau đó nhận giá trị thực, vì vậy trong trường hợp Pure MVVM (ví dụ dự án PCL) Tôi nghĩ rằng đây là giải pháp thanh lịch nhất:

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

Bạn có thể sử dụng Tasknhư thế này:

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

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

Tôi nghĩ .GetAwaiter (). GetResult () chính xác là giải pháp cho vấn đề này, phải không? ví dụ:

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

Vì "thuộc tính async" của bạn nằm trong chế độ xem, bạn có thể sử dụng AsyncMVVM :

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

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

Nó sẽ chăm sóc bối cảnh đồng bộ hóa và thông báo thay đổi thuộc tính cho bạn.

Necromance.
Trong .NET Core / NetSt Chuẩn2, bạn có thể sử dụng Nito.AsyncEx.AsyncContext.Runthay vì 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"));
    }


}

Nếu bạn chỉ đơn giản chọn System.Threading.Tasks.Task.Runhoặc System.Threading.Tasks.Task<int>.Run, thì nó sẽ không hoạt động.

Tôi nghĩ ví dụ của tôi dưới đây có thể theo cách tiếp cận của @ Stephen-Cleary nhưng tôi muốn đưa ra một ví dụ được mã hóa. Điều này được sử dụng trong bối cảnh ràng buộc dữ liệu, ví dụ Xamarin.

Hàm tạo của lớp - hoặc thực sự là setter của một thuộc tính khác mà nó phụ thuộc - có thể gọi một khoảng trống không đồng bộ sẽ tạo ra thuộc tính khi hoàn thành nhiệm vụ mà không cần phải chờ đợi hoặc chặn. Khi cuối cùng nó nhận được một giá trị, nó sẽ cập nhật giao diện người dùng của bạn thông qua cơ chế NotifyPropertyChanged.

Tôi không chắc chắn về bất kỳ tác dụng phụ nào của việc gọi khoảng trống aysnc từ hàm tạo. Có lẽ một bình luận viên sẽ giải thích chi tiết về xử lý lỗi, v.v.

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


}

Khi tôi gặp phải vấn đề này, việc cố gắng chạy đồng bộ phương thức async từ trình cài đặt hoặc hàm tạo đã khiến tôi gặp bế tắc trên luồng UI và sử dụng trình xử lý sự kiện đòi hỏi quá nhiều thay đổi trong thiết kế chung.
Giải pháp là, thường là, chỉ viết một cách rõ ràng những gì tôi muốn xảy ra ngầm, đó là có một luồng khác xử lý thao tác và lấy luồng chính để chờ nó kết thúc:

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

Bạn có thể lập luận rằng tôi lạm dụng khuôn khổ, nhưng nó hoạt động.

Tôi xem lại tất cả câu trả lời nhưng tất cả đều có vấn đề về hiệu suất.

ví dụ trong:

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.C Hiện.Dispatcher.InvokeAsync (async () => {Title = await getTitle ();});

sử dụng điều phối không phải là một câu trả lời tốt.

nhưng có một giải pháp đơn giản, chỉ cần làm điều đó:

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

Bạn có thể thay đổi proerty thành Task<IEnumerable>

và làm một cái gì đó như:

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

và sử dụng nó như đang chờ MyList;