Délégués avec méthodes nommées et Méthodes anonymes (Guide de programmation C#)Delegates with Named vs. Anonymous Methods (C# Programming Guide)

Un délégué peut être associé à une méthode nommée.A delegate can be associated with a named method. Quand vous instanciez un délégué à l’aide d’une méthode nommée, la méthode est passée en tant que paramètre, par exemple :When you instantiate a delegate by using a named method, the method is passed as a parameter, for example:

// Declare a delegate:
delegate void Del(int x);

// Define a named method:
void DoWork(int k) { /* ... */ }

// Instantiate the delegate using the method as a parameter:
Del d = obj.DoWork;

C’est ce qui s’appelle utiliser une méthode nommée.This is called using a named method. Les délégués construits avec une méthode nommée peuvent encapsuler une méthode static ou une méthode d’instance.Delegates constructed with a named method can encapsulate either a static method or an instance method. Les méthodes nommées représentent la seule façon d’instancier un délégué dans les versions précédentes de C#.Named methods are the only way to instantiate a delegate in earlier versions of C#. Toutefois, dans une situation où la création d’une méthode constitue une charge de travail non souhaitée, C# vous permet d’instancier un délégué et de spécifier immédiatement un bloc de code que le délégué traite quand il est appelé.However, in a situation where creating a new method is unwanted overhead, C# enables you to instantiate a delegate and immediately specify a code block that the delegate will process when it is called. Le bloc peut contenir une expression lambda ou une méthode anonyme.The block can contain either a lambda expression or an anonymous method. Pour plus d’informations, consultez Fonctions anonymes.For more information, see Anonymous Functions.

NotesRemarks

La méthode que vous passez en tant que paramètre de délégué doit avoir la même signature que la déclaration du délégué.The method that you pass as a delegate parameter must have the same signature as the delegate declaration.

Une instance de délégué encapsule soit une méthode statique soit une méthode d’instance.A delegate instance may encapsulate either static or instance method.

Même si le délégué peut utiliser un paramètre out, nous ne recommandons pas son utilisation avec les délégués d’événement multicast, car vous ne pouvez pas savoir quel délégué sera appelé.Although the delegate can use an out parameter, we do not recommend its use with multicast event delegates because you cannot know which delegate will be called.

Exemple 1Example 1

L’exemple suivant est un exemple simple de déclaration et d’utilisation d’un délégué.The following is a simple example of declaring and using a delegate. Notez que le délégué, Del, et la méthode associée, MultiplyNumbers, ont la même signatureNotice that both the delegate, Del, and the associated method, MultiplyNumbers, have the same signature

// Declare a delegate
delegate void Del(int i, double j);

class MathClass
{
    static void Main()
    {
        MathClass m = new MathClass();

        // Delegate instantiation using "MultiplyNumbers"
        Del d = m.MultiplyNumbers;

        // Invoke the delegate object.
        System.Console.WriteLine("Invoking the delegate using 'MultiplyNumbers':");
        for (int i = 1; i <= 5; i++)
        {
            d(i, 2);
        }

        // Keep the console window open in debug mode.
        System.Console.WriteLine("Press any key to exit.");
        System.Console.ReadKey();
    }

    // Declare the associated method.
    void MultiplyNumbers(int m, double n)
    {
        System.Console.Write(m * n + " ");
    }
}
/* Output:
    Invoking the delegate using 'MultiplyNumbers':
    2 4 6 8 10
*/

Exemple 2Example 2

Dans l’exemple suivant, un délégué est associé à une méthode statique et à une méthode d’instance, et retourne des informations spécifiques à partir de chacune.In the following example, one delegate is mapped to both static and instance methods and returns specific information from each.

// Declare a delegate
delegate void Del();

class SampleClass
{
    public void InstanceMethod()
    {
        System.Console.WriteLine("A message from the instance method.");
    }

    static public void StaticMethod()
    {
        System.Console.WriteLine("A message from the static method.");
    }
}

class TestSampleClass
{
    static void Main()
    {
        SampleClass sc = new SampleClass();

        // Map the delegate to the instance method:
        Del d = sc.InstanceMethod;
        d();

        // Map to the static method:
        d = SampleClass.StaticMethod;
        d();
    }
}
/* Output:
    A message from the instance method.
    A message from the static method.
*/

Voir aussiSee also