Bagaimana untuk Menunggu Peristiwa Asynchronous dengan Selamat dalam C#?

Mengendalikan peristiwa tak segerak dalam C#: Menunggu operasi tak segerak dengan selamat

Gambaran keseluruhan masalah:

Dalam C#, acara biasanya perwakilan tanpa nilai pulangan yang digunakan untuk memberitahu pelanggan tentang acara tertentu dalam aplikasi. Walau bagaimanapun, apabila cuba menggunakan pengendali acara tak segerak, masalah boleh timbul: acara itu dipecat, tetapi aplikasi ditutup sebelum pengendali tak segerak menyelesaikan pelaksanaan.

Langgan acara menggunakan pengendali tak segerak:

Untuk mengendalikan acara secara tidak segerak, tidak disyorkan untuk mengubah suai tandatangan acara itu sendiri untuk mengembalikan Tugas. Sebaliknya, anda boleh menggunakan kaedah pendaftaran yang menerima fungsi panggil balik yang boleh ditunggu. Ini memberikan fleksibiliti yang lebih besar dan penyepaduan yang lebih mudah dengan komponen pihak ketiga.

Pelaksanaan menggunakan kaedah pendaftaran:

<code class="language-csharp">private List<Func<Task>> ShutdownCallbacks = new List<Func<Task>>();

public void RegisterShutdownCallback(Func<Task> callback)
{
    this.ShutdownCallbacks.Add(callback);
}

public async Task Shutdown()
{
    var callbackTasks = new List<Task>();
    foreach (var callback in this.ShutdownCallbacks)
    {
        callbackTasks.Add(callback());
    }

    await Task.WhenAll(callbackTasks);
}</code>

Dalam contoh ini, senarai ShutdownCallbacks menyimpan fungsi panggil balik yang boleh ditunggu. Kaedah Shutdown() berulang melalui fungsi panggil balik ini dan menunggunya serentak. Ini memastikan semua pengendali tak segerak telah selesai sebelum proses penutupan diteruskan.

Panggil acara menggunakan senarai panggilan:

Sebagai alternatif, jika anda ingin mengekalkan paradigma acara sedia ada, anda boleh menggunakan kaedah GetInvocationList() untuk memanggil pengendali secara berurutan dan menunggu Tugasan yang dikembalikan.

<code class="language-csharp">class A
{
    public event Func<object, EventArgs, Task> Shutdown;

    public async Task OnShutdown()
    {
        Func<object, EventArgs, Task> handler = Shutdown;

        if (handler == null)
        {
            return;
        }

        Delegate[] invocationList = handler.GetInvocationList();
        Task[] handlerTasks = new Task[invocationList.Length];

        for (int i = 0; i < invocationList.Length; i++)
        {
            handlerTasks[i] = ((Func<object, EventArgs, Task>)invocationList[i])(this, EventArgs.Empty);
        }

        await Task.WhenAll(handlerTasks);
    }
}</code>

Di sini, OnShutdown() mendapatkan perwakilan acara, memanggil pengendali dan menunggu penyelesaiannya.

Kesimpulan:

Walaupun pengendali acara tak segerak mungkin kelihatan menggoda, pendekatan ini secara amnya tidak disyorkan kerana berpotensi menemui jalan buntu dan masalah lain. Seperti yang dinyatakan di atas, menggunakan kaedah berdaftar atau senarai panggilan menyediakan penyelesaian yang lebih mantap dan lebih mudah untuk diuruskan untuk acara yang menunggu secara tidak segerak dalam C#.

Atas ialah kandungan terperinci Bagaimana untuk Menunggu Peristiwa Asynchronous dengan Selamat dalam C#?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!