Action<T> Delegát

Definice

Obor názvů:

System

Sestavení:

netstandard.dll, System.Runtime.dll

Zdroj:

Action.cs

Zapouzdřuje metodu, která má jeden parametr a nevrací hodnotu.

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)

Parametry typu

T

Typ parametru metody, kterou tento delegát zapouzdřuje.

Tento parametr typu je kontravariantní. To znamená, že můžete použít buď zadaný typ, nebo libovolný typ, který je méně odvozený. Další informace o kovarianci a kontravarianci najdete v tématu popisujícím kovarianci a kontravarianci u parametrického polymorfismu.

Parametry

obj

T

Parametr metody, kterou tento delegát zapouzdřuje.

Příklady

Následující příklad ukazuje použití Action<T> delegáta k tisku obsahu objektu List<T> . V tomto příkladu Print se metoda používá k zobrazení obsahu seznamu v konzole. Kromě toho příklad jazyka C# také ukazuje použití anonymních metod k zobrazení obsahu konzoly. Všimněte si, že v příkladu není explicitně deklarována proměnná Action<T> . Místo toho předá odkaz na metodu, která přebírá jeden parametr a který nevrací hodnotu List<T>.ForEach metody, jejíž jediný parametr je Action<T> delegát. Podobně v příkladu jazyka C# není delegát explicitně vytvořena instance, Action<T> protože podpis anonymní metody odpovídá podpisu Action<T> delegáta, který je očekáváno metodou List<T>.ForEach .

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

Poznámky

Delegáta můžete použít Action<T> k předání metody jako parametru bez explicitního deklarování vlastního delegáta. Zapouzdřená metoda musí odpovídat podpisu metody definovanému tímto delegátem. To znamená, že zapouzdřená metoda musí mít jeden parametr předaný hodnotou a nesmí vracet hodnotu. (V jazyce C# musí metoda vrátit void. V Visual Basic musí být definována Sub... End Sub konstruktor. Může to být také metoda, která vrací hodnotu, která je ignorována.) Obvykle se taková metoda používá k provedení operace.

Note

Pokud chcete odkazovat na metodu, která má jeden parametr a vrací hodnotu, použijte místo toho obecný Func<T,TResult> delegát.

Při použití Action<T> delegáta nemusíte explicitně definovat delegáta, který zapouzdřuje metodu s jedním parametrem. Například následující kód explicitně deklaruje delegát pojmenovaný DisplayMessage a přiřadí odkaz na metodu WriteLine nebo metodu ShowWindowsMessage její instanci delegáta.

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

Následující příklad tento kód zjednodušuje vytvořením instance delegáta Action<T> místo explicitního definování nového delegáta a přiřazení pojmenované metody k němu.

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

Delegáta můžete také použít Action<T> s anonymními metodami v jazyce C#, jak je znázorněno v následujícím příkladu. (Úvod do anonymních metod naleznete v tématu Anonymní metody.)

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);
   }
}

Výraz lambda můžete také přiřadit instanci delegáta Action<T> , jak je znázorněno v následujícím příkladu. (Úvod do výrazů lambda najdete v tématu Výrazy 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

ForEach Jednotlivé ForEach metody přebírají delegáta Action<T> jako parametr. Metoda zapouzdřená delegátem umožňuje provést akci pro každý prvek v poli nebo seznamu. Příklad používá metodu ForEach k poskytnutí ilustrace.

Metody rozšíření

Name	Description
GetMethodInfo(Delegate)	Získá objekt, který představuje metodu reprezentovanou zadaným delegátem.

Viz také

• Func<T,TResult>