C # 7 en profondeur: Explorer les fonctions locales

La prise en charge des fonctions locales est une excellente nouvelle fonctionnalité qui a été introduite dans C # 7. Notez que vous pouvez définir des fonctions locales à l'intérieur de n'importe quelle méthode, le constructeur d'une classe ou à l'intérieur d'une propriété - à la fois getter et setter. Lorsqu'elle est compilée par le compilateur C #, une fonction locale est transformée en méthode privée.

Lors du développement d'applications, vous devrez souvent créer des méthodes qui ne sont pas réutilisées - vous n'en avez besoin que pour la modularité. Vous ne voudrez peut-être pas que vos méthodes soient longues, car leur maintien deviendrait un cauchemar avec le temps. Cependant, vous pourriez finir par avoir de nombreuses méthodes privées qui ne seraient pas réutilisées, non? Cette nouvelle fonctionnalité de C # 7 vient à la rescousse dans de telles circonstances - vous pouvez définir des fonctions qui sont locales à une autre portée, ou elle peut être à l'intérieur d'une autre fonction ou même à l'intérieur d'une propriété (à la fois getter et setter).

Imaginez une situation où vous auriez besoin d'une fonction d'assistance qui ne serait appelée qu'une seule fois. Avant C # 7, vous auriez pu y parvenir en utilisant les types Func et Action avec des méthodes anonymes. Cependant, il y avait quelques défis. Ils ne prenaient pas en charge les génériques, les paramètres et les paramètres de référence et de sortie.

Avec C # 7 autour, vous pouvez maintenant déclarer de telles fonctions dans un autre corps d'une autre fonction. Ces fonctions sont appelées fonctions locales. En d'autres termes, la prise en charge des fonctions locales vous permet de définir une fonction dans le cadre d'une autre fonction.

Implémentation de fonctions locales en C #

Écrivons du code et voyons comment fonctionnent les fonctions locales. Considérez l'extrait de code suivant. Notez que la méthode Sum est définie dans le corps de la méthode Main dans l'extrait de code qui suit.

 static void Main(string[] args)

        {

            int Sum(int x, int y)

            {

                return x + y;

            }

            Console.WriteLine(Sum(10, 20));

            Console.ReadKey();

        }

Dans cet exemple, la méthode Sum est une fonction locale - elle est locale à la méthode Main. En d'autres termes, la méthode Sum ne peut être utilisée qu'à l'intérieur de la méthode Main, c'est-à-dire la méthode à l'intérieur de laquelle elle a été définie.

Les fonctions locales peuvent avoir toutes les caractéristiques d'une méthode régulière sauf que les fonctions locales ne peuvent pas être de nature statique. Une fonction locale peut même être asynchrone et peut également avoir accès aux variables du bloc englobant. Les paramètres et les variables locales de la portée englobante peuvent être utilisés dans une fonction locale, similaire aux expressions lambda. Il convient de noter que les variables locales capturées sont transmises à une fonction locale par référence. Voici un autre exemple qui illustre comment une fonction locale peut accéder aux variables de son type englobant.

public static void Display(string str)

        {

            int ctr = 5;

            DisplayText();

            void DisplayText ()

            {

                for(int i = 0; i < ctr; i++)

                Console.WriteLine(str);

            }

        }

Maintenant, reportez-vous à l'extrait de code ci-dessus. La méthode Display contient un paramètre de chaîne et une variable entière à l'intérieur. Notez que la fonction locale définie dans la méthode Display (nommée DisplayText) peut avoir accès aux variables locales ainsi qu'à l'argument de la méthode Display. Belle fonctionnalité, n'est-ce pas?

L'un des principaux avantages des fonctions locales est l'encapsulation - une fonction locale ne peut être appelée qu'à partir de son type englobant. Notez que si vous avez une méthode privée dans votre classe, n'importe quel membre de la classe peut appeler la méthode privée.