Action<T> Delegat

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Kapselt eine Methode, die über einen einzelnen Parameter verfügt und keinen Wert zurückgibt.

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)

Typparameter

T

Der Typ des Parameters der Methode, die dieser Delegat kapselt.

Dieser Typparameter ist kontravariant. Das bedeutet, dass Sie entweder den angegebenen Typ oder einen weniger abgeleiteten Typ verwenden können. Weitere Informationen zu Kovarianz und Kontravarianz finden Sie unter Kovarianz und Kontravarianz in Generics.

Parameter

obj: T

Der Parameter der Methode, die dieser Delegat kapselt.

Beispiele

Das folgende Beispiel veranschaulicht die Verwendung des Action<T> Delegaten zum Drucken des Inhalts eines List<T> Objekts. In diesem Beispiel wird die Print -Methode verwendet, um den Inhalt der Liste in der Konsole anzuzeigen. Darüber hinaus veranschaulicht das C#-Beispiel auch die Verwendung anonymer Methoden zum Anzeigen der Inhalte in der Konsole. Beachten Sie, dass im Beispiel eine Action<T> Variable nicht explizit deklariert wird. Stattdessen wird ein Verweis auf eine Methode übergeben, die einen einzelnen Parameter akzeptiert und keinen Wert an die List<T>.ForEach -Methode zurückgibt, deren einzelner Parameter ein Action<T> Delegate ist. In ähnlicher Weise wird im C#-Beispiel ein Action<T> Delegat nicht explizit instanziiert, da die Signatur der anonymen Methode mit der Signatur des Delegaten übereinstimmt, die Action<T> von der List<T>.ForEach -Methode erwartet wird.

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

Hinweise

Sie können den Action<T> Delegaten verwenden, um eine Methode als Parameter zu übergeben, ohne einen benutzerdefinierten Delegaten explizit zu deklarieren. Die gekapselte Methode muss der Von diesem Delegaten definierten Methodensignatur entsprechen. Dies bedeutet, dass die gekapselte Methode über einen Parameter verfügen muss, der als Wert an sie übergeben wird, und sie darf keinen Wert zurückgeben. (In C# muss die -Methode zurückgeben void. In Visual Basic muss es durch das SubKonstrukt ...End Sub definiert werden. Es kann auch eine Methode sein, die einen wert zurückgibt, der ignoriert wird.) In der Regel wird eine solche Methode verwendet, um einen Vorgang auszuführen.

Hinweis

Verwenden Sie stattdessen den generischen Func<T,TResult> Delegat, um auf eine Methode zu verweisen, die über einen Parameter verfügt und einen Wert zurückgibt.

Wenn Sie den Action<T> Delegaten verwenden, müssen Sie nicht explizit einen Delegaten definieren, der eine Methode mit einem einzelnen Parameter kapselt. Der folgende Code deklariert beispielsweise explizit einen Delegat namens DisplayMessage und weist ihrer Delegateninstanz entweder einen Verweis auf die WriteLine -Methode oder die ShowWindowsMessage -Methode zu.

#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

Im folgenden Beispiel wird dieser Code vereinfacht, indem der Action<T> Delegat instanziiert wird, anstatt explizit einen neuen Delegaten zu definieren und ihm eine benannte Methode zuzuweisen.

#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

Sie können den Action<T> Delegaten auch mit anonymen Methoden in C# verwenden, wie das folgende Beispiel veranschaulicht. (Eine Einführung in anonyme Methoden finden Sie unter Anonyme Methoden.)

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

Sie können einer Delegateninstanz auch einen Action<T> Lambdaausdruck zuweisen, wie das folgende Beispiel veranschaulicht. (Eine Einführung in Lambdaausdrücke finden Sie unter Lambdaausdrücke.)

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

Die ForEach Methoden und ForEach nehmen jeweils einen Action<T> Delegaten als Parameter an. Mit der vom Delegaten gekapselten Methode können Sie eine Aktion für jedes Element im Array oder in der Liste ausführen. Im Beispiel wird die ForEach -Methode verwendet, um eine Abbildung bereitzustellen.

Erweiterungsmethoden

GetMethodInfo(Delegate)

Ruft ein Objekt ab, das die Methode darstellt, die vom angegebenen Delegaten dargestellt wird.

Gilt für:

Weitere Informationen

Func<T,TResult>

Teilen über