Méthodes anonymes (Guide de programmation C#)

 

System_CAPS_ICON_note.jpg Remarque

Pour obtenir la documentation la plus récente sur C#, accédez au Guide C# sur docs.microsoft.com.

Dans les versions de C# antérieures à 2.0, la seule façon de déclarer un délégué consistait à utiliser des méthodes nommées. C# 2.0 a introduit les méthodes anonymes et dans C# 3.0 et les versions ultérieures, les expressions lambda remplacent des méthodes anonymes comme manière privilégiée d'écrire du code incorporé. Toutefois, les informations à propos des méthodes anonymes dans cette rubrique s'appliquent également aux expressions lambda. Il existe un cas dans lequel une méthode anonyme fournit des fonctionnalités introuvables dans les expressions lambda. Les méthodes anonymes vous permettent d'omettre la liste de paramètres. Cela signifie qu'une méthode anonyme peut être convertie en délégués avec diverses signatures. Ceci est impossible avec les expressions lambda. Pour plus d'informations spécifiques aux expressions lambda, consultez Expressions lambda.

La création de méthodes anonymes est essentiellement un moyen de passer un bloc de code en paramètre de délégué. En voici deux exemples :

        // Create a handler for a click event.
        button1.Click += delegate(System.Object o, System.EventArgs e)
                           { System.Windows.Forms.MessageBox.Show("Click!"); };

    // Create a delegate.
    delegate void Del(int x);

    // Instantiate the delegate using an anonymous method.
    Del d = delegate(int k) { /* ... */ };

En utilisant des méthodes anonymes, vous réduisez la charge de travail liée au codage de l'instanciation de délégués, car vous n'avez pas à créer de méthode distincte.

Par exemple, la spécification d'un bloc de code au lieu d'un délégué peut être utile dans une situation où le travail nécessité par la création d'une méthode ne semble pas justifié. Un bon exemple pourrait être le moment où vous démarrez un nouveau thread. Cette classe crée un thread et contient également le code exécuté par le thread sans créer une méthode supplémentaire pour le délégué.

    void StartThread()
    {
        System.Threading.Thread t1 = new System.Threading.Thread
          (delegate()
                {
                    System.Console.Write("Hello, ");
                    System.Console.WriteLine("World!");
                });
        t1.Start();
    }

La portée des paramètres d'une méthode anonyme est anonymous-method-block.

C'est une erreur d'avoir une instruction de saut, telle que goto, break ou continue, à l'intérieur du bloc de méthode anonyme si la cible est à l'extérieur du bloc. C'est également une erreur d'avoir une instruction de saut, telle que goto, break ou continue, à l'extérieur du bloc de méthode anonyme si la cible est à l'intérieur du bloc.

Les variables locales et les paramètres dont la portée contient une déclaration de méthode anonyme sont appelés des variables externes de la méthode anonyme. Par exemple, dans le segment de code suivant, n est une variable externe :

        int n = 0;
        Del d = delegate() { System.Console.WriteLine("Copy #:{0}", ++n); };

Une référence à la variable externe n parle capturées lorsque le délégué est créé. Contrairement aux variables locales, la durée de vie d'une variable capturée s'étend jusqu'à ce que les délégués qui font référence aux méthodes anonymes soient éligibles pour le garbage collection.

Une méthode anonyme ne peut pas accéder aux paramètres ref ou out d'une portée externe.

Aucun code unsafe n'est accessible dans anonymous-method-block.

Les méthodes anonymes ne sont pas autorisées à gauche de l'opérateur is.

L'exemple suivant illustre deux manières d'instancier un délégué :

  • Associer le délégué à une méthode anonyme.

  • Associer le délégué à une méthode nommée (DoWork).

Dans chaque cas, un message est affiché lorsque le délégué est appelé.

    // Declare a delegate.
    delegate void Printer(string s);

    class TestClass
    {
        static void Main()
        {
            // Instantiate the delegate type using an anonymous method.
            Printer p = delegate(string j)
            {
                System.Console.WriteLine(j);
            };

            // Results from the anonymous delegate call.
            p("The delegate using the anonymous method is called.");

            // The delegate instantiation using a named method "DoWork".
            p = new Printer(TestClass.DoWork);

            // Results from the old style delegate call.
            p("The delegate using the named method is called.");
        }

        // The method associated with the named delegate.
        static void DoWork(string k)
        {
            System.Console.WriteLine(k);
        }
    }
    /* Output:
        The delegate using the anonymous method is called.
        The delegate using the named method is called.
    */

Référence C#
Guide de programmation C#
Délégués
Expressions lambda
Pointeurs et code unsafe
Méthodes
Délégués avec méthodes nommées et méthodes anonymes

Afficher: