Action<T1,T2,T3> Délégué
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Encapsule une méthode ayant trois paramètres et ne retournant aucune valeur.
generic <typename T1, typename T2, typename T3>
public delegate void Action(T1 arg1, T2 arg2, T3 arg3);
public delegate void Action<in T1,in T2,in T3>(T1 arg1, T2 arg2, T3 arg3);
public delegate void Action<T1,T2,T3>(T1 arg1, T2 arg2, T3 arg3);
type Action<'T1, 'T2, 'T3> = delegate of 'T1 * 'T2 * 'T3 -> unit
Public Delegate Sub Action(Of In T1, In T2, In T3)(arg1 As T1, arg2 As T2, arg3 As T3)
Public Delegate Sub Action(Of T1, T2, T3)(arg1 As T1, arg2 As T2, arg3 As T3)
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 Action<T1,T2,T3> 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 trois 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 Sub
construction ...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 trois paramètres et retourne une valeur, utilisez plutôt le délégué générique Func<T1,T2,T3,TResult> .
Lorsque vous utilisez le Action<T1,T2,T3> délégué, 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 CopyStrings
méthode à son instance de délégué.
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] = string.Copy(source[ctr]);
}
}
open System
type StringCopy = delegate of stringArray1: string [] *
stringArray2: string [] *
indexToStart: int -> unit
let copyStrings (source: string []) (target: string []) startPos =
if source.Length <> target.Length then
raise (IndexOutOfRangeException "The source and target arrays must have the same number of elements.")
for i = startPos to source.Length - 1 do
target.[i] <- source.[i]
let ordinals = [| "First"; "Second"; "Third"; "Fourth"; "Fifth" |]
let copiedOrdinals: string [] = Array.zeroCreate ordinals.Length
let copyOperation = StringCopy copyStrings
copyOperation.Invoke(ordinals, copiedOrdinals, 3)
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)
Module TestDelegate
Public Sub Main()
Dim ordinals() As String = {"First", "Second", "Third", "Fourth", "Fifth"}
Dim copiedOrdinals(ordinals.Length - 1) As String
Dim copyOperation As StringCopy = AddressOf CopyStrings
copyOperation(ordinals, copiedOrdinals, 3)
For Each ordinal As String In copiedOrdinals
Console.WriteLine(ordinal)
Next
End Sub
Private Sub CopyStrings(source() As String, target() As String, startPos 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 source.Length - 1
target(ctr) = String.Copy(source(ctr))
Next
End Sub
End Module
L’exemple suivant simplifie ce code en instanciant le Action<T1,T2,T3> 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 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] = string.Copy(source[ctr]);
}
}
open System
let copyStrings (source: string []) (target: string []) startPos =
if source.Length <> target.Length then
raise (IndexOutOfRangeException "The source and target arrays must have the same number of elements.")
for i = startPos to source.Length - 1 do
target.[i] <- source.[i]
let ordinals = [| "First"; "Second"; "Third"; "Fourth"; "Fifth" |]
let copiedOrdinals = Array.zeroCreate<string> ordinals.Length
let copyOperation = Action<_,_,_> copyStrings
copyOperation.Invoke(ordinals, copiedOrdinals, 3)
for ordinal in copiedOrdinals do
printfn "%s" (if String.IsNullOrEmpty ordinal then "<None>" else ordinal)
Module TestAction3
Public Sub Main()
Dim ordinals() As String = {"First", "Second", "Third", "Fourth", "Fifth"}
Dim copiedOrdinals(ordinals.Length - 1) As String
Dim copyOperation As Action(Of String(), String(), Integer) = AddressOf CopyStrings
copyOperation(ordinals, copiedOrdinals, 3)
For Each ordinal As String In copiedOrdinals
Console.WriteLine(ordinal)
Next
End Sub
Private Sub CopyStrings(source() As String, target() As String, startPos 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 source.Length - 1
target(ctr) = String.Copy(source(ctr))
Next
End Sub
End Module
Vous pouvez également utiliser le délégué avec des Action<T1,T2,T3> 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 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] = string.Copy(source[ctr]);
}
}
Vous pouvez également affecter une expression lambda à une instance de Action<T1,T2,T3> 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 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(ordinal == string.Empty ? "<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] = string.Copy(source[ctr]);
}
}
open System
let copyStrings (source: string []) (target: string []) startPos =
if source.Length <> target.Length then
raise (IndexOutOfRangeException "The source and target arrays must have the same number of elements.")
for i = startPos to source.Length - 1 do
target.[i] <- source.[i]
let ordinals = [| "First"; "Second"; "Third"; "Fourth"; "Fifth" |]
let copiedOrdinals: string [] = Array.zeroCreate ordinals.Length
let copyOperation = Action<_,_,_> (fun s1 s2 pos -> copyStrings s1 s2 pos)
copyOperation.Invoke(ordinals, copiedOrdinals, 3)
for ordinal in copiedOrdinals do
printfn "%s" (if String.IsNullOrEmpty ordinal then "<None>" else ordinal)
Public Module TestLambda
Public Sub Main()
Dim ordinals() As String = {"First", "Second", "Third", "Fourth", "Fifth"}
Dim copiedOrdinals(ordinals.Length - 1) As String
Dim copyOperation As Action(Of String(), String(), Integer) = _
Sub(s1, s2, pos) CopyStrings(s1, s2, pos)
copyOperation(ordinals, copiedOrdinals, 3)
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) 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 source.Length - 1
target(ctr) = String.Copy(source(ctr))
Next
Return source.Length - startPos
End Function
End Module
' The example displays the following output:
' Fourth
' Fifth
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
Commentaires
https://aka.ms/ContentUserFeedback.
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultezEnvoyer et afficher des commentaires pour