Action<T> Délégué

Définition

Espace de noms:

System

Assemblys:

netstandard.dll, System.Runtime.dll

Source:

Action.cs

Encapsule une méthode qui a un paramètre unique et ne retourne pas de valeur.

generic <typename T>
public delegate void Action(T obj);

public delegate void Action<in T>(T obj) where T : allows ref struct;

type Action<'T> = delegate of 'T -> unit

Public Delegate Sub Action(Of In T)(obj As T)

Paramètres de type

T

Type du 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

obj

T

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

Exemples

L’exemple suivant illustre l’utilisation du Action<T> délégué pour imprimer le contenu d’un List<T> objet. Dans cet exemple, la Print méthode est utilisée pour afficher le contenu de la liste dans la console. En outre, l’exemple C# illustre également l’utilisation de méthodes anonymes pour afficher le contenu dans la console. Notez que l’exemple ne déclare pas explicitement une Action<T> variable. Au lieu de cela, il transmet une référence à une méthode qui prend un paramètre unique et qui ne retourne pas de valeur à la méthode, dont le List<T>.ForEach paramètre unique est un Action<T> délégué. De même, dans l’exemple C#, un Action<T> délégué n’est pas instancié explicitement, car la signature de la méthode anonyme correspond à la Action<T> signature du délégué attendu par la List<T>.ForEach méthode.

List<string> names = new List<string>();
names.Add("Bruce");
names.Add("Alfred");
names.Add("Tim");
names.Add("Richard");

// Display the contents of the list using the Print method.
names.ForEach(Print);

// The following demonstrates the anonymous method feature of C#
// to display the contents of the list to the console.
names.ForEach(delegate(string name)
{
    Console.WriteLine(name);
});

void Print(string s)
{
    Console.WriteLine(s);
}

/* This code will produce output similar to the following:
* Bruce
* Alfred
* Tim
* Richard
* Bruce
* Alfred
* Tim
* Richard
*/

// F# provides a type alias for System.Collections.List<'T> as ResizeArray<'T>.
let names = ResizeArray<string>()
names.Add "Bruce"
names.Add "Alfred"
names.Add "Tim"
names.Add "Richard"

let print s = printfn "%s" s

// Display the contents of the list using the print function.
names.ForEach(Action<string> print)

// The following demonstrates the lambda expression feature of F#
// to display the contents of the list to the console.
names.ForEach(fun s -> printfn "%s" s)

(* This code will produce output similar to the following:
* Bruce
* Alfred
* Tim
* Richard
* Bruce
* Alfred
* Tim
* Richard
*)

Imports System.Collections.Generic

Class Program
    Shared Sub Main()
        Dim names As New List(Of String)
        names.Add("Bruce")
        names.Add("Alfred")
        names.Add("Tim")
        names.Add("Richard")

        ' Display the contents of the list using the Print method.
        names.ForEach(AddressOf Print)
    End Sub

    Shared Sub Print(ByVal s As String)
        Console.WriteLine(s)
    End Sub
End Class

' This code will produce output similar to the following:
' Bruce
' Alfred
' Tim
' Richard

Remarques

