Action<T> Gedelegeerde

Definitie

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

public delegate void Action<in T>(T obj);

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

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)

Type parameters

Parameters

Voorbeelden

In het volgende voorbeeld ziet u hoe de gedelegeerde de Action<T> inhoud van een List<T> object afdrukt. In dit voorbeeld wordt de Print methode gebruikt om de inhoud van de lijst weer te geven aan de console. Daarnaast toont het C#-voorbeeld ook het gebruik van anonieme methoden om de inhoud weer te geven aan de console. Houd er rekening mee dat in het voorbeeld niet expliciet een Action<T> variabele wordt gede declareren. In plaats daarvan wordt een verwijzing doorgegeven aan een methode die één parameter gebruikt en die geen waarde retourneert aan de List<T>.ForEach methode, waarvan één parameter een Action<T> gemachtigde is. Op dezelfde manier wordt in het C#-voorbeeld een Action<T> gemachtigde niet expliciet geïnstantieerd omdat de handtekening van de anonieme methode overeenkomt met de handtekening van de Action<T> gemachtigde die door de List<T>.ForEach methode wordt verwacht.

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

Opmerkingen

U kunt de Action<T> gemachtigde gebruiken om een methode als parameter door te geven zonder expliciet een aangepaste gemachtigde te declareren. De ingekapselde methode moet overeenkomen met de methodehandtekening die door deze gemachtigde is gedefinieerd. Dit betekent dat de ingekapselde methode één parameter moet hebben die aan de methode wordt doorgegeven op waarde en dat er geen waarde mag worden geretourneerd. (In C# moet de methode void retourneren. In Visual Basic moet deze worden gedefinieerd door de Sub... End Sub constructie. Het kan ook een methode zijn die een waarde retourneert die wordt genegeerd.) Normaal gesproken wordt een dergelijke methode gebruikt om een bewerking uit te voeren.

Wanneer u de Action<T> gemachtigde gebruikt, hoeft u niet expliciet een gemachtigde te definiëren die een methode inkapselt met één parameter. De volgende code declareert bijvoorbeeld expliciet een gemachtigde met de naam DisplayMessage en wijst een verwijzing toe aan de WriteLine methode of de methode aan het ShowWindowsMessage gemachtigde exemplaar.

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

In het volgende voorbeeld wordt deze code vereenvoudigd door de Action<T> gemachtigde te instantiëren in plaats van expliciet een nieuwe gemachtigde te definiëren en er een benoemde methode aan toe te wijzen.

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

U kunt de Action<T> gemachtigde ook gebruiken met anonieme methoden in C#, zoals in het volgende voorbeeld wordt geïllustreerd. (Zie Anonieme methoden voor een inleiding tot anonieme 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);
   }
}

U kunt ook een lambda-expressie toewijzen aan een Action<T> gemachtigde instantie, zoals in het volgende voorbeeld wordt geïllustreerd. (Zie Lambda-expressies voor een inleiding tot lambda-expressies.)

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

De ForEach en ForEach methoden nemen elk een Action<T> gemachtigde als parameter. Met de methode die door de gemachtigde wordt ingekapseld, kunt u een actie uitvoeren op elk element in de matrix of lijst. In het voorbeeld wordt de ForEach methode gebruikt om een afbeelding te bieden.

Zie ook

• Func<T,TResult>