Freigeben über


Action<T1,T2,T3,T4> Delegat

Definition

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

generic <typename T1, typename T2, typename T3, typename T4>
public delegate void Action(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
public delegate void Action<in T1,in T2,in T3,in T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
public delegate void Action<T1,T2,T3,T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
type Action<'T1, 'T2, 'T3, 'T4> = delegate of 'T1 * 'T2 * 'T3 * 'T4 -> unit
Public Delegate Sub Action(Of In T1, In T2, In T3, In T4)(arg1 As T1, arg2 As T2, arg3 As T3, arg4 As T4)
Public Delegate Sub Action(Of T1, T2, T3, T4)(arg1 As T1, arg2 As T2, arg3 As T3, arg4 As T4)

Typparameter

T1

Der Typ des ersten 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.
T2

Der Typ des zweiten 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.
T3

Der Typ des dritten 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.
T4

Der Typ des vierten 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

arg1
T1

Der erste Parameter der Methode, die dieser Delegat kapselt.

arg2
T2

Der zweite Parameter der Methode, die dieser Delegat kapselt.

arg3
T3

Der dritte Parameter der Methode, die dieser Delegat kapselt.

arg4
T4

Der vierte Parameter der Methode, die dieser Delegat kapselt.

Hinweise

Sie können die Action<T1,T2,T3,T4> Stellvertretung verwenden, um eine Methode als Parameter zu übergeben, ohne eine benutzerdefinierte Stellvertretung explizit zu deklarieren. Die gekapselte Methode muss der Von diesem Stellvertretung definierten Methodensignatur entsprechen. Dies bedeutet, dass die gekapselte Methode vier Parameter aufweisen muss, die alle nach Wert übergeben werden, und es darf keinen Wert zurückgeben. (In C#muss die Methode zurückgegeben werden void. In F#muss die Methode oder Funktion Einheit zurückgeben. In Visual Basic muss es durch die Sub...End Sub construct. 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 die generische Func<T1,T2,T3,T4,TResult> Stellvertretung, um auf eine Methode zu verweisen, die vier Parameter enthält und einen Wert zurückgibt.

Wenn Sie die Action<T1,T2,T3,T4> Stellvertretung verwenden, müssen Sie keine Stellvertretung explizit definieren, die eine Methode mit vier Parametern kapselt. Der folgende Code deklariert beispielsweise explizit einen Stellvertretungsnamen und weist der Methode einen Verweis auf die CopyStrings Stellvertretungsinstanz StringCopy zu.

using System;

delegate void StringCopy(string[] stringArray1,
                         string[] stringArray2,
                         int indexToStart,
                         int numberToCopy);

public class TestDelegate
{
   public static void Main()
   {
      string[] ordinals = {"First", "Second", "Third", "Fourth", "Fifth",
                           "Sixth", "Seventh", "Eighth", "Ninth", "Tenth"};
      string[] copiedOrdinals = new string[ordinals.Length];
      StringCopy copyOperation = CopyStrings;
      copyOperation(ordinals, copiedOrdinals, 3, 5);
      foreach (string ordinal in copiedOrdinals)
         Console.WriteLine(string.IsNullOrEmpty(ordinal) ? "<None>" : ordinal);
   }

   private static void CopyStrings(string[] source, string[] target,
                                   int startPos, int number)
   {
      if (source.Length != target.Length)
         throw new IndexOutOfRangeException("The source and target arrays must have the same number of elements.");

      for (int ctr = startPos; ctr <= startPos + number - 1; ctr++)
         target[ctr] = string.Copy(source[ctr]);
   }
}
open System

type StringCopy = delegate of stringArray1: string [] *
                              stringArray2: string [] *
                              indexToStart: int *
                              numberToCopy: int -> unit

let copyStrings (source: string []) (target: string []) startPos number =
    if source.Length <> target.Length then
        raise (IndexOutOfRangeException "The source and target arrays must have the same number of elements.")

    for i = startPos to startPos + number - 1 do
        target.[i] <- source.[i]

let ordinals =
    [| "First"; "Second"; "Third"; "Fourth"; "Fifth"
       "Sixth"; "Seventh"; "Eighth"; "Ninth"; "Tenth" |]

let copiedOrdinals: string [] = Array.zeroCreate ordinals.Length

let copyOperation = StringCopy copyStrings

copyOperation.Invoke(ordinals, copiedOrdinals, 3, 5)

for ordinal in copiedOrdinals do
    printfn "%s" (if String.IsNullOrEmpty ordinal then "<None>" else ordinal)
Delegate Sub StringCopy(stringArray1() As String, _
                        stringArray2() As String, _
                        indexToStart As Integer, _
                        numberToCopy As Integer)

Module TestDelegate
   Public Sub Main()
      Dim ordinals() As String = {"First", "Second", "Third", "Fourth", _
                                  "Fifth", "Sixth", "Seventh", "Eighth", _
                                  "Ninth", "Tenth"}
      Dim copiedOrdinals(ordinals.Length - 1) As String
      Dim copyOperation As StringCopy = AddressOf CopyStrings
      copyOperation(ordinals, copiedOrdinals, 3, 5)
      For Each ordinal As String In copiedOrdinals
         Console.WriteLine(ordinal)
      Next    
   End Sub
   
   Private Sub CopyStrings(source() As String, target() As String, _
                           startPos As Integer, number As Integer)
      If source.Length <> target.Length Then 
         Throw New IndexOutOfRangeException("The source and target arrays" & _
                   " must have the same number of elements.")
      End If
      For ctr As Integer = startPos to startpos + number  - 1
         target(ctr) = String.Copy(source(ctr))
      Next
   End Sub
End Module

Im folgenden Beispiel wird dieser Code vereinfacht, indem er die Stellvertretung instanziiert Action<T1,T2,T3,T4> , anstatt eine neue Stellvertretung explizit zu definieren und einer benannten Methode zuzuweisen.

using System;

public class TestAction4
{
   public static void Main()
   {
      string[] ordinals = {"First", "Second", "Third", "Fourth", "Fifth",
                           "Sixth", "Seventh", "Eighth", "Ninth", "Tenth"};
      string[] copiedOrdinals = new string[ordinals.Length];
      Action<string[], string[], int, int> copyOperation = CopyStrings;
      copyOperation(ordinals, copiedOrdinals, 3, 5);
      foreach (string ordinal in copiedOrdinals)
         Console.WriteLine(string.IsNullOrEmpty(ordinal) ? "<None>" : ordinal);
   }

   private static void CopyStrings(string[] source, string[] target,
                                   int startPos, int number)
   {
      if (source.Length != target.Length)
         throw new IndexOutOfRangeException("The source and target arrays must have the same number of elements.");

      for (int ctr = startPos; ctr <= startPos + number - 1; ctr++)
         target[ctr] = string.Copy(source[ctr]);
   }
}
open System

let copyStrings (source: string []) (target: string []) startPos number =
    if source.Length <> target.Length then
        raise (IndexOutOfRangeException "The source and target arrays must have the same number of elements.")

    for i = startPos to startPos + number - 1 do
        target.[i] <- source.[i]

let ordinals =
    [| "First"; "Second"; "Third"; "Fourth"; "Fifth"
       "Sixth"; "Seventh"; "Eighth"; "Ninth"; "Tenth" |]

let copiedOrdinals: string [] = Array.zeroCreate ordinals.Length

let copyOperation = Action<_, _, _, _> copyStrings

copyOperation.Invoke(ordinals, copiedOrdinals, 3, 5)

for ordinal in copiedOrdinals do
    printfn "%s" (if String.IsNullOrEmpty ordinal then "<None>" else ordinal)
Module TestAction4
   Public Sub Main()
      Dim ordinals() As String = {"First", "Second", "Third", "Fourth", _
                                  "Fifth", "Sixth", "Seventh", "Eighth", _
                                  "Ninth", "Tenth"}
      Dim copiedOrdinals(ordinals.Length - 1) As String
      Dim copyOperation As Action(Of String(), String(), Integer, Integer) = _
                           AddressOf CopyStrings
      copyOperation(ordinals, copiedOrdinals, 3, 5)
      For Each ordinal As String In copiedOrdinals
         Console.WriteLine(ordinal)
      Next    
   End Sub
   
   Private Sub CopyStrings(source() As String, target() As String, _
                           startPos As Integer, number As Integer)
      If source.Length <> target.Length Then 
         Throw New IndexOutOfRangeException("The source and target arrays" & _
                   " must have the same number of elements.")
      End If
      For ctr As Integer = startPos to startpos + number  - 1
         target(ctr) = String.Copy(source(ctr))
      Next
   End Sub
End Module

Sie können auch die Stellvertretung mit anonymen Methoden in C#verwenden, wie das Action<T1,T2,T3,T4> folgende Beispiel veranschaulicht. (Eine Einführung in anonyme Methoden finden Sie unter Anonyme Methoden.)

using System;

public class TestAnonymousMethod
{
   public static void Main()
   {
      string[] ordinals = {"First", "Second", "Third", "Fourth", "Fifth",
                           "Sixth", "Seventh", "Eighth", "Ninth", "Tenth"};
      string[] copiedOrdinals = new string[ordinals.Length];
      Action<string[], string[], int, int> copyOperation =
                                           delegate(string[] s1, string[] s2,
                                           int pos, int num)
                                { CopyStrings(s1, s2, pos, num); };
      copyOperation(ordinals, copiedOrdinals, 3, 5);
      foreach (string ordinal in copiedOrdinals)
         Console.WriteLine(string.IsNullOrEmpty(ordinal) ? "<None>" : ordinal);
   }

   private static void CopyStrings(string[] source, string[] target,
                                   int startPos, int number)
   {
      if (source.Length != target.Length)
         throw new IndexOutOfRangeException("The source and target arrays must have the same number of elements.");

      for (int ctr = startPos; ctr <= startPos + number - 1; ctr++)
         target[ctr] = string.Copy(source[ctr]);
   }
}

Sie können auch einem Action<T1,T2,T3,T4> Stellvertretungsinstanz einen Lambdaausdruck zuweisen, wie das folgende Beispiel veranschaulicht. (Eine Einführung in Lambda-Ausdrücke finden Sie unter Lambda-Ausdrücke (C#) oder Lambda-Ausdrücke (F#).)

using System;

public class TestLambdaExpression
{
   public static void Main()
   {
      string[] ordinals = {"First", "Second", "Third", "Fourth", "Fifth",
                           "Sixth", "Seventh", "Eighth", "Ninth", "Tenth"};
      string[] copiedOrdinals = new string[ordinals.Length];
      Action<string[], string[], int, int> copyOperation = (s1, s2, pos, num)
                                           => CopyStrings(s1, s2, pos, num);
      copyOperation(ordinals, copiedOrdinals, 3, 5);
      foreach (string ordinal in copiedOrdinals)
         Console.WriteLine(string.IsNullOrEmpty(ordinal) ? "<None>" : ordinal);
   }

   private static void CopyStrings(string[] source, string[] target,
                                   int startPos, int number)
   {
      if (source.Length != target.Length)
         throw new IndexOutOfRangeException("The source and target arrays must have the same number of elements.");

      for (int ctr = startPos; ctr <= startPos + number - 1; ctr++)
         target[ctr] = string.Copy(source[ctr]);
   }
}
open System

let copyStrings (source: string []) (target: string []) startPos number =
    if source.Length <> target.Length then
        raise (IndexOutOfRangeException "The source and target arrays must have the same number of elements.")

    for i = startPos to startPos + number - 1 do
        target.[i] <- source.[i]

let ordinals =
    [| "First"; "Second"; "Third"; "Fourth"; "Fifth"
       "Sixth"; "Seventh"; "Eighth"; "Ninth"; "Tenth" |]

let copiedOrdinals: string [] = Array.zeroCreate ordinals.Length

let copyOperation = Action<_, _, _, _> (fun s1 s2 pos num -> copyStrings s1 s2 pos num)

copyOperation.Invoke(ordinals, copiedOrdinals, 3, 5)

for ordinal in copiedOrdinals do
    printfn "%s" (if String.IsNullOrEmpty ordinal then "<None>" else ordinal)
Public Module TestLambdaExpression
   Public Sub Main()
      Dim ordinals() As String = {"First", "Second", "Third", "Fourth", "Fifth", _ 
                           "Sixth", "Seventh", "Eighth", "Ninth", "Tenth"}
      Dim copiedOrdinals(ordinals.Length - 1) As String           
      Dim copyOperation As Action(Of String(), String(), Integer, Integer) = _
                           Sub(s1, s2, pos, num) CopyStrings(s1, s2, pos, num)  
      copyOperation(ordinals, copiedOrdinals, 3, 5)
      For Each ordinal As String In copiedOrdinals
         If String.IsNullOrEmpty(ordinal) Then
            Console.WriteLine("<None>")
         Else
            Console.WriteLine(ordinal)
         End If
      Next   
   End Sub

   Private Function CopyStrings(source() As String, target() As String, _ 
                                startPos As Integer, number As Integer) As Integer
      If source.Length <> target.Length Then 
         throw new IndexOutOfRangeException("The source and target arrays must have the same number of elements.")
      End If
      
      For ctr As Integer = startPos To startPos + number - 1
         target(ctr) = String.Copy(source(ctr))
      Next
      Return number
   End Function
End Module
' The example displays the following output:
'       Fourth
'       Fifth
'       Sixth
'       Seventh
'       Eighth

Erweiterungsmethoden

GetMethodInfo(Delegate)

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

Gilt für

Siehe auch