Action<T1,T2,T3> Delegát

Reference

Definice

Obor názvů:: System

Sestavení:: System.Runtime.dll

Sestavení:: System.Core.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Zapouzdřuje metodu, která má tři parametry a nevrací hodnotu.

generic <typename T1, typename T2, typename T3>
public delegate void Action(T1 arg1, T2 arg2, T3 arg3);

public delegate void Action<in T1,in T2,in T3>(T1 arg1, T2 arg2, T3 arg3);

public delegate void Action<T1,T2,T3>(T1 arg1, T2 arg2, T3 arg3);

type Action<'T1, 'T2, 'T3> = delegate of 'T1 * 'T2 * 'T3 -> unit

Public Delegate Sub Action(Of In T1, In T2, In T3)(arg1 As T1, arg2 As T2, arg3 As T3)

Public Delegate Sub Action(Of T1, T2, T3)(arg1 As T1, arg2 As T2, arg3 As T3)

Parametry typu

T1

Typ prvního parametru metody, kterou tento delegát zapouzdřuje.

Tento parametr typu je kontravariantní. To znamená, že můžete použít buď zadaný typ, nebo libovolný typ, který je méně odvozený. Další informace o kovarianci a kontravarianci najdete v tématu popisujícím kovarianci a kontravarianci u parametrického polymorfismu.

T2

Typ druhého parametru metody, který tento delegát zapouzdřuje.

T3

Typ třetího parametru metody, kterou tento delegát zapouzdřuje.

Parametry

arg1: T1

První parametr metody, kterou tento delegát zapouzdřuje.

arg2: T2

Druhý parametr metody, kterou tento delegát zapouzdřuje.

arg3: T3

Třetí parametr metody, kterou tento delegát zapouzdřuje.

Poznámky

Pomocí Action<T1,T2,T3> delegáta můžete předat metodu jako parametr bez explicitního deklarování vlastního delegáta. Zapouzdřená metoda musí odpovídat podpisu metody definovanému tímto delegátem. To znamená, že zapouzdřená metoda musí mít tři parametry, které jsou do ní předány hodnotou, a nesmí vracet hodnotu. (V jazyce C# musí metoda vrátit void. V jazyce F# musí metoda nebo funkce vracet jednotku. V jazyce Visual Basic musí být definována konstruktorem Sub...End Sub. Může to být také metoda, která vrací hodnotu, která je ignorována.) Obvykle se taková metoda používá k provedení operace.

Poznámka

Pokud chcete odkazovat na metodu, která má tři parametry a vrací hodnotu, použijte místo toho obecný Func<T1,T2,T3,TResult> delegáta.

Když použijete Action<T1,T2,T3> delegáta, nemusíte explicitně definovat delegáta, který zapouzdřuje metodu se třemi parametry. Následující kód například explicitně deklaruje delegáta s názvem StringCopy a přiřadí odkaz na metodu CopyStrings jeho instanci delegáta.

using System;

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

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

    private static void CopyStrings(string[] source, string[] target, int startPos)
    {
        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 <= source.Length - 1; ctr++)
            target[ctr] = source[ctr];
    }
}

open System

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

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

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

let ordinals = [| "First"; "Second"; "Third"; "Fourth"; "Fifth" |]
let copiedOrdinals: string [] = Array.zeroCreate ordinals.Length

let copyOperation = StringCopy copyStrings

copyOperation.Invoke(ordinals, copiedOrdinals, 3)

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)

Module TestDelegate
    Public Sub RunIt()
        Dim ordinals() As String = {"First", "Second", "Third", "Fourth", "Fifth"}
        Dim copiedOrdinals(ordinals.Length - 1) As String
        Dim copyOperation As StringCopy = AddressOf CopyStrings
        copyOperation(ordinals, copiedOrdinals, 3)
        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)
        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 source.Length - 1
            target(ctr) = source(ctr)
        Next
    End Sub
End Module

Následující příklad tento kód zjednodušuje vytvořením instance Action<T1,T2,T3> delegáta místo explicitního definování nového delegáta a přiřazení pojmenované metody k němu.

using System;

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

    private static void CopyStrings(string[] source, string[] target, int startPos)
    {
        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 <= source.Length - 1; ctr++)
            target[ctr] = source[ctr];
    }
}

open System

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

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

let ordinals = [| "First"; "Second"; "Third"; "Fourth"; "Fifth" |]
let copiedOrdinals = Array.zeroCreate<string> ordinals.Length

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

copyOperation.Invoke(ordinals, copiedOrdinals, 3)

for ordinal in copiedOrdinals do
    printfn "%s" (if String.IsNullOrEmpty ordinal then "<None>" else ordinal)

Module TestAction3
    Public Sub RunIt()
        Dim ordinals() As String = {"First", "Second", "Third", "Fourth", "Fifth"}
        Dim copiedOrdinals(ordinals.Length - 1) As String
        Dim copyOperation As Action(Of String(), String(), Integer) = AddressOf CopyStrings
        copyOperation(ordinals, copiedOrdinals, 3)
        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)
        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 source.Length - 1
            target(ctr) = source(ctr)
        Next
    End Sub
End Module

Můžete také použít Action<T1,T2,T3> delegát s anonymními metodami v jazyce C#, jak je znázorněno v následujícím příkladu. (Úvod do anonymních metod najdete v tématu anonymní metody.)

using System;

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

    private static void CopyStrings(string[] source, string[] target, int startPos)
    {
        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 <= source.Length - 1; ctr++)
            target[ctr] = source[ctr];
    }
}

Výraz lambda můžete také přiřadit instanci delegáta Action<T1,T2,T3>, jak ukazuje následující příklad. (Úvod k výrazům lambda najdete v tématu výrazy lambda (C#) nebo výrazy lambda (F#).)

using System;

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

    private static void CopyStrings(string[] source, string[] target, int startPos)
    {
        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 <= source.Length - 1; ctr++)
            target[ctr] = source[ctr];
    }
}

open System

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

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

let ordinals = [| "First"; "Second"; "Third"; "Fourth"; "Fifth" |]
let copiedOrdinals: string [] = Array.zeroCreate ordinals.Length

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

copyOperation.Invoke(ordinals, copiedOrdinals, 3)

for ordinal in copiedOrdinals do
    printfn "%s" (if String.IsNullOrEmpty ordinal then "<None>" else ordinal)

Public Module TestLambda
    Public Sub RunIt()
        Dim ordinals() As String = {"First", "Second", "Third", "Fourth", "Fifth"}
        Dim copiedOrdinals(ordinals.Length - 1) As String
        Dim copyOperation As Action(Of String(), String(), Integer) =
                           Sub(s1, s2, pos) CopyStrings(s1, s2, pos)
        copyOperation(ordinals, copiedOrdinals, 3)
        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) 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 source.Length - 1
            target(ctr) = source(ctr)
        Next
        Return source.Length - startPos
    End Function
End Module

' The example displays the following output:
'       Fourth
'       Fifth

Metody rozšíření

GetMethodInfo(Delegate)

Získá objekt, který představuje metodu reprezentovanou zadaným delegátem.

Platí pro

Viz také

Func<T1,T2,T3,TResult>

Sdílet prostřednictvím