วิธีการเรียกใช้วิธีการ async จาก getter หรือ setter

อะไรจะเป็นวิธีที่สวยงามที่สุดในการโทรหาวิธีการ async จาก getter หรือ setter ใน 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;
    }
}

ฉันต้องการการโทรเพื่อเริ่มต้นด้วยวิธีการรับเนื่องจากสถาปัตยกรรมที่แยกออกมาของฉัน ดังนั้นฉันจึงเกิดการดำเนินการดังต่อไปนี้

การใช้งาน: ชื่อเรื่องอยู่ใน ViewModel หรือวัตถุที่คุณสามารถประกาศแบบคงที่เป็นทรัพยากรของหน้าเว็บ ผูกเข้ากับมันและค่าจะได้รับการเติมโดยไม่มีการปิดกั้น UI เมื่อ 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");
        }
    }
}

เนื่องจาก "คุณสมบัติ async" ของคุณอยู่ใน viewmodel คุณสามารถใช้AsyncMVVM :

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

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

มันจะดูแลบริบทการประสานและการแจ้งเตือนการเปลี่ยนแปลงคุณสมบัติสำหรับคุณ

Necromancing
ใน. 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

คอนสตรัคเตอร์ของคลาส - หรือตัวตั้งค่าของคุณสมบัติอื่นที่ขึ้นอยู่กับมัน - อาจเรียกว่าโมฆะ async ที่จะเติมคุณสมบัติเมื่อเสร็จสิ้นงานโดยไม่ต้องรอหรือบล็อก เมื่อได้รับค่าในที่สุดก็จะอัปเดต UI ของคุณผ่านกลไก NotifyPropertyChanged

ฉันไม่แน่ใจเกี่ยวกับผลข้างเคียงของการเรียก 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 () => {Title = รอ 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;