Lokale Funktion gegen Lambda C # 7.0

Ich schaue mir die neuen Implementierungen in C # 7.0 an und finde es interessant, dass sie lokale Funktionen implementiert haben, aber ich kann mir kein Szenario vorstellen, in dem eine lokale Funktion einem Lambda-Ausdruck vorgezogen würde und was der Unterschied zwischen beiden ist.

Ich verstehe, dass Lambdas anonymousFunktionen sind, während lokale Funktionen dies nicht sind, aber ich kann mir kein reales Szenario vorstellen, in dem lokale Funktionen Vorteile gegenüber Lambda-Ausdrücken haben

Jedes Beispiel wäre sehr dankbar. Vielen Dank.

Dies wurde von Mads Torgersen in C # Design Meeting Notes erklärt, in denen lokale Funktionen zuerst besprochen wurden :

Sie möchten eine Hilfsfunktion. Sie verwenden es nur innerhalb einer einzelnen Funktion, und es werden wahrscheinlich Variablen und Typparameter verwendet, die in der enthaltenen Funktion enthalten sind. Im Gegensatz zu einem Lambda benötigen Sie es jedoch nicht als erstklassiges Objekt, sodass Sie ihm keinen Delegatentyp zuweisen und kein tatsächliches Delegatenobjekt zuweisen möchten. Möglicherweise möchten Sie auch, dass es rekursiv oder generisch ist oder als Iterator implementiert wird.

Um es noch weiter zu erweitern, sind die Vorteile:

1. Performance.

   Beim Erstellen eines Lambda muss ein Delegat erstellt werden, was in diesem Fall eine unnötige Zuordnung darstellt. Lokale Funktionen sind eigentlich nur Funktionen, es sind keine Delegierten erforderlich.

   Außerdem sind lokale Funktionen beim Erfassen lokaler Variablen effizienter: Lambdas erfassen normalerweise Variablen in einer Klasse, während lokale Funktionen eine Struktur (übergeben mit ref) verwenden können, wodurch wiederum eine Zuordnung vermieden wird.

   Dies bedeutet auch, dass das Aufrufen lokaler Funktionen billiger ist und eingebunden werden kann, wodurch die Leistung möglicherweise noch weiter gesteigert wird.

2. Lokale Funktionen können rekursiv sein.

   Lambdas können auch rekursiv sein, erfordern jedoch umständlichen Code, bei dem Sie zuerst nulleiner Delegatenvariablen und dann dem Lambda zuweisen . Lokale Funktionen können natürlich rekursiv sein (einschließlich gegenseitig rekursiv).

3. Lokale Funktionen können generisch sein.

   Lambdas können nicht generisch sein, da sie einer Variablen mit einem konkreten Typ zugewiesen werden müssen (dieser Typ kann generische Variablen aus dem äußeren Bereich verwenden, aber das ist nicht dasselbe).

4. Lokale Funktionen können als Iterator implementiert werden.

   Lambdas kann das Schlüsselwort yield return(und yield break) nicht verwenden , um die IEnumerable<T>Rückgabefunktion zu implementieren . Lokale Funktionen können.

5. Lokale Funktionen sehen besser aus.

   Dies wird im obigen Zitat nicht erwähnt und ist möglicherweise nur meine persönliche Neigung, aber ich denke, dass die normale Funktionssyntax besser aussieht, als einer Delegatenvariablen ein Lambda zuzuweisen. Lokale Funktionen sind auch prägnanter.

   Vergleichen Sie:

   int add(int x, int y) => x + y;
   Func<int, int, int> add = (x, y) => x + y;

Neben der großartigen Antwort von svick bieten lokale Funktionen noch einen weiteren Vorteil:
Sie können überall in der Funktion definiert werden, auch nach der returnAnweisung.

public double DoMath(double a, double b)
{
    var resultA = f(a);
    var resultB = f(b);
    return resultA + resultB;

    double f(double x) => 5 * x + 3;
}

Wenn Sie sich auch fragen, wie Sie die lokale Funktion testen können, sollten Sie JustMock überprüfen, da es über die entsprechenden Funktionen verfügt. Hier ist ein einfaches Klassenbeispiel, das getestet wird:

public class Foo // the class under test
{ 
    public int GetResult() 
    { 
        return 100 + GetLocal(); 
        int GetLocal () 
        { 
            return 42; 
        } 
    } 
}

Und so sieht der Test aus:

[TestClass] 
public class MockLocalFunctions 
{ 
    [TestMethod] 
    public void BasicUsage() 
    { 
        //Arrange 
        var foo = Mock.Create<Foo>(Behavior.CallOriginal); 
        Mock.Local.Function.Arrange<int>(foo, "GetResult", "GetLocal").DoNothing(); 

        //Act 
        var result = foo. GetResult(); 

        //Assert 
        Assert.AreEqual(100, result); 
    } 
} 

Hier ist ein Link zur JustMock- Dokumentation .

Haftungsausschluss. Ich bin einer der Entwickler, die für JustMock verantwortlich sind .

Ich verwende Inline-Funktionen, um den Druck der Speicherbereinigung zu vermeiden, insbesondere wenn es um länger laufende Methoden geht. Angenommen, man möchte 2 Jahre oder Marktdaten für ein bestimmtes Tickersymbol erhalten. Außerdem kann man bei Bedarf eine Menge Funktionalität und Geschäftslogik packen.

Sie öffnen eine Socket-Verbindung zum Server und durchlaufen die Daten, die ein Ereignis an ein Ereignis binden. Man kann es sich genauso vorstellen, wie eine Klasse entworfen wurde, nur schreibt man nicht überall Hilfsmethoden, die wirklich nur für ein Stück Funktionalität funktionieren. Im Folgenden finden Sie ein Beispiel dafür, wie dies aussehen könnte. Bitte beachten Sie, dass ich Variablen verwende und die "Helfer" -Methoden unter dem Endlich stehen. Im Schließlich entferne ich die Ereignishandler, wenn meine Exchange-Klasse extern / injiziert wäre, hätte ich keinen ausstehenden Ereignishandler registriert

void List<HistoricalData> RequestData(Ticker ticker, TimeSpan timeout)
{
    var socket= new Exchange(ticker);
    bool done=false;
    socket.OnData += _onData;
    socket.OnDone += _onDone;
    var request= NextRequestNr();
    var result = new List<HistoricalData>();
    var start= DateTime.Now;
    socket.RequestHistoricalData(requestId:request:days:1);
    try
    {
      while(!done)
      {   //stop when take to long….
        if((DateTime.Now-start)>timeout)
           break;
      }
      return result;

    }finally
    {
        socket.OnData-=_onData;
        socket.OnDone-= _onDone;
    }


   void _OnData(object sender, HistoricalData data)
   {
       _result.Add(data);
   }
   void _onDone(object sender, EndEventArgs args)
   {
      if(args.ReqId==request )
         done=true;
   } 
}

Sie können die Vorteile wie unten erwähnt sehen, hier sehen Sie eine Beispielimplementierung. Hoffe, das hilft, die Vorteile zu erklären.