Action<T1,T2,T3> Délégué

Définition

Espace de noms:

System

Assemblys:

netstandard.dll, System.Runtime.dll

Encapsule une méthode qui a trois paramètres et ne retourne pas de valeur.

C#

public delegate void Action<in T1,in T2,in T3>(T1 arg1, T2 arg2, T3 arg3);

Paramètres de type

T1

Type du premier paramètre de la méthode encapsulée par ce délégué.

Ce paramètre de type est contravariant. Cela signifie que vous pouvez utiliser le type spécifié ou tout type moins dérivé. Pour plus d’informations sur la covariance et la contravariance, consultez Covariance et contravariance dans les génériques.

T2

Type du deuxième paramètre de la méthode encapsulée par ce délégué.

Ce paramètre de type est contravariant. Cela signifie que vous pouvez utiliser le type spécifié ou tout type moins dérivé. Pour plus d’informations sur la covariance et la contravariance, consultez Covariance et contravariance dans les génériques.

T3

Type du troisième paramètre de la méthode encapsulée par ce délégué.

Ce paramètre de type est contravariant. Cela signifie que vous pouvez utiliser le type spécifié ou tout type moins dérivé. Pour plus d’informations sur la covariance et la contravariance, consultez Covariance et contravariance dans les génériques.

Paramètres

arg1

T1

Premier paramètre de la méthode encapsulée par ce délégué.

arg2

T2

Deuxième paramètre de la méthode encapsulée par ce délégué.

arg3

T3

Troisième paramètre de la méthode encapsulée par ce délégué.

Remarques

Vous pouvez utiliser le délégué Action<T1,T2,T3> pour passer une méthode en tant que paramètre sans déclarer explicitement un délégué personnalisé. La méthode encapsulée doit correspondre à la signature de méthode définie par ce délégué. Cela signifie que la méthode encapsulée doit avoir trois paramètres qui lui sont tous passés par valeur, et qu’elle ne doit pas retourner une valeur. (En C#, la méthode doit retourner void. Dans F#, la méthode ou la fonction doit retourner une unité. Dans Visual Basic, elle doit être définie par la construction Sub...End Sub. Il peut également s’agir d’une méthode qui retourne une valeur qui est ignorée.) En règle générale, une telle méthode est utilisée pour effectuer une opération.

Note

Pour référencer une méthode qui a trois paramètres et retourne une valeur, utilisez plutôt le délégué Func<T1,T2,T3,TResult> générique.

Lorsque vous utilisez le délégué Action<T1,T2,T3>, vous n’avez pas besoin de définir explicitement un délégué qui encapsule une méthode avec trois paramètres. Par exemple, le code suivant déclare explicitement un délégué nommé StringCopy et affecte une référence à la méthode CopyStrings à son instance de délégué.

C#

using System;

delegate void StringCopy(string[] stringArray1,
                         string[] stringArray2,
                         int indexToStart);

public class TestDelegate
{
    public static void Main()
    {
        string[] ordinals = ["First", "Second", "Third", "Fourth", "Fifth"];
        string[] copiedOrdinals = new string[ordinals.Length];
        StringCopy copyOperation = CopyStrings;
        copyOperation(ordinals, copiedOrdinals, 3);
        foreach (string ordinal in copiedOrdinals)
            Console.WriteLine(string.IsNullOrEmpty(ordinal) ? "<None>" : ordinal);
    }

    private static void CopyStrings(string[] source, string[] target, int startPos)
    {
        if (source.Length != target.Length)
            throw new IndexOutOfRangeException("The source and target arrays must have the same number of elements.");

        for (int ctr = startPos; ctr <= source.Length - 1; ctr++)
            target[ctr] = source[ctr];
    }
}

L’exemple suivant simplifie ce code en instanciant le délégué Action<T1,T2,T3> au lieu de définir explicitement un nouveau délégué et d’attribuer une méthode nommée à celui-ci.

C#

using System;

public class TestAction3
{
    public static void Main()
    {
        string[] ordinals = ["First", "Second", "Third", "Fourth", "Fifth"];
        string[] copiedOrdinals = new string[ordinals.Length];
        Action<string[], string[], int> copyOperation = CopyStrings;
        copyOperation(ordinals, copiedOrdinals, 3);
        foreach (string ordinal in copiedOrdinals)
            Console.WriteLine(string.IsNullOrEmpty(ordinal) ? "<None>" : ordinal);
    }

    private static void CopyStrings(string[] source, string[] target, int startPos)
    {
        if (source.Length != target.Length)
            throw new IndexOutOfRangeException("The source and target arrays must have the same number of elements.");

        for (int ctr = startPos; ctr <= source.Length - 1; ctr++)
            target[ctr] = source[ctr];
    }
}

Vous pouvez également utiliser le délégué Action<T1,T2,T3> avec des méthodes anonymes en C#, comme l’illustre l’exemple suivant. (Pour une présentation des méthodes anonymes, consultez Méthodes anonymes.)

C#

using System;

public class TestAnon
{
    public static void Main()
    {
        string[] ordinals = ["First", "Second", "Third", "Fourth", "Fifth"];
        string[] copiedOrdinals = new string[ordinals.Length];
        Action<string[], string[], int> copyOperation = delegate (string[] s1,
                                                                 string[] s2,
                                                                 int pos)
                                        { CopyStrings(s1, s2, pos); };
        copyOperation(ordinals, copiedOrdinals, 3);
        foreach (string ordinal in copiedOrdinals)
            Console.WriteLine(string.IsNullOrEmpty(ordinal) ? "<None>" : ordinal);
    }

    private static void CopyStrings(string[] source, string[] target, int startPos)
    {
        if (source.Length != target.Length)
            throw new IndexOutOfRangeException("The source and target arrays must have the same number of elements.");

        for (int ctr = startPos; ctr <= source.Length - 1; ctr++)
            target[ctr] = source[ctr];
    }
}

Vous pouvez également affecter une expression lambda à une instance de délégué Action<T1,T2,T3>, comme l’illustre l’exemple suivant. (Pour une présentation des expressions lambda, consultez expressions lambda (C#) ou expressions lambda (F#).)

C#

using System;

public class TestLambda
{
    public static void Main()
    {
        string[] ordinals = ["First", "Second", "Third", "Fourth", "Fifth"];
        string[] copiedOrdinals = new string[ordinals.Length];
        Action<string[], string[], int> copyOperation = (s1, s2, pos) =>
                                        CopyStrings(s1, s2, pos);
        copyOperation(ordinals, copiedOrdinals, 3);
        foreach (string ordinal in copiedOrdinals)
            Console.WriteLine(string.IsNullOrEmpty(ordinal) ? "<None>" : ordinal);
    }

    private static void CopyStrings(string[] source, string[] target, int startPos)
    {
        if (source.Length != target.Length)
            throw new IndexOutOfRangeException("The source and target arrays must have the same number of elements.");

        for (int ctr = startPos; ctr <= source.Length - 1; ctr++)
            target[ctr] = source[ctr];
    }
}

Méthodes d’extension

GetMethodInfo(Delegate)

Obtient un objet qui représente la méthode représentée par le délégué spécifié.

S’applique à

Voir aussi

• Func<T1,T2,T3,TResult>