다음을 통해 공유

Action<T1,T2,T3> 대리자

  • 참조

정의

네임스페이스:
System
어셈블리:
System.Runtime.dll
어셈블리:
System.Core.dll
어셈블리:
mscorlib.dll
어셈블리:
netstandard.dll

세 개의 매개 변수가 있고 값을 반환하지 않는 메서드를 캡슐화합니다.

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)

형식 매개 변수

T1

이 대리자가 캡슐화하는 메서드의 첫 번째 매개 변수 형식입니다.

이 형식 매개 변수는 반공변(Contravariant)입니다. 즉, 지정한 형식이나 더 적게 파생된 모든 형식을 사용할 수 있습니다. 공변성(Covariance) 및 반공변성(Contravariance)에 대한 자세한 내용은 제네릭의 공변성(Covariance) 및 반공변성(Contravariance)을 참조하세요.
T2

이 대리자가 캡슐화하는 메서드의 두 번째 매개 변수 형식입니다.

이 형식 매개 변수는 반공변(Contravariant)입니다. 즉, 지정한 형식이나 더 적게 파생된 모든 형식을 사용할 수 있습니다. 공변성(Covariance) 및 반공변성(Contravariance)에 대한 자세한 내용은 제네릭의 공변성(Covariance) 및 반공변성(Contravariance)을 참조하세요.
T3

이 대리자가 캡슐화하는 메서드의 세 번째 매개 변수 형식입니다.

이 형식 매개 변수는 반공변(Contravariant)입니다. 즉, 지정한 형식이나 더 적게 파생된 모든 형식을 사용할 수 있습니다. 공변성(Covariance) 및 반공변성(Contravariance)에 대한 자세한 내용은 제네릭의 공변성(Covariance) 및 반공변성(Contravariance)을 참조하세요.

매개 변수

arg1
T1

이 대리자가 캡슐화하는 메서드의 첫 번째 매개 변수입니다.

arg2
T2

이 대리자가 캡슐화하는 메서드의 두 번째 매개 변수입니다.

arg3
T3

이 대리자가 캡슐화하는 메서드의 세 번째 매개 변수입니다.

설명

Action<T1,T2,T3> 대리자를 사용하여 사용자 지정 대리자를 명시적으로 선언하지 않고 메서드를 매개 변수로 전달할 수 있습니다. 캡슐화된 메서드는 이 대리자가 정의한 메서드 서명에 해당해야 합니다. 즉, 캡슐화된 메서드에는 값으로 전달되는 세 개의 매개 변수가 있어야 하며 값을 반환해서는 안 됩니다. (C#에서 메서드는 void반환해야 합니다. F#에서 메서드 또는 함수는 단위를 반환해야 합니다. Visual Basic에서는 Sub...End Sub 구문으로 정의해야 합니다. 무시되는 값을 반환하는 메서드일 수도 있습니다.) 일반적으로 이러한 메서드는 작업을 수행하는 데 사용됩니다.

메모

세 개의 매개 변수가 있고 값을 반환하는 메서드를 참조하려면 제네릭 Func<T1,T2,T3,TResult> 대리자를 대신 사용합니다.

Action<T1,T2,T3> 대리자를 사용하는 경우 세 개의 매개 변수로 메서드를 캡슐화하는 대리자를 명시적으로 정의할 필요가 없습니다. 예를 들어 다음 코드는 StringCopy 대리자를 명시적으로 선언하고 CopyStrings 메서드에 대한 참조를 해당 대리자 인스턴스에 할당합니다.

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

다음 예제에서는 새 대리자를 명시적으로 정의하고 명명된 메서드를 할당하는 대신 Action<T1,T2,T3> 대리자를 인스턴스화하여 이 코드를 간소화합니다.

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

다음 예제와 같이 C#에서 익명 메서드와 함께 Action<T1,T2,T3> 대리자를 사용할 수도 있습니다. (익명 메서드에 대한 소개는익명 메서드를 참조하세요.)

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

다음 예제와 같이 Action<T1,T2,T3> 대리자 인스턴스에 람다 식을 할당할 수도 있습니다. (람다 식에 대한 소개는 람다 식(C#) 또는 람다 식(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

확장 메서드

GetMethodInfo(Delegate)

지정된 대리자가 나타내는 메서드를 나타내는 개체를 가져옵니다.

적용 대상

추가 정보