Méthodes anonymes (C#)

Guide de programmation C#

Méthodes anonymes (Guide de programmation C#)

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 permet désormais l'utilisation de méthodes anonymes.

La création de méthodes anonymes est essentiellement un moyen de passer un bloc de code comme un paramètre de délégué. Par exemple :

// 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 instance
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 en éliminant la nécessité de créer une méthode distincte.

Par exemple, la spécification d'un bloc de code à la place 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 du lancement d'un nouveau thread. Cette classe crée un thread et contient également le code exécuté par le thread, sans qu'il soit nécessaire de 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();
}

Notes

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 dont 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 dont 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 externes ou variables capturées 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); };

Contrairement aux variables locales, la durée de vie de la variable externe 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 référence à n est capturée au moment de la création du délégué.

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 à l'intérieur du anonymous-method-block.

Exemple

L'exemple suivant montre les 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()
    {
        // Instatiate 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);
    }
}

Sortie

The delegate using the anonymous method is called.

The delegate using the named method is called.

Voir aussi

Référence

Concepts

Autres ressources