Alıcıdan veya ayarlayıcıdan zaman uyumsuz yöntem nasıl çağrılır?

C # 'da bir alıcı veya ayarlayıcıdan bir zaman uyumsuz yöntem çağırmanın en zarif yolu ne olurdu?

İşte kendimi açıklamaya yardımcı olacak bazı sahte kodlar.

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

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

C # ' da özelliklere izin verilmesinin teknik bir nedeni yoktur async. Amaçlı bir tasarım kararıdır, çünkü "asenkron özellikler" bir oksimorondur.

Özellikler geçerli değerleri döndürmelidir; arka plan işlemlerini başlatmamalıdırlar.

Genellikle, birisi "eşzamansız özellik" istediğinde, gerçekten istediği şey bunlardan biridir:

1. Bir değer döndüren zaman uyumsuz bir yöntem. Bu durumda, özelliği bir asyncyönteme değiştirin.
2. Veri bağlamada kullanılabilen, ancak eşzamansız olarak hesaplanması / alınması gereken bir değer. Bu durumda, asynciçeren nesne için bir fabrika yöntemi kullanın veya bir async InitAsync()yöntem kullanın . Veriye bağlı değer default(T), değer hesaplanana / alınana kadar olacaktır .
3. Oluşturulması pahalı olan ancak gelecekte kullanılmak üzere önbelleğe alınması gereken bir değer. Bu durumda, kullanmak AsyncLazy benim blogdan veya AsyncEx kütüphanesine . Bu size awaityetenekli bir mülk verecektir .

Güncelleme: En son "zaman uyumsuz OOP" blog yayınlarımdan birinde zaman uyumsuz özellikleri ele aldım.

Eşzamansız özellik desteği olmadığından, yalnızca eşzamansız yöntemler olduğundan eşzamansız olarak çağıramazsınız. Bunun gibi, iki seçenek, CTP içinde asenkron yöntemler gerçekten sadece bir yöntem döndürür olmasından hem yararlanarak vardır Task<T>ya Task:

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

Veya:

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

Gerçekten ayrışmış mimarisi nedeniyle get yönteminden kaynaklanan çağrı gerekiyordu. Bu yüzden aşağıdaki uygulamayı buldum.

Kullanım: Başlık , bir ViewModel veya statik olarak sayfa kaynağı olarak bildirebileceğiniz bir nesnedir. Bağlayın ve getTitle () döndüğünde değer UI'yi engellemeden doldurulur.

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

Ben sadece ilk null dönen değeri beklemek ve sonra gerçek değeri almak düşünüyorum, bu yüzden Pure MVVM (örneğin PCL projesi) aşağıdaki en zarif çözüm olduğunu düşünüyorum:

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

Bunun gibi kullanabilirsiniz Task:

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

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

Ben düşündüm .GetAwaiter (). GetResult () tam olarak bu sorunun çözümü, değil mi? Örneğin:

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

" Eşzamansız mülkünüz" bir görünüm modelinde olduğundan AsyncMVVM'yi kullanabilirsiniz :

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

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

Senkronizasyon bağlamını ve özellik değişikliği bildirimini sizin yerinize halleder.

Necromancing.
.NET Core / NetStandard2'de aşağıdakiler Nito.AsyncEx.AsyncContext.Runyerine kullanabilirsiniz 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"));
    }


}

Basitçe seçerseniz System.Threading.Tasks.Task.Runveya System.Threading.Tasks.Task<int>.Runo zaman işe yaramaz.

Aşağıdaki örneğimin @ Stephen-Cleary'nin yaklaşımını izleyebileceğini düşünüyorum ama kodlanmış bir örnek vermek istedim. Bu veri bağlama bağlamında kullanım içindir, örneğin Xamarin.

Sınıfın kurucusu - ya da aslında bağımlı olduğu başka bir mülkün ayarlayıcısı - bir beklemeye veya bloğa gerek kalmadan görevi tamamladıktan sonra mülkü dolduracak bir asenkron boşluk çağırabilir. Sonunda bir değer aldığında, kullanıcı arayüzünüzü NotifyPropertyChanged mekanizması aracılığıyla güncelleyecektir.

Bir kurucudan aysnc geçersizliğini çağırmanın herhangi bir yan etkisi konusunda emin değilim. Belki de bir yorumcu hata işleme vb.

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


}

Bu sorunla karşılaştığımda, bir ayarlayıcıdan veya bir kurucudan bir eşzamansız yöntem eşzamanlılığını çalıştırmaya çalışmak beni UI iş parçacığında bir kilitlenmeye soktu ve bir olay işleyicisi kullanmak genel tasarımda çok fazla değişiklik gerektirdi.
Çözüm, sık sık, sadece açıkça başka bir iş parçacığı işlemi işlemek ve bitirmek için beklemek için ana iş parçacığı almak için dolaylı olmak istediklerini açıkça yazmak oldu:

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

Çerçeveyi kötüye kullandığımı iddia edebilirsiniz, ancak işe yarıyor.

Tüm yanıtları gözden geçiriyorum ancak hepsinde bir performans sorunu var.

örneğin:

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

iyi bir cevap olmayan dağıtıcı kullanın.

ama basit bir çözüm var, sadece yap:

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

Proerty'i şu şekilde değiştirebilirsiniz: Task<IEnumerable>

ve şöyle bir şey yapın:

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

ve MyList'i beklerken kullanın;