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

Définition

Encapsule une méthode ayant quatre paramètres et ne retournant aucune valeur.

generic <typename T1, typename T2, typename T3, typename T4>
public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
public delegate void Action<in T1,in T2,in T3,in T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
public delegate void Action<T1,T2,T3,T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
type Action<'T1, 'T2, 'T3, 'T4> = delegate of 'T1 * 'T2 * 'T3 * 'T4 -> unit
Public Delegate Sub Action(Of In T1, In T2, In T3, In T4)(arg1 As T1, arg2 As T2, arg3 As T3, arg4 As T4)
Public Delegate Sub Action(Of T1, T2, T3, T4)(arg1 As T1, arg2 As T2, arg3 As T3, arg4 As T4)

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.
T4

Type du quatriè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é.

arg4
T4

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

Remarques

Vous pouvez utiliser le Action<T1,T2,T3,T4> délégué pour passer une méthode en tant que paramètre sans déclarer explicitement de 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 quatre paramètres qui lui sont tous passés par valeur, et qu’elle ne doit pas retourner de valeur. (En C#, la méthode doit retourner void. En F#, la méthode ou la fonction doit retourner l’unité. En Visual Basic, elle doit être définie par la Subconstruction ...End Sub . Il peut également s’agir d’une méthode qui retourne une valeur ignorée.) En règle générale, une telle méthode est utilisée pour effectuer une opération.

Notes

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

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

using System;

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

public class TestDelegate
{
    public static void Main()
    {
        string[] ordinals = ["First", "Second", "Third", "Fourth", "Fifth",
                           "Sixth", "Seventh", "Eighth", "Ninth", "Tenth"];
        string[] copiedOrdinals = new string[ordinals.Length];
        StringCopy copyOperation = CopyStrings;
        copyOperation(ordinals, copiedOrdinals, 3, 5);

        Console.WriteLine();
        foreach (string ordinal in copiedOrdinals)
            Console.WriteLine(string.IsNullOrEmpty(ordinal) ? "<None>" : ordinal);
    }

    private static void CopyStrings(string[] source, string[] target,
                                    int startPos, int number)
    {
        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 <= startPos + number - 1; ctr++)
            target[ctr] = source[ctr];
    }
}
open System

type StringCopy = delegate of stringArray1: string [] *
                              stringArray2: string [] *
                              indexToStart: int *
                              numberToCopy: int -> unit

let copyStrings (source: string []) (target: string []) startPos number =
    if source.Length <> target.Length then
        raise (IndexOutOfRangeException "The source and target arrays must have the same number of elements.")

    for i = startPos to startPos + number - 1 do
        target.[i] <- source.[i]

let ordinals =
    [| "First"; "Second"; "Third"; "Fourth"; "Fifth"
       "Sixth"; "Seventh"; "Eighth"; "Ninth"; "Tenth" |]

let copiedOrdinals: string [] = Array.zeroCreate ordinals.Length

let copyOperation = StringCopy copyStrings

copyOperation.Invoke(ordinals, copiedOrdinals, 3, 5)

for ordinal in copiedOrdinals do
    printfn "%s" (if String.IsNullOrEmpty ordinal then "<None>" else ordinal)
Delegate Sub StringCopy(stringArray1() As String, _
                        stringArray2() As String, _
                        indexToStart As Integer, _
                        numberToCopy As Integer)

Module TestDelegate
    Public Sub RunIt()
        Dim ordinals() As String = {"First", "Second", "Third", "Fourth",
                                  "Fifth", "Sixth", "Seventh", "Eighth",
                                  "Ninth", "Tenth"}
        Dim copiedOrdinals(ordinals.Length - 1) As String
        Dim copyOperation As StringCopy = AddressOf CopyStrings
        copyOperation(ordinals, copiedOrdinals, 3, 5)

        Console.WriteLine()
        For Each ordinal As String In copiedOrdinals
            If String.IsNullOrEmpty(ordinal) Then
                Console.WriteLine("<None>")
            Else
                Console.WriteLine(ordinal)
            End If
        Next
    End Sub

    Private Sub CopyStrings(source() As String, target() As String, _
                           startPos As Integer, number As Integer)
      If source.Length <> target.Length Then 
         Throw New IndexOutOfRangeException("The source and target arrays" & _
                   " must have the same number of elements.")
      End If
      For ctr As Integer = startPos to startpos + number  - 1
            target(ctr) = source(ctr)
        Next
   End Sub
End Module

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

using System;

public class TestAction4
{
    public static void Main()
    {
        string[] ordinals = ["First", "Second", "Third", "Fourth", "Fifth",
                           "Sixth", "Seventh", "Eighth", "Ninth", "Tenth"];
        string[] copiedOrdinals = new string[ordinals.Length];
        Action<string[], string[], int, int> copyOperation = CopyStrings;
        copyOperation(ordinals, copiedOrdinals, 3, 5);

        Console.WriteLine();
        foreach (string ordinal in copiedOrdinals)
            Console.WriteLine(string.IsNullOrEmpty(ordinal) ? "<None>" : ordinal);
    }

    private static void CopyStrings(string[] source, string[] target,
                                    int startPos, int number)
    {
        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 <= startPos + number - 1; ctr++)
            target[ctr] = source[ctr];
    }
}
open System

let copyStrings (source: string []) (target: string []) startPos number =
    if source.Length <> target.Length then
        raise (IndexOutOfRangeException "The source and target arrays must have the same number of elements.")

    for i = startPos to startPos + number - 1 do
        target.[i] <- source.[i]

let ordinals =
    [| "First"; "Second"; "Third"; "Fourth"; "Fifth"
       "Sixth"; "Seventh"; "Eighth"; "Ninth"; "Tenth" |]

