La fonction locale vs Lambda C# 7.0

Je suis en train de regarder les nouvelles mises en oeuvre dans C# 7.0 et je trouve intéressant qu'ils ont mis en œuvre des fonctions locales, mais je ne peux pas imaginer un scénario où une fonction locale serait préférée à une expression lambda, et quelle est la différence entre les deux.

Je ne comprends que les lambdas sont anonymous fonctions en attendant les fonctions locales ne sont pas, mais je ne peux pas comprendre un scénario réel, où la fonction locale a des avantages sur les expressions lambda

Un exemple serait très apprécié. Merci.

  • Les génériques, des paramètres, des fonctions récursives, sans avoir à initialiser le lambda null, etc.
  • Vous devriez poster cela comme une réponse.
InformationsquelleAutor Sid | 2016-12-03
  1. 255

    Ceci s'explique par Mads Torgersen en C# Design Notes de Réunion où les fonctions ont d'abord été discuté:

    Vous voulez une fonction d'assistance. Vous utilisez uniquement de l'intérieur d'une seule fonction, et il est probable utilise des variables et des paramètres de type qui sont dans la portée de cette fonction contenante. D'autre part, contrairement à un lambda vous n'en avez pas besoin, comme une première classe de l'objet, de sorte que vous n'avez pas soin de lui donner un type délégué et d'allouer un délégué de l'objet. Aussi, vous voudrez peut-être lui être récursive ou générique, ou de l'appliquer comme un itérateur.

    À développer un peu plus, les avantages sont:

    1. Performance.

      Lors de la création d'un lambda, un délégué doit être créé, ce qui est inutile, de l'allocation dans ce cas. Les fonctions locales sont vraiment juste des fonctions, pas de délégués sont nécessaires.

      Aussi, les fonctions locales sont plus efficaces pour la capture de variables locales: les lambdas généralement la capture de variables dans une classe, tandis que les fonctions peuvent utiliser un struct (passé à l'aide de ref), ce qui évite une allocation.

      Cela signifie également d'appeler des fonctions locales est moins cher et ils peuvent être inline, ce qui pourrait accroître encore plus les performances.

    2. Local, les fonctions peuvent être récursives.

      Lambdas peuvent être récursifs trop, mais il nécessite maladroit code, si vous commencez par attribuer null à un délégué de la variable, puis le lambda. Les fonctions locales peuvent naturellement être récursive (y compris mutuellement récursives).

    3. Fonctions locales peuvent être génériques.

      Lambdas ne peut pas être générique, car ils doivent être assignée à une variable avec un type de béton (ce type peuvent utiliser générique variables à partir de l'extérieur de la portée, mais ce n'est pas la même chose).

    4. Fonctions locales peuvent être mises en œuvre comme un itérateur.

      Lambdas ne peut pas utiliser le yield return (et yield break) mot-clé pour mettre en œuvre IEnumerable<T>-retour de fonction. Les fonctions locales peut.

    5. Fonctions locales regarder mieux.

      Ce n'est pas mentionné dans la citation ci-dessus et peut-être juste ma préférence personnelle, mais je pense que la normale de la syntaxe de la fonction, c'est mieux que l'affectation d'un lambda à un délégué de la variable. Les fonctions locales sont également plus succincte.

      Comparer:

      int add(int x, int y) => x + y;
Func<int, int, int> add = (x, y) => x + y;
    • Je voudrais ajouter que les fonctions locales ont des noms de paramètres sur le côté de l'appelant. Les Lambdas ne le font pas.
    • Il est vrai que les noms des paramètres de lambdas ne sont pas conservés, mais c'est parce qu'ils doivent être convertis pour les délégués, qui ont leurs propres noms. Par exemple: Func<int, int, int> f = (x, y) => x + y; f(arg1:1, arg2:1);.
    • Grande liste! Cependant, je ne peux imaginer comment IL/compilateur JIT peut effectuer toutes les optimisations mentionné au point 1. aussi aux participants si leur utilisation obéit à certaines règles.
    • Si vous pensez que l'optimisation doit être fait vaut la peine d'ajouter, vous pouvez créer une question à ce sujet sur le Roslyn ou CoreCLR repo.
    • "En outre, les fonctions locales sont plus efficaces pour la capture de variables locales: les lambdas généralement la capture de variables dans une classe, tandis que les fonctions peuvent utiliser un struct (passé à l'aide de ref), ce qui évite une allocation" - pourquoi ne peut-lambdas utiliser une structure?
    • Parce que les lambdas toujours utiliser un délégué et délégué titulaire de la fermeture comme une object. Ainsi, elles pourraient utiliser une structure, mais il devrait être mis en boîte, donc vous devez toujours avoir une allocation supplémentaire.
    • J'ai toujours aime quand C# réutilise la syntaxe pour faire quelque chose de similaire pour garder les choses inutilement compliqué, comme la façon dont ils ont fait le tuple de la syntaxe exactement les mêmes que les paramètres formels d'essayer et de miroir.
    • Super réponse! Une question: quand vous faites le contraire, choisissez lambda au lieu de fonctions locales?
    • Surtout quand vous n'avez pas besoin de donner un nom à elle, comme lorsque vous êtes à la passer à la méthode.
    • il y a aucune frappe potentiel de performance (peut-être l'incapacité à optimiser) pour en faire un local de la fonction d'assistance de plus d'un régulier de la méthode d'assistance?
    • Non, si la fonction local et la méthode sont les mêmes, il devrait y avoir pas de différences de performances entre eux. Cependant, si les locaux de la fonction de capture des variables au lieu de les accepter en tant que paramètres, il pourrait y avoir de minuscules différences.

    InformationsquelleAutor svick
  2. 76

    En plus de svick de la grande réponse il y a un avantage de plus pour les fonctions locales:

    Ils peuvent être définis de n'importe où dans la fonction, même après la return déclaration. 

    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;
}
    • C'est vraiment utile, que je peux obtenir utilisé pour mettre toutes les fonctions d'assistance dans un #region Helpers à la fin de la fonction, afin d'éviter l'encombrement à l'intérieur de cette fonction et surtout éviter l'encombrement dans la classe principale.
    • J'apprécie également cette. Il fait la principale fonction de ce que vous êtes en train de regarder plus facile à lire, que vous n'avez pas besoin de regarder autour de trouver où il commence. Si vous voulez voir les détails de mise en œuvre, continuez à chercher au delà de la fin.
    InformationsquelleAutor Tim Pohlmann
  3. 6

    Si vous aussi vous vous demandez comment tester la fonction locale, vous devriez vérifier JustMock qu'il dispose de la fonctionnalité de le faire. Voici un simple exemple de classe qui seront testées:

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

    Et voici comment le test recherche:

    [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); 
    } 
}

    Voici un lien vers JustMock la documentation.

    Avertissement. Je suis l'un des développeurs responsables de JustMock.

    • c'est génial de voir des développeurs passionnés qui préconise pour les personnes à utiliser leur outil. Comment vous êtes-vous intéressé par l'écriture d'outils de développeur comme un emploi à temps plein? Comme un Américain, mon impression est qu'il peut être difficile de trouver ces carrières, sauf si vous avez un master ou Ph. D. dans la comp de la sci.
    • Bonjour Jean et merci pour les paroles aimables. En tant que développeur logiciel, je ne vois rien de mieux que d'être apprécié par mes clients pour la valeur je fournir pour eux. Combinez cela avec le désir de difficile et concurrentiel de travail et vous recevrez un nombre assez restreint la liste des choses que je serais passionnés sur. L'écriture de la productivité des outils développeur est sur la liste. Au moins dans mon esprit 🙂 Concernant la carrière, je pense que les entreprises fournissant des outils de développement sont tout à fait un petit pourcentage de l'ensemble des sociétés de logiciels et c'est pourquoi il est plus difficile de trouver une telle opportunité.
    • Une question distincte. Pourquoi n'appelez-vous pas VerifyAll ici? Est-il un moyen de dire JustMock pour vérifier la fonction locale a été appelée, trop?
    • Salut @JohnZabroski, l'essai scénario n'a pas besoin d'affirmer occurrences. Bien sûr, vous pouvez vérifier qu'un appel a été effectué. Tout d'abord, vous devez spécifier combien de fois vous vous attendez à de la méthode à appeler. Comme ceci: .DoNothing().OccursOnce(); Et, plus tard, affirmer que l'appel a été fait par l'appel de la Mock.Assert(foo); méthode. Si vous êtes intéressé à la façon dont d'autres scénarios sont pris en charge vous pouvez lire notre Affirmant Occurrence de l'aide de l'article.
    InformationsquelleAutor Mihail Vladov
  4. 0

    - Je utiliser les fonctions inline pour éviter la collecte des ordures pression spécialement lorsque vous traitez avec de plus en cours d'exécution des méthodes. Dire que l'on souhaite obtenir 2 ans, ou les données du marché pour un symbole. Aussi, on peut emballer beaucoup de fonctionnalités et une logique d'entreprise si on a besoin d'.

    ce que l'on ouvre une socket de connexion au serveur et en boucle sur les données de la liaison d'un événement pour un événement. On peut penser de la même manière qu'une classe est conçu, un seul n'est pas l'écriture de méthodes d'assistance partout qui sont vraiment seulement pour une pice de fonctionnalité. ci-dessous quelques exemples de la façon dont cela pourrait ressembler, veuillez noter que je suis à l'aide de variables et de l ' "aide" méthodes sont en dessous de la enfin. En la Finalement j'ai bien supprimer les gestionnaires d'événements, si je Change de classe serait externe/injectés je n'aurais aucune attente de gestionnaire d'événement fondé 

    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;
   } 
}

    Vous pouvez voir les avantages, comme mentionné ci-dessous, vous pouvez voir ici un exemple de mise en œuvre. L'espoir qui aide à expliquer les avantages.

    • 1. C'est vraiment un exemple complexe et explication, simplement pour démontrer les fonctions locales. 2. Les fonctions locales de ne pas éviter tout allocations lors de la comparaison avec les lambdas dans cet exemple, parce qu'ils ont encore à être converti aux délégués. Donc je ne vois pas comment ils pourraient éviter GC.
    • pas de croisement /de la copie des variables à travers, svick réponse du couvre le reste vraiment bien. Pas besoin de dupliquer sa réponse
    InformationsquelleAutor PPann