Azione per delegare: nuova azione o azione di lancio?

Question

Ho trovato due modi diversi per inizializzare un delegato con un'azione:

Creare una nuova azione o lanciare su Azione.

Delegate foo = new Action(() => DoNothing(param)); 
Delegate bar = (Action)(() => DoNothing(param)); 

C'è una differenza tra queste 2 sintassi?

Quale è migliore e perché?

Edit:
delegato è l'uso in questo esempio perché la sintassi è utile per richiamare metodi come BeginInvoke o invocare con un'espressione lambda, ed è importante per lanciare l'espressione lambda in un'azione

static main 
{ 
    Invoke((Action)(() => DoNothing())); // OK 
    Invoke(new Action(() => DoNothing())); // OK 
    Invoke(() => DoNothing()); // Doesn't compil 
} 

private static void Invoke(Delegate del) { } 

Ma è interessante vedere che il compilatore ha autorizzato questo:

Action action =() => DoNothing(); 
Invoke(action); 

Answer 1

Non c'è differenza tra queste due istruzioni. In entrambe le istruzioni viene creata una nuova istanza di Action.

Il codice IL sottostante sembra confermarlo.

Programma Console:

class Program 
{ 
    static void Main(string[] args) 
    { 
     Delegate barInit = (Action)(() => DoNothing()); 
     Delegate fooInit = new Action(() => DoNothing()); 
    } 

    private static void DoNothing() { } 
} 

IL Codice:

// First instruction 
IL_0000: ldsfld class [mscorlib]System.Action CodeMachineTest.Program::'CS$<>9__CachedAnonymousMethodDelegate2' 
IL_0005: brtrue.s IL_0018 

IL_0007: ldnull 
IL_0008: ldftn void CodeMachineTest.Program::'<Main>b__0'() 

// Create a new Action instance for the instruction (Action)(() => DoNothing()) 
IL_000e: newobj instance void [mscorlib]System.Action::.ctor(object, native int) 

IL_0013: stsfld class [mscorlib]System.Action CodeMachineTest.Program::'CS$<>9__CachedAnonymousMethodDelegate2' 

IL_0018: ldsfld class [mscorlib]System.Action CodeMachineTest.Program::'CS$<>9__CachedAnonymousMethodDelegate2' 
IL_001d: pop 

// Second instruction 
IL_001e: ldsfld class [mscorlib]System.Action CodeMachineTest.Program::'CS$<>9__CachedAnonymousMethodDelegate3' 
IL_0023: brtrue.s IL_0036 

IL_0025: ldnull 
IL_0026: ldftn void CodeMachineTest.Program::'<Main>b__1'() 
IL_002c: newobj instance void [mscorlib]System.Action::.ctor(object, native int) 
IL_0031: stsfld class [mscorlib]System.Action CodeMachineTest.Program::'CS$<>9__CachedAnonymousMethodDelegate3' 

IL_0036: ldsfld class [mscorlib]System.Action CodeMachineTest.Program::'CS$<>9__CachedAnonymousMethodDelegate3' 
IL_003b: pop 
IL_003c: ret 

Answer 2

Secondo me non c'è differenza.

new Action(() => DoNothing(param)); 

Questo solo crea una nuova azione e passa lungo un'espressione lambda, che il compilatore affrontare e fare in modo che tutto è cablato bene.

(Action)(() => DoNothing(param)); 

Ciò funziona perché un metodo lambda come questo non restituisce alcun valore e non accetta parametri, come ad esempio il compilatore può verificare che sia "mappable" per un'azione sulla base del fatto che esso passa attraverso il sistema delegato.

Sono più o meno uno e lo stesso, a seconda di qualsiasi tipo di ottimizzatore del compilatore è difficile dire quale sia più performante, forse dovresti testare le prestazioni e vedere tu stesso?

E 'una domanda interessante e un'esplorazione nel sistema di deleghe e di come LINQ e le espressioni in forma in

new Func<string>(() => "Boo!"); 

è più o meno equivalente a:.

(Func<String>)() => "Boo!"; 

Per quanto mi Mi rendo conto che entrambi finiscono col passare attraverso il sistema delegato a pensare a Invoke() ecc. Sarebbe interessante se tu testassi la performance e avessi condiviso i risultati.

Answer 3

Non c'è differenza, sono solo due sintassi per lo stesso. Personalmente, io uso l'ultimo, perché è più breve.

Ma perché è necessaria una variabile di tipo Delegate? Nella maggior parte dei casi si desidera che la variabile abbia lo stesso tipo come esempio, e quindi è possibile utilizzare

var bar = (Action)(() => DoNothing(param)); 

o

Action bar =() => DoNothing(param); 

invece di

Delegate bar = (Action)(() => DoNothing(param)); // (from your question)