Condivisione della tecnologia

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Programmazione asincrona C# Utilizzo e funzione di Invoke, BeginInvoke ed EndInvoke

1. Invocare

L'essenza di Invoke è semplicemente un metodo e il metodo deve essere chiamato tramite un oggetto.

In generale, ci sono solo due situazioni in cui Invoke viene effettivamente utilizzato:

ControlInvoke

DelegateInvoke

In altre parole, Invoke è preceduto da un oggetto controllo o delegato.

ControlInvoke

Invoke di Control viene generalmente utilizzato per risolvere problemi di accesso a thread incrociati. Ad esempio, se si desidera utilizzare un pulsante, è necessario utilizzare button.Invoke. Se si desidera utilizzare un'etichetta di testo, è necessario utilizzare label.Invoke, but tutti lo troveranno molto fastidioso, se voglio azionare sia il pulsante che l'etichetta, posso scriverli insieme? Sicuro.

Sappiamo che il form principale è un Form e Form eredita naturalmente Control, quindi Form ha anche il metodo Invoke, che può chiamare direttamente Form.Invoke Questo è il nostro this.Invoke comune. Questo è il motivo per cui alcune Invoke non hanno nulla davanti a sé. Infatti, c'è questo davanti a sé, ma è omesso.

Esempio:

this.Invoke(new Action(() =>{ button1.Text = "关闭";}));

DelegateInvoke

Invoke del delegato chiama effettivamente il metodo delegato dal pool di thread per l'esecuzione. Invoke è un metodo sincrono e bloccherà il thread dell'interfaccia utente che lo chiama.

void PrintMessage(string message) 
    { 
        Console.WriteLine(message); 
    } 
    MyDelegate myDelegate = PrintMessage; 
    myDelegate.Invoke("Hello, World!"); // 使用 Invoke 方法调用委托引用的方法`

inizioInvoke, fineInvoke

Sappiamo già che async/await, la classe BackGroudWorker e TPL (Task Parallel Library) esistono in C#. Naturalmente, C# ha ancora alcuni vecchi modelli per supportare la programmazione asincrona.

    delegate long MyDel(int first, int second);
    
    class Program
    {
        static long Sum(int x, int y)
        {
            Console.WriteLine("------Inside Sum@{0}", DateTime.Now.ToString());
            Thread.Sleep(2000);
            return x + y;
        }
    
        static void Main(string[] args)
        {
            MyDel del = new MyDel(Sum);
    
            Console.WriteLine("Before BeginInvoke---@{0}", DateTime.Now.ToString());
            IAsyncResult iar = del.BeginInvoke(3, 5, null, null);
            Console.WriteLine("After BeginInvoke@{0}", DateTime.Now.ToString());
    
            Console.WriteLine("Doing stuff@{0}", DateTime.Now.ToString());
    
            long result = del.EndInvoke(iar);
            Console.WriteLine("End Invoke@{0}", DateTime.Now.ToString());
    
            Console.WriteLine("After EndInvoke:  {0}", result);
    
            Console.ReadKey();
    
        }
    }

Il codice precedente definisce un delegato MyDel e passa il metodo Sum al suo oggetto quando viene chiamato. Normalmente quando chiamiamo questo oggetto delegato, chiamerà i metodi inclusi nel suo elenco di chiamate. Proprio come chiamare un metodo, questo viene fatto in modo sincrono.

Ma se l'oggetto delegato ha un solo metodo (metodo di riferimento) nell'elenco delle chiamate, può eseguire questo metodo in modo asincrono. A questo scopo vengono utilizzati BeginInovke e EndInvoke. Possiamo usarlo nel modo seguente:

* ① Quando chiamiamo il metodo BeginInvoke, inizia a eseguire il metodo di riferimento su un thread indipendente e ritorna immediatamente al thread originale. Il thread originale può continuare e il metodo di riferimento verrà eseguito in parallelo nel thread desiderato.
* ② Quando il programma desidera ottenere il risultato del metodo asincrono completato, può controllare la proprietà IsCompleted dell'IAsyncResult restituito da BeginInvoke o chiamare il metodo EndInvoke del delegato per attendere il completamento dell'esecuzione del delegato.

Il processo di utilizzo di cui sopra porta a tre modalità:

* ①Aspetta fino al completamento Dopo che il thread originale ha avviato il metodo asincrono ed ha eseguito altre elaborazioni, il thread originale si interrompe e attende il completamento del metodo asincrono prima di continuare.

* ②Polling, il thread originale controlla regolarmente se il thread avviato è stato completato. In caso contrario, può continuare a fare altre cose.

* ③ Il thread originale del callback viene sempre eseguito senza attendere o verificare se il thread di avvio è stato completato Una volta completata l'emissione del riferimento nel thread di avvio, il thread di avvio chiamerà il metodo di callback e il metodo di callback elaborerà il risultato. del metodo asincrono prima di chiamare EndInvoke.

Sito di riferimento:

Spiegazione dettagliata dell'applicazione pratica di Invoke e BeginInvoke in C#_C# Tutorial_Script Home

Utilizzo del delegato del thread C# BeginInvoke e EndInvoke_C# Tutorial_Script Home