Action<T> Delegar
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Encapsula um método que tem um único parâmetro e não retorna um valor.
generic <typename T>
public delegate void Action(T obj);
public delegate void Action<in T>(T obj);
public delegate void Action<T>(T obj);
type Action<'T> = delegate of 'T -> unit
Public Delegate Sub Action(Of In T)(obj As T)
Public Delegate Sub Action(Of T)(obj As T)
- T
O tipo do parâmetro do método encapsulado por esse delegado.
Este parâmetro de tipo é contravariante. Isso significa que é possível usar o tipo especificado ou qualquer tipo menos derivado. Para obter mais informações sobre covariância e contravariância, consulte Covariância e contravariância em genéricos.- obj
- T
O parâmetro do método encapsulado por esse delegado.
O exemplo a seguir demonstra o uso do Action<T> delegado para imprimir o conteúdo de um List<T> objeto. Neste exemplo, o Print
método é usado para exibir o conteúdo da lista no console. Além disso, o exemplo de C# também demonstra o uso de métodos anônimos para exibir o conteúdo no console. Observe que o exemplo não declara explicitamente uma Action<T> variável. Em vez disso, ele passa uma referência a um método que usa um único parâmetro e que não retorna um valor para o List<T>.ForEach método, cujo único parâmetro é um Action<T> delegado. Da mesma forma, no exemplo de C#, um Action<T> delegado não é explicitamente instanciado porque a assinatura do método anônimo corresponde à assinatura do Action<T> delegado que é esperada pelo List<T>.ForEach método.
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
Você pode usar o Action<T> delegado para passar um método como um parâmetro sem declarar explicitamente um delegado personalizado. O método encapsulado deve corresponder à assinatura do método definida por esse delegado. Isso significa que o método encapsulado deve ter um parâmetro que é passado para ele por valor e não deve retornar um valor. (Em C#, o método deve retornar void
. Em Visual Basic, ele deve ser definido peloSub
...End Sub
Construir. Também pode ser um método que retorna um valor ignorado.) Normalmente, esse método é usado para executar uma operação.
Observação
Para fazer referência a um método que tem um parâmetro e retorna um valor, use o delegado genérico Func<T,TResult> .
Ao usar o Action<T> delegado, você não precisa definir explicitamente um delegado que encapsula um método com um único parâmetro. Por exemplo, o código a seguir declara explicitamente um delegado nomeado DisplayMessage
e atribui uma referência ao WriteLine método ou ao ShowWindowsMessage
método à instância delegada.
#using <System.Windows.Forms.dll>
using namespace System;
using namespace System::Windows::Forms;
public delegate void DisplayMessage(String^ message);
public ref class TestCustomDelegate
{
public:
static void ShowWindowsMessage(String^ message)
{
MessageBox::Show(message);
}
};
int main()
{
DisplayMessage^ messageTarget;
if (Environment::GetCommandLineArgs()->Length > 1)
messageTarget = gcnew DisplayMessage(&TestCustomDelegate::ShowWindowsMessage);
else
messageTarget = gcnew DisplayMessage(&Console::WriteLine);
messageTarget(L"Hello World!");
return 0;
}
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
O exemplo a seguir simplifica esse código instanciando o Action<T> delegado em vez de definir explicitamente um novo delegado e atribuir um método nomeado a ele.
#using <System.Windows.Forms.dll>
using namespace System;
using namespace System::Windows::Forms;
namespace ActionExample
{
public ref class Message
{
public:
static void ShowWindowsMessage(String^ message)
{
MessageBox::Show(message);
}
};
}
int main()
{
Action<String^>^ messageTarget;
if (Environment::GetCommandLineArgs()->Length > 1)
messageTarget = gcnew Action<String^>(&ActionExample::Message::ShowWindowsMessage);
else
messageTarget = gcnew Action<String^>(&Console::WriteLine);
messageTarget("Hello, World!");
return 0;
}
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
Você também pode usar o Action<T> delegado com métodos anônimos em C#, como ilustra o exemplo a seguir. (Para obter uma introdução aos métodos anônimos, consulte Métodos Anônimos.)
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);
}
}
Você também pode atribuir uma expressão lambda a uma Action<T> instância delegada, como ilustra o exemplo a seguir. (Para obter uma introdução às expressões lambda, consulte Lambda Expressions.)
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
Os ForEach métodos e ForEach cada um assumem um Action<T> delegado como um parâmetro. O método encapsulado pelo delegado permite que você execute uma ação em cada elemento na matriz ou lista. O exemplo usa o ForEach método para fornecer uma ilustração.
Get |
Obtém um objeto que representa o método representado pelo delegado especificado. |