Action<T1,T2,T3,T4> Delegera

Definition

Namnområde:: System

Sammansättningar:: mscorlib.dll, System.Runtime.dll

Sammansättningar:: netstandard.dll, System.Runtime.dll

Sammansättning:: System.Runtime.dll

Sammansättning:: System.Core.dll

Sammansättning:: mscorlib.dll

Sammansättning:: netstandard.dll

Källa:: Action.cs

Källa:: Action.cs

Källa:: FormatException.cs

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Kapslar in en metod som har fyra parametrar och inte returnerar ett värde.

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<in T1,in T2,in T3,in T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4) where T1 : allows ref struct where T2 : allows ref struct where T3 : allows ref struct where T4 : allows ref struct;

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)

Typparametrar

T1

Typen av den första parametern för metoden som det här ombudet kapslar in.

Det här är en contravariant-typparameter. Det innebär att du kan använda antingen den typ du angett eller en typ som inte är lika härledd. Mer information om kovarians och kontravarians finns i Kovarians och kontravarians i Generisk typ.

T2

Typen av den andra parametern för metoden som det här ombudet kapslar in.

T3

Typen av den tredje parametern för metoden som det här ombudet kapslar in.

T4

Typen av den fjärde parametern för metoden som det här ombudet kapslar in.

Parametrar

arg1: T1

Den första parametern för metoden som det här ombudet kapslar in.

arg2: T2

Den andra parametern för metoden som det här ombudet kapslar in.

arg3: T3

Den tredje parametern för metoden som det här ombudet kapslar in.

arg4: T4

Den fjärde parametern för metoden som det här ombudet kapslar in.

Kommentarer

Du kan använda ombudet Action<T1,T2,T3,T4> för att skicka en metod som en parameter utan att uttryckligen deklarera ett anpassat ombud. Den inkapslade metoden måste motsvara den metodsignatur som definieras av det här ombudet. Det innebär att den inkapslade metoden måste ha fyra parametrar som alla skickas till den med värde, och den får inte returnera ett värde. (I C#måste metoden returnera void. I F#måste metoden eller funktionen returnera enheten. I Visual Basic måste den definieras av Sub... End Sub konstruktion. Det kan också vara en metod som returnerar ett värde som ignoreras.) Vanligtvis används en sådan metod för att utföra en åtgärd.

Note

Om du vill referera till en metod som har fyra parametrar och returnerar ett värde använder du det allmänna Func<T1,T2,T3,T4,TResult> ombudet i stället.

När du använder ombudet Action<T1,T2,T3,T4> behöver du inte uttryckligen definiera ett ombud som kapslar in en metod med fyra parametrar. Följande kod deklarerar till exempel uttryckligen ett ombud med namnet StringCopy och tilldelar en referens till CopyStrings metoden till dess delegatinstans.

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

        Console.WriteLine();
        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] = 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 RunIt()
        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)

        Console.WriteLine()
        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 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) = source(ctr)
        Next
   End Sub
End Module

Följande exempel förenklar den här koden genom att instansiera ombudet i stället för att uttryckligen definiera ett nytt ombud och tilldela en namngiven Action<T1,T2,T3,T4> metod till den.

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

        Console.WriteLine();
        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] = 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 RunIt()
        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)

        Console.WriteLine()
        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 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) = source(ctr)
        Next
   End Sub
End Module

Du kan också använda ombudet Action<T1,T2,T3,T4> med anonyma metoder i C#, vilket visas i följande exempel. (En introduktion till anonyma metoder finns i Anonyma metoder.)

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

        Console.WriteLine();
        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] = source[ctr];
    }
}

Du kan också tilldela ett lambda-uttryck till en Action<T1,T2,T3,T4> delegatinstans, vilket visas i följande exempel. (En introduktion till lambda-uttryck finns i Lambda-uttryck (C#) eller Lambda-uttryck (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);

        Console.WriteLine();
        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] = 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 RunIt()
        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)

        Console.WriteLine()
        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) = source(ctr)
        Next
        Return number
    End Function
End Module

' The example displays the following output:
'       Fourth
'       Fifth
'       Sixth
'       Seventh
'       Eighth

Tilläggsmetoder

Name	Description
GetMethodInfo(Delegate)	Hämtar ett objekt som representerar den metod som representeras av det angivna ombudet.

Gäller för

Se även

Func<T1,T2,T3,T4,TResult>

Feedback

Var den här sidan till hjälp?