Aktion zum Delegieren: neue Aktion oder Casting-Aktion?

Question

Ich habe zwei verschiedene Möglichkeiten gefunden, einen Delegaten mit einer Aktion zu initialisieren:

Eine neue Aktion erstellen oder eine Aktion ausführen.

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

Gibt es einen Unterschied zwischen diesen 2 Syntaxen?

Welcher ist besser und warum?

Edit:
Delegieren ist in diesem Beispiel verwenden, da die Syntax ist nützlich Methoden wie BeginInvoke aufrufen oder mit einem Lambda-Ausdruck Invoke, und es ist wichtig, den Lambda-Ausdruck in eine Aktion

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

private static void Invoke(Delegate del) { } 

zu werfen

Aber es ist interessant zu sehen, dass der Compiler diese autorisiert:

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

Answer 1

Es gibt keinen Unterschied zwischen diesen beiden Anweisungen. In beiden Anweisungen wird eine neue Instanz von Action erstellt.

Der folgende IL-Code scheint dies zu bestätigen.

Console Programm:

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

    private static void DoNothing() { } 
} 

IL-Code:

// 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

meiner Meinung nach kein Unterschied besteht.

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

Das schafft nur eine neue Aktion und führt entlang einem Lambda-Ausdruck, die die Compiler mit befassen und dafür sorgen, dass alles gut verdrahtet ist. Diese

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

funktioniert, weil ein Lambda-Verfahren wie diesem keinen Wert zurückgibt und keine Parameter, die als solche der Compiler verifizieren kann, dass es „mappable“ auf eine Aktion der Begründung, dass es den Delegierten System geht.

Sie sind mehr oder weniger ein und dasselbe, abhängig von jeder Art von Compiler-Optimierungen ist es schwer zu sagen, welche performanter ist, vielleicht sollten Sie die Leistung testen und selbst sehen?

Es ist eine interessante Frage und eine Entdeckungsreise in die Delegation System und wie Linq und Ausdrücke passen in

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

mehr oder weniger entspricht.

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

Soweit ich Ich bin mir bewusst, dass beide am Ende durch das Delegiertensystem gehen, denke Invoke() usw., es wäre interessant, wenn Sie die Leistung testen und Ihre Ergebnisse teilen würden.

Answer 3

Es gibt keinen Unterschied, sie sind nur zwei Syntaxen für das gleiche. Persönlich benutze ich das letzte, weil es kürzer ist.

Aber warum brauchen Sie eine Variable vom Typ Delegate? In den meisten Fällen wollen Sie die Variable den gleichen Typ wie die Instanz haben, und dann können Sie

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

oder

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

statt

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