let copiedOrdinals: string [] = Array.zeroCreate ordinals.Length

let copyOperation = Action<_, _, _, _> copyStrings

copyOperation.Invoke(ordinals, copiedOrdinals, 3, 5)

for ordinal in copiedOrdinals do
    printfn "%s" (if String.IsNullOrEmpty ordinal then "<None>" else ordinal)
Module TestAction4
    Public Sub RunIt()
        Dim ordinals() As String = {"First", "Second", "Third", "Fourth",
                                  "Fifth", "Sixth", "Seventh", "Eighth",
                                  "Ninth", "Tenth"}
        Dim copiedOrdinals(ordinals.Length - 1) As String
        Dim copyOperation As Action(Of String(), String(), Integer, Integer) =
                           AddressOf CopyStrings
        copyOperation(ordinals, copiedOrdinals, 3, 5)

        Console.WriteLine()
        For Each ordinal As String In copiedOrdinals
            If String.IsNullOrEmpty(ordinal) Then
                Console.WriteLine("<None>")
            Else
                Console.WriteLine(ordinal)
            End If
        Next
    End Sub

    Private Sub CopyStrings(source() As String, target() As String, _
                           startPos As Integer, number As Integer)
      If source.Length <> target.Length Then 
         Throw New IndexOutOfRangeException("The source and target arrays" & _
                   " must have the same number of elements.")
      End If
      For ctr As Integer = startPos to startpos + number  - 1
            target(ctr) = source(ctr)
        Next
   End Sub
End Module

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

using System;

public class TestAnonymousMethod
{
    public static void Main()
    {
        string[] ordinals = ["First", "Second", "Third", "Fourth", "Fifth",
                           "Sixth", "Seventh", "Eighth", "Ninth", "Tenth"];
        string[] copiedOrdinals = new string[ordinals.Length];
        Action<string[], string[], int, int> copyOperation =
                                             delegate (string[] s1, string[] s2,
                                             int pos, int num)
                                  { CopyStrings(s1, s2, pos, num); };
        copyOperation(ordinals, copiedOrdinals, 3, 5);

        Console.WriteLine();
        foreach (string ordinal in copiedOrdinals)
            Console.WriteLine(string.IsNullOrEmpty(ordinal) ? "<None>" : ordinal);
    }

    private static void CopyStrings(string[] source, string[] target,
                                    int startPos, int number)
    {
        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 <= startPos + number - 1; ctr++)
            target[ctr] = source[ctr];
    }
}

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

using System;

public class TestLambdaExpression
{
    public static void Main()
    {
        string[] ordinals = ["First", "Second", "Third", "Fourth", "Fifth",
                           "Sixth", "Seventh", "Eighth", "Ninth", "Tenth"];
        string[] copiedOrdinals = new string[ordinals.Length];
        Action<string[], string[], int, int> copyOperation = (s1, s2, pos, num)
                                             => CopyStrings(s1, s2, pos, num);
        copyOperation(ordinals, copiedOrdinals, 3, 5);

        Console.WriteLine();
        foreach (string ordinal in copiedOrdinals)
            Console.WriteLine(string.IsNullOrEmpty(ordinal) ? "<None>" : ordinal);
    }

    private static void CopyStrings(string[] source, string[] target,
                                    int startPos, int number)
    {
        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 <= startPos + number - 1; ctr++)
            target[ctr] = source[ctr];
    }
}
open System

let copyStrings (source: string []) (target: string []) startPos number =
    if source.Length <> target.Length then
        raise (IndexOutOfRangeException "The source and target arrays must have the same number of elements.")

    for i = startPos to startPos + number - 1 do
        target.[i] <- source.[i]

let ordinals =
    [| "First"; "Second"; "Third"; "Fourth"; "Fifth"
       "Sixth"; "Seventh"; "Eighth"; "Ninth"; "Tenth" |]

let copiedOrdinals: string [] = Array.zeroCreate ordinals.Length

let copyOperation = Action<_, _, _, _> (fun s1 s2 pos num -> copyStrings s1 s2 pos num)

copyOperation.Invoke(ordinals, copiedOrdinals, 3, 5)

for ordinal in copiedOrdinals do
    printfn "%s" (if String.IsNullOrEmpty ordinal then "<None>" else ordinal)
Public Module TestLambdaExpression
    Public Sub RunIt()
        Dim ordinals() As String = {"First", "Second", "Third", "Fourth", "Fifth",
                           "Sixth", "Seventh", "Eighth", "Ninth", "Tenth"}
        Dim copiedOrdinals(ordinals.Length - 1) As String
        Dim copyOperation As Action(Of String(), String(), Integer, Integer) =
                           Sub(s1, s2, pos, num) CopyStrings(s1, s2, pos, num)
        copyOperation(ordinals, copiedOrdinals, 3, 5)

        Console.WriteLine()
        For Each ordinal As String In copiedOrdinals
            If String.IsNullOrEmpty(ordinal) Then
                Console.WriteLine("<None>")
            Else
                Console.WriteLine(ordinal)
            End If
        Next
    End Sub

    Private Function CopyStrings(source() As String, target() As String,
                                startPos As Integer, number As Integer) As Integer
        If source.Length <> target.Length Then
            Throw New IndexOutOfRangeException("The source and target arrays must have the same number of elements.")
        End If

        For ctr As Integer = startPos To startPos + number - 1
            target(ctr) = source(ctr)
        Next
        Return number
    End Function
End Module

' The example displays the following output:
'       Fourth
'       Fifth
'       Sixth
'       Seventh
'       Eighth

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