Qual è la differenza tra InvokeAsync e BeginInvoke per WPF Dispatcher

Question

Ho notato in .NET 4.5 che lo WPF Dispatcher aveva ottenuto un nuovo set di metodi per eseguire le cose sul thread del Dispatcher chiamato InvokeAsync. Prima, .NET 4.5 avevamo Invoke e BeginInvoke che gestivano questo in maniera sincrona e asincrona rispettivamente.

Oltre alla denominazione e ai sovraccarichi leggermente diversi disponibili, esistono differenze significative tra i metodi BeginInvoke e InvokeAsync?

Oh, e ho già controllato, entrambi possono essere await ndr:

private async Task RunStuffOnUiThread(Action action) 
{ 
    // both of these works fine 
    await dispatcher.BeginInvoke(action); 
    await dispatcher.InvokeAsync(action); 
} 

Answer 1

Non ci sono differenze come metodo BeginInvoke chiama un LegacyBeginInvokeImpl metodo privato che itslef chiama il metodo privato InvokeAsyncImpl (il metodo usato da InvokeAsync). Quindi è praticamente la stessa cosa. Sembra che sia un semplice refactoring, tuttavia è strano che i metodi BeginInvoke non siano stati contrassegnati come obsoleti.

BeginInvoke:

public DispatcherOperation BeginInvoke(DispatcherPriority priority, Delegate method) 
{ 
    return this.LegacyBeginInvokeImpl(priority, method, null, 0); 
} 

private DispatcherOperation LegacyBeginInvokeImpl(DispatcherPriority priority, Delegate method, object args, int numArgs) 
{ 
    Dispatcher.ValidatePriority(priority, "priority"); 
    if (method == null) 
    { 
     throw new ArgumentNullException("method"); 
    } 
    DispatcherOperation dispatcherOperation = new DispatcherOperation(this, method, priority, args, numArgs); 
    this.InvokeAsyncImpl(dispatcherOperation, CancellationToken.None); 
    return dispatcherOperation; 
} 

InvokeAsync:

public DispatcherOperation InvokeAsync(Action callback, DispatcherPriority priority) 
{ 
    return this.InvokeAsync(callback, priority, CancellationToken.None); 
} 

public DispatcherOperation InvokeAsync(Action callback, DispatcherPriority priority, CancellationToken cancellationToken) 
{ 
    if (callback == null) 
    { 
     throw new ArgumentNullException("callback"); 
    } 
    Dispatcher.ValidatePriority(priority, "priority"); 
    DispatcherOperation dispatcherOperation = new DispatcherOperation(this, priority, callback); 
    this.InvokeAsyncImpl(dispatcherOperation, cancellationToken); 
    return dispatcherOperation; 
} 

Answer 2

[Edit - entrambi sono nello stesso]

Thereotically

opere BeginInvoke sul thread su cui è stato creato il dispatcher e InvokeAsync funziona con il thread su cui è associato il dispatcher.

Significa che se è necessario elaborare qualcosa basandosi sul thread corrente del dispatcher, si utilizzerà InvokeAsync altrimenti utilizzare BeginInvoke.

MODIFICA: - ma il commento sopra non ha senso poiché non è possibile modificare il thread associato del dispatcher una volta creato.

D'accordo con sopra risposta menzione .. grazie

Answer 3

C'è una differenza nel metodo di firma:

BeginInvoke(Delegate, Object[]) 
InvokeAsync(Action) 

Per BeginInvoke() compilatore crea serie Object[] implicitamente mentre per InvokeAsync() non è necessario tale varietà:

IL_0001: ldarg.0 
IL_0002: call  instance class [WindowsBase]System.Windows.Threading.Dispatcher [WindowsBase]System.Windows.Threading.DispatcherObject::get_Dispatcher() 
IL_0007: ldarg.1 
IL_0008: ldc.i4.0 
IL_0009: newarr  [mscorlib]System.Object 
IL_000e: callvirt instance class [WindowsBase]System.Windows.Threading.DispatcherOperation [WindowsBase]System.Windows.Threading.Dispatcher::BeginInvoke(class [mscorlib]System.Delegate, object[]) 


IL_0014: ldarg.0 
IL_0015: call  instance class [WindowsBase]System.Windows.Threading.Dispatcher [WindowsBase]System.Windows.Threading.DispatcherObject::get_Dispatcher() 
IL_001a: ldarg.1 
IL_001b: callvirt instance class [WindowsBase]System.Windows.Threading.DispatcherOperation [WindowsBase]System.Windows.Threading.Dispatcher::InvokeAsync(class [mscorlib]System.Action)