Vous pouvez utiliser le Action<T> délégué 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 un paramètre qui lui est transmis par valeur, et qu’elle ne doit pas retourner de valeur. (En C#, la méthode doit retourner void. Dans Visual Basic, elle doit être définie par le Sub... construction 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 un paramètre et retourne une valeur, utilisez plutôt le délégué générique Func<T,TResult> .

Lorsque vous utilisez le Action<T> délégué, vous n’avez pas besoin de définir explicitement un délégué qui encapsule une méthode avec un seul paramètre. Par exemple, le code suivant déclare explicitement un délégué nommé DisplayMessage et affecte une référence à la WriteLine méthode ou à la ShowWindowsMessage méthode à son instance de délégué.

using System;
using System.Windows.Forms;

delegate void DisplayMessage(string message);

public class TestCustomDelegate
{
   public static void Main()
   {
      DisplayMessage messageTarget;

      if (Environment.GetCommandLineArgs().Length > 1)
         messageTarget = ShowWindowsMessage;
      else
         messageTarget = Console.WriteLine;

      messageTarget("Hello, World!");
   }

   private static void ShowWindowsMessage(string message)
   {
      MessageBox.Show(message);
   }
}

open System
open System.Windows.Forms

type DisplayMessage = delegate of message: string -> unit

let showWindowsMessage message = 
    MessageBox.Show message |> ignore

let messageTarget =
    DisplayMessage(
        if Environment.GetCommandLineArgs().Length > 1 then
            showWindowsMessage
        else
            printfn "%s"
    )

messageTarget.Invoke "Hello, World!"

Delegate Sub DisplayMessage(message As String) 

Module TestCustomDelegate
   Public Sub Main
      Dim messageTarget As DisplayMessage 

      If Environment.GetCommandLineArgs().Length > 1 Then
         messageTarget = AddressOf ShowWindowsMessage
      Else
         messageTarget = AddressOf Console.WriteLine
      End If
      messageTarget("Hello, World!")
   End Sub
   
   Private Sub ShowWindowsMessage(message As String)
      MsgBox(message)
   End Sub   
End Module

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

using System;
using System.Windows.Forms;

public class TestAction1
{
   public static void Main()
   {
      Action<string> messageTarget;

      if (Environment.GetCommandLineArgs().Length > 1)
         messageTarget = ShowWindowsMessage;
      else
         messageTarget = Console.WriteLine;

      messageTarget("Hello, World!");
   }

   private static void ShowWindowsMessage(string message)
   {
      MessageBox.Show(message);
   }
}

open System
open System.Windows.Forms

let showWindowsMessage message = 
    MessageBox.Show message |> ignore

let messageTarget =
    Action<string>(
        if Environment.GetCommandLineArgs().Length > 1 then
            showWindowsMessage
        else
            printfn "%s"
    )

messageTarget.Invoke "Hello, World!"

Module TestAction1
   Public Sub Main
      Dim messageTarget As Action(Of String) 

      If Environment.GetCommandLineArgs().Length > 1 Then
         messageTarget = AddressOf ShowWindowsMessage
      Else
         messageTarget = AddressOf Console.WriteLine
      End If
      messageTarget("Hello, World!")
   End Sub
   
   Private Sub ShowWindowsMessage(message As String)
      MsgBox(message)
   End Sub   
End Module

Vous pouvez également utiliser le Action<T> délégué 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.)

using System;
using System.Windows.Forms;

public class TestAnonMethod
{
   public static void Main()
   {
      Action<string> messageTarget;

      if (Environment.GetCommandLineArgs().Length > 1)
         messageTarget = delegate(string s) { ShowWindowsMessage(s); };
      else
         messageTarget = delegate(string s) { Console.WriteLine(s); };

      messageTarget("Hello, World!");
   }

   private static void ShowWindowsMessage(string message)
   {
      MessageBox.Show(message);
   }
}

Vous pouvez également affecter une expression lambda à une Action<T> instance de délégué, comme l’illustre l’exemple suivant. (Pour une introduction aux expressions lambda, consultez Expressions lambda.)

using System;
using System.Windows.Forms;

public class TestLambdaExpression
{
   public static void Main()
   {
      Action<string> messageTarget;

      if (Environment.GetCommandLineArgs().Length > 1)
         messageTarget = s => ShowWindowsMessage(s);
      else
         messageTarget = s => Console.WriteLine(s);

      messageTarget("Hello, World!");
   }

   private static void ShowWindowsMessage(string message)
   {
      MessageBox.Show(message);
   }
}

open System
open System.Windows.Forms

let showWindowsMessage message = 
    MessageBox.Show message |> ignore

let messageTarget =
    Action<string>(
        if Environment.GetCommandLineArgs().Length > 1 then
            fun s -> showWindowsMessage s
        else
            fun s -> printfn "%s" s
    )

messageTarget.Invoke "Hello, World!"

Imports System.Windows.Forms

Public Module TestLambdaExpression
   Public Sub Main()
      Dim messageTarget As Action(Of String) 
      
      If Environment.GetCommandLineArgs().Length > 1 Then
         messageTarget = Sub(s) ShowWindowsMessage(s) 
      Else
         messageTarget = Sub(s) ShowConsoleMessage(s)
      End If
      messageTarget("Hello, World!")
   End Sub
      
   Private Function ShowWindowsMessage(message As String) As Integer
      Return MessageBox.Show(message)      
   End Function
   
   Private Function ShowConsoleMessage(message As String) As Integer
      Console.WriteLine(message)
      Return 0
   End Function
End Module

Les ForEach méthodes et ForEach les méthodes prennent chacun un Action<T> délégué en tant que paramètre. La méthode encapsulée par le délégué vous permet d’effectuer une action sur chaque élément du tableau ou de la liste. L’exemple utilise la ForEach méthode pour fournir une illustration.

Méthodes d’extension

Nom	Description
GetMethodInfo(Delegate)	Obtient un objet qui représente la méthode représentée par le délégué spécifié.

Voir aussi

• Func<T,TResult>