Inline-Funktionen in C #?

Wie macht man "Inline-Funktionen" in C #? Ich glaube nicht, dass ich das Konzept verstehe. Sind sie wie anonyme Methoden? Wie Lambda-Funktionen?

Hinweis : Die Antworten beziehen sich fast ausschließlich auf die Fähigkeit, Funktionen zu integrieren , dh "eine manuelle oder Compiler-Optimierung, die eine Funktionsaufruf-Site durch den Körper des Angerufenen ersetzt". Wenn Sie an anonymen (auch bekannt als Lambda) Funktionen interessiert sind , lesen Sie die Antwort von @ jalf oder Was ist das für ein Lambda, von dem alle reden? .

Schließlich in .NET 4.5 ermöglicht die CLR ein bis hint / vorschlagen ¹ Methode inlining Verwendung MethodImplOptions.AggressiveInliningWert. Es ist auch im Kofferraum des Mono erhältlich (heute verpflichtet).

// The full attribute usage is in mscorlib.dll,
// so should not need to include extra references
using System.Runtime.CompilerServices; 

...

[MethodImpl(MethodImplOptions.AggressiveInlining)]
void MyMethod(...)

1 . Bisher wurde hier "Kraft" angewendet. Da es einige Abstimmungen gab, werde ich versuchen, den Begriff zu klären. Wie in den Kommentaren und in der Dokumentation gibt es The method should be inlined if possible.insbesondere in Bezug auf Mono (das offen ist) einige monospezifische technische Einschränkungen in Bezug auf Inlining oder allgemeinere (wie virtuelle Funktionen). Insgesamt ja, dies ist ein Hinweis für den Compiler, aber ich denke, das wurde gefragt.

Inline-Methoden sind einfach eine Compiler-Optimierung, bei der der Code einer Funktion in den Aufrufer gerollt wird.

Es gibt keinen Mechanismus, mit dem dies in C # durchgeführt werden kann, und sie sollten sparsam in Sprachen verwendet werden, in denen sie unterstützt werden. Wenn Sie nicht wissen, warum sie irgendwo verwendet werden sollten, sollten sie es nicht sein.

Bearbeiten: Zur Verdeutlichung gibt es zwei Hauptgründe, warum sie sparsam verwendet werden müssen:

1. Es ist einfach, massive Binärdateien zu erstellen, indem Inline verwendet wird, wenn dies nicht erforderlich ist
2. Der Compiler weiß in der Regel besser als Sie, wann aus Sicht der Leistung etwas eingefügt werden sollte

Lassen Sie die Dinge am besten in Ruhe und lassen Sie den Compiler seine Arbeit erledigen. Profilieren Sie dann und finden Sie heraus, ob Inline die beste Lösung für Sie ist. Natürlich sind einige Dinge nur sinnvoll, um inline zu sein (insbesondere mathematische Operatoren), aber es ist normalerweise die beste Vorgehensweise, den Compiler damit umgehen zu lassen.

Update: Per konrad.kruczynski Antwort , folgendes gilt für Versionen von .NET bis einschließlich 4.0.

Sie können die MethodImplAttribute-Klasse verwenden , um zu verhindern , dass eine Methode inline wird ...

[MethodImpl(MethodImplOptions.NoInlining)]
void SomeMethod()
{
    // ...
}

... aber es gibt keine Möglichkeit , das Gegenteil zu tun und zwingt es inlined werden.

Sie mischen zwei verschiedene Konzepte. Function Inlining ist eine Compileroptimierung, die keinen Einfluss auf die Semantik hat. Eine Funktion verhält sich unabhängig davon, ob sie inline ist oder nicht.

Andererseits sind Lambda-Funktionen ein rein semantisches Konzept. Es gibt keine Anforderung, wie sie implementiert oder ausgeführt werden sollen, solange sie dem in der Sprachspezifikation festgelegten Verhalten folgen. Sie können eingefügt werden, wenn der JIT-Compiler Lust dazu hat oder nicht, wenn dies nicht der Fall ist.

