Action<T> Delegált

Definíció

Névtér:

System

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

Action.cs

Olyan metódust ágyaz be, amely egyetlen paraméterrel rendelkezik, és nem ad vissza értéket.

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)

Típusparaméterek

T

A delegált által beágyazott metódus paraméterének típusa.

Ez a típusparaméter kontravariancia típusú. Ez azt jelenti, hogy a megadott típust vagy egy kevésbé származtatott bármilyen típust is használhat. A kovarianciáról és a kontravarianciáról a Kovariancia és a kontravariancia az általánosításban című cikket.

Paraméterek

obj

T

A delegált által beágyazott metódus paramétere.

Példák

Az alábbi példa bemutatja, hogy a Action<T> delegált egy objektum tartalmának List<T> nyomtatására használja. Ebben a példában a rendszer a Print lista tartalmát jeleníti meg a konzolon. A C#-példa emellett azt is bemutatja, hogy névtelen metódusok használatával jeleníthetők meg a tartalmak a konzolon. Vegye figyelembe, hogy a példa nem deklarál explicit módon változót Action<T> . Ehelyett egy olyan metódusra mutató hivatkozást ad át, amely egyetlen paramétert használ, és amely nem ad vissza értéket a List<T>.ForEach metódusnak, amelynek egyetlen paramétere delegált Action<T> . Hasonlóképpen, a C# példában a meghatalmazott nem lesz explicit módon példányosítva, Action<T> mert a névtelen metódus aláírása megegyezik a Action<T> metódus által List<T>.ForEach várt meghatalmazott aláírásával.

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

Megjegyzések

A meghatalmazott használatával Action<T> paraméterként adhat át egy metódust anélkül, hogy explicit módon deklarálhat egy egyéni delegáltat. A beágyazott metódusnak meg kell felelnie a meghatalmazott által definiált metódus-aláírásnak. Ez azt jelenti, hogy a beágyazott metódusnak egy paraméterrel kell rendelkeznie, amelyet érték alapján ad át, és nem ad vissza értéket. (C#-ban a metódusnak void kell visszaadnia. A Visual Basic a Sub... End Sub szerkezet. Olyan metódus is lehet, amely figyelmen kívül hagyott értéket ad vissza.) Általában egy ilyen metódust használnak egy művelet végrehajtásához.

Note

Ha egy olyan metódusra szeretne hivatkozni, amely egy paramétert tartalmaz, és értéket ad vissza, használja inkább az általános Func<T,TResult> delegáltat.

Ha a Action<T> delegáltat használja, nem kell explicit módon definiálnia egy olyan meghatalmazottat, amely egyetlen paraméterrel foglal magában egy metódust. Az alábbi kód például explicit módon deklarál egy elnevezett DisplayMessage meghatalmazottat, és egy hivatkozást rendel a WriteLine metódushoz vagy a metódushoz a ShowWindowsMessage meghatalmazott példányához.

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

Az alábbi példa leegyszerűsíti ezt a kódot úgy, hogy a Action<T> delegáltat példányosít egy új delegált explicit meghatározása és egy névvel ellátott metódus hozzárendelése helyett.

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

A delegáltat Action<T> névtelen metódusokkal is használhatja a C#-ban, ahogy az alábbi példa is mutatja. (A névtelen metódusok bemutatása: Névtelen metódusok.)

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

Lambda-kifejezést is hozzárendelhet egy Action<T> delegált példányhoz, ahogy azt az alábbi példa szemlélteti. (A lambdakifejezések bemutatása: 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

Az ForEach egyes metódusok és ForEach metódusok egy-egy Action<T> delegáltat vesznek fel paraméterként. A meghatalmazott által befoglalt metódus lehetővé teszi, hogy műveletet hajtson végre a tömb vagy lista minden elemén. A példa a metódust használja illusztrációként ForEach .

Bővítő metódusok

Name	Description
GetMethodInfo(Delegate)	Lekéri a megadott meghatalmazott által képviselt metódust képviselő objektumot.

Lásd még

• Func<T,TResult>