Gibt es einen Overhead bei der Verwendung von anonymen Methoden?

Question

Ich würde gerne wissen, ob beim Erstellen eines Background-Arbeiter durch die Verwendung anonymer Methoden ein Overhead entsteht.

zum Beispiel:

public void SomeMethod()
{
    BackgroundWorker worker = new BackgroundWorker();
    worker.DoWork += (sender, e) =>
    {
        //große Menge an Code
    }

    worker.RunWorkerAsync();
}

Wäre das obige Beispiel besser oder schlechter als das Definieren des //großen Menge an Code in einer separaten Methode?

Entsteht ein Overhead, wenn die Hintergrundarbeitermethode inline definiert wird, insbesondere wenn SomeMethod() oft aufgerufen wird?

Answer 1

Das hat der Decompiler gesagt:

[CompilerGenerated]
private static DoWorkEventHandler CS$<>9__CachedAnonymousMethodDelegate1;

[CompilerGenerated]
private static void b__0(object sender, DoWorkEventArgs e)
{
    throw new NotImplementedException();
}

public void SomeMethod1()
{
    BackgroundWorker worker = new BackgroundWorker();
    BackgroundWorker backgroundWorker = worker;
    backgroundWorker.DoWork += (object sender, DoWorkEventArgs e) => throw new NotImplementedException();
    worker.RunWorkerAsync();
}

public void SomeMethod2()
{
    BackgroundWorker worker = new BackgroundWorker();
    worker.DoWork += worker_DoWork;
    worker.RunWorkerAsync();
}

private void worker_DoWork(object sender, DoWorkEventArgs e)
{
    throw new NotImplementedException();
} 

Bearbeitung:

Beim Betrachten des IL-Codes gibt es nur einen kleinen Overhead beim Erstellen/Zuweisen einer Methode an einen Delegaten zum ersten Mal.

Answer 2

Es gibt keinen Overhead. Anonyme Methode ist effizienter, weil sie immer in eine statische Methode aufgelöst wird, aber das ist nur in sehr seltenen Szenarien relevant.

Siehe Delegaten versus Leistungsmerkmale anonymer Methoden und Leistung bei Verwendung von statischen Methoden vs. Instanziierung der Klasse, die die Methoden enthält.

Answer 3

Meine Sorge war immer - Delegates in einer Schleife zu verwenden. Es stellt sich heraus, dass der Compiler schlau genug ist, um anonyme Funktionen auch dann zu zwischenspeichern, wenn sie in einer Schleife verwendet werden.

Hier ist mein Code (10 Millionen Durchläufe):

var dummyVar = 0;
var sw = new Stopwatch();

//Delegat innerhalb der Schleife
sw.Start();
for(int i=0; i<10000000; i++)
{
    Func ax = delegate (int x) { return x++; };
    dummyVar = ax(i);
}
sw.Stop();
var ms = sw.ElapsedMilliseconds;

//Delegat außerhalb der Schleife
Func ax2 = delegate (int x) { return x++; };
sw.Restart();
for (int i = 0; i < 10000000; i++)
{
    dummyVar = ax2(i);
}
sw.Stop();
var ms2 = sw.ElapsedMilliseconds;

Ergebnisse:

1.: 151 Millisekunden

2.: 148 Millisekunden

2. Durchlauf

1.: 149 Millisekunden

2.: 175 Millisekunden (dieses Mal LANGSAMER... wer hätte das gedacht)