In C # gibt es kein Inline-Schlüsselwort, da es sich um eine Optimierung handelt, die normalerweise dem Compiler überlassen werden kann, insbesondere in JIT-Sprachen. Der JIT-Compiler hat Zugriff auf Laufzeitstatistiken, mit denen er wesentlich effizienter entscheiden kann, was beim Schreiben des Codes inline sein soll. Eine Funktion wird eingefügt, wenn der Compiler dies wünscht, und Sie können in beiden Fällen nichts dagegen tun. :) :)

Meinen Sie Inline-Funktionen im C ++ - Sinne? In welcher Form wird der Inhalt einer normalen Funktion automatisch inline auf die Call-Site kopiert? Der Endeffekt ist, dass beim Aufrufen einer Funktion tatsächlich kein Funktionsaufruf erfolgt.

Beispiel:

inline int Add(int left, int right) { return left + right; }

Wenn ja, dann nein, es gibt kein C # -Äquivalent dazu.

Oder meinen Sie Funktionen, die in einer anderen Funktion deklariert sind? Wenn ja, dann unterstützt C # dies über anonyme Methoden oder Lambda-Ausdrücke.

Beispiel:

static void Example() {
  Func<int,int,int> add = (x,y) => x + y;
  var result = add(4,6);  // 10
}

Cody hat es richtig gemacht, aber ich möchte ein Beispiel dafür geben, was eine Inline-Funktion ist.

Angenommen, Sie haben diesen Code:

private void OutputItem(string x)
{
    Console.WriteLine(x);

    //maybe encapsulate additional logic to decide 
    // whether to also write the message to Trace or a log file
}

public IList<string> BuildListAndOutput(IEnumerable<string> x)
{  // let's pretend IEnumerable<T>.ToList() doesn't exist for the moment
    IList<string> result = new List<string>();

    foreach(string y in x)
    {
        result.Add(y);
        OutputItem(y);
    }
    return result;
}

Das Just-In-Time-Optimierungsprogramm des Compilers kann den Code ändern, um zu vermeiden, dass OutputItem () wiederholt auf dem Stapel aufgerufen wird, sodass es so aussieht, als hätten Sie den Code stattdessen wie folgt geschrieben:

public IList<string> BuildListAndOutput(IEnumerable<string> x)
{
    IList<string> result = new List<string>();

    foreach(string y in x)
    {
        result.Add(y);

        // full OutputItem() implementation is placed here
        Console.WriteLine(y);   
    }

    return result;
}

In diesem Fall würden wir sagen, dass die Funktion OutputItem () inline ist. Beachten Sie, dass dies auch dann möglich ist, wenn OutputItem () auch von anderen Stellen aus aufgerufen wird.

Bearbeitet, um ein Szenario anzuzeigen, das mit größerer Wahrscheinlichkeit inline ist.

Ja Genau, der einzige Unterschied ist die Tatsache, dass ein Wert zurückgegeben wird.

Vereinfachung (ohne Ausdrücke):

List<T>.ForEach Führt eine Aktion aus, erwartet kein Rückgabeergebnis.

Ein Action<T>Delegierter würde also ausreichen. Sagen Sie:

List<T>.ForEach(param => Console.WriteLine(param));

ist das gleiche wie zu sagen:

List<T>.ForEach(delegate(T param) { Console.WriteLine(param); });

Der Unterschied besteht darin, dass der Parametertyp und die Delegiertendekleration durch die Verwendung abgeleitet werden und die geschweiften Klammern bei einer einfachen Inline-Methode nicht erforderlich sind.

Wohingegen

List<T>.Where Übernimmt eine Funktion und erwartet ein Ergebnis.

Also Function<T, bool>wäre ein zu erwarten:

List<T>.Where(param => param.Value == SomeExpectedComparison);

Das ist das gleiche wie:

List<T>.Where(delegate(T param) { return param.Value == SomeExpectedComparison; });

Sie können diese Methoden auch inline deklarieren und sie den Variablen IE zuordnen:

Action myAction = () => Console.WriteLine("I'm doing something Nifty!");

myAction();

oder

Function<object, string> myFunction = theObject => theObject.ToString();

string myString = myFunction(someObject);

Ich hoffe das hilft.

Es gibt Fälle, in denen ich die Inline-Eingabe von Code erzwingen möchte.

Zum Beispiel, wenn ich eine komplexe Routine habe, in der eine große Anzahl von Entscheidungen innerhalb eines stark iterativen Blocks getroffen wird und diese Entscheidungen zu ähnlichen, aber leicht unterschiedlichen Aktionen führen, die ausgeführt werden müssen. Stellen Sie sich zum Beispiel einen komplexen (nicht DB-gesteuerten) Sortiervergleich vor, bei dem der Sortieralgorithmus die Elemente nach einer Reihe verschiedener nicht verwandter Kriterien sortiert, wie dies beispielsweise der Fall wäre, wenn Wörter nach gramatischen und semantischen Kriterien für eine schnelle Sprache sortiert würden Erkennungssystem. Ich würde dazu neigen, Hilfsfunktionen zu schreiben, um diese Aktionen auszuführen, um die Lesbarkeit und Modularität des Quellcodes aufrechtzuerhalten.

Ich weiß, dass diese Hilfsfunktionen eingebunden sein sollten, da der Code auf diese Weise geschrieben würde, wenn er niemals von einem Menschen verstanden werden müsste. Ich würde in diesem Fall sicherlich sicherstellen wollen, dass es keinen Funktionsaufruf-Overhead gibt.

Die Aussage "Es ist am besten, diese Dinge in Ruhe zu lassen und den Compiler die Arbeit machen zu lassen." (Cody Brocious) ist völliger Quatsch. Ich programmiere seit 20 Jahren Hochleistungsspielcode und habe noch keinen Compiler gefunden, der "klug genug" ist, um zu wissen, welcher Code eingebunden werden soll (Funktionen) oder nicht. Es wäre nützlich, eine "Inline" -Anweisung in c # zu haben. Die Wahrheit ist, dass der Compiler nicht über alle Informationen verfügt, die er benötigt, um zu bestimmen, welche Funktion ohne den "Inline" -Hinweis immer inline oder nicht eingefügt werden soll. Sicher, wenn die Funktion klein ist (Accessor), wird sie möglicherweise automatisch eingefügt, aber was ist, wenn es sich um ein paar Codezeilen handelt? Unsinnig, der Compiler hat keine Möglichkeit zu wissen, Sie können dies nicht einfach dem Compiler überlassen, um optimierten Code (über Algorithmen hinaus) zu erhalten.

Ich weiß, dass es bei dieser Frage um C # geht. Sie können jedoch Inline-Funktionen in .NET mit F # schreiben. siehe: Verwendung von `inline` in F #

Nein, es gibt kein solches Konstrukt in C #, aber der .NET JIT-Compiler könnte entscheiden, Inline-Funktionsaufrufe zur JIT-Zeit durchzuführen. Aber ich weiß eigentlich nicht, ob es wirklich solche Optimierungen macht.
(Ich denke es sollte :-))

Für den Fall, dass Ihre Assemblys erstellt werden, sollten Sie sich TargetedPatchingOptOut ansehen. Dies hilft ngen bei der Entscheidung, ob Inline-Methoden verwendet werden sollen. MSDN-Referenz

Es ist jedoch immer noch nur ein deklarativer Hinweis zur Optimierung, kein zwingender Befehl.

Lambda-Ausdrücke sind Inline-Funktionen! Ich denke, dass C # kein zusätzliches Attribut wie Inline oder ähnliches hat!

C # unterstützt keine Inline-Methoden (oder -Funktionen) wie dynamische Sprachen wie Python. Anonyme Methoden und Lambdas können jedoch für ähnliche Zwecke verwendet werden, z. B. wenn Sie wie im folgenden Beispiel auf eine Variable in der enthaltenen Methode zugreifen müssen.

static void Main(string[] args)
{
    int a = 1;

    Action inline = () => a++;
    inline();
    //here a = 2
}