Action<T1,T2,T3,T4> Temsilci

Başvuru

Tanım

Ad Alanı:: System

Bütünleştirilmiş Kod:: System.Runtime.dll

Bütünleştirilmiş Kod:: System.Core.dll

Bütünleştirilmiş Kod:: mscorlib.dll

Bütünleştirilmiş Kod:: netstandard.dll

Önemli

Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.

Dört parametresi olan ve değer döndürmeyen bir yöntemi kapsüller.

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)

Tür Parametreleri

T1

Bu temsilcinin kapsüllediğini yöntemin ilk parametresinin türü.

Bu genel tür parametresi kontravaryanttır. Bu, kendi belirttiğiniz türü veya daha az türetilmiş başka bir türü kullanabileceğiniz anlamına gelir. Kovaryans ve kontravaryans hakkında daha fazla bilgi için bkz. Genel Türlerde Kovaryans ve Kontravaryans.

T2

Bu temsilcinin kapsüllediğini yöntemin ikinci parametresinin türü.

T3

Bu temsilcinin kapsüllediğini yöntemin üçüncü parametresinin türü.

T4

Bu temsilcinin kapsüllediğini yöntemin dördüncü parametresinin türü.

Parametreler

arg1: T1

Bu temsilcinin kapsüllediğini yönteminin ilk parametresi.

arg2: T2

Bu temsilcinin kapsüllediğini yönteminin ikinci parametresi.

arg3: T3

Bu temsilcinin kapsüllediğini yönteminin üçüncü parametresi.

arg4: T4

Bu temsilcinin kapsüllediğini yönteminin dördüncü parametresi.

Açıklamalar

Özel temsilciyi Action<T1,T2,T3,T4> açıkça bildirmeden bir yöntemi parametre olarak geçirmek için temsilciyi kullanabilirsiniz. Kapsüllenen yöntem, bu temsilci tarafından tanımlanan yöntem imzasına karşılık olmalıdır. Bu, kapsüllenen yöntemin tümü değere göre geçirilen dört parametreye sahip olması ve değer döndürmemesi gerektiği anlamına gelir. (C# dilinde yöntemi döndürmelidir void. F# dilinde yöntemin veya işlevin birim döndürmesi gerekir. Visual Basic,Sub...End Sub Oluşturmak. Yoksayılan bir değer döndüren bir yöntem de olabilir.) Genellikle, böyle bir yöntem bir işlemi gerçekleştirmek için kullanılır.

Not

Dört parametresi olan ve değer döndüren bir yönteme başvurmak için bunun yerine genel Func<T1,T2,T3,T4,TResult> temsilciyi kullanın.

Temsilciyi Action<T1,T2,T3,T4> kullandığınızda, dört parametreli bir yöntemi kapsülleyen bir temsilciyi açıkça tanımlamanız gerekmez. Örneğin, aşağıdaki kod adlı StringCopy bir temsilciyi açıkça bildirir ve yöntemine CopyStrings temsilci örneğine bir başvuru atar.

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

Aşağıdaki örnek, yeni bir temsilciyi açıkça tanımlamak ve buna adlandırılmış bir yöntem atamak yerine temsilcinin Action<T1,T2,T3,T4> örneğini oluşturarak bu kodu basitleştirir.

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

Aşağıdaki örnekte gösterildiği gibi temsilciyi Action<T1,T2,T3,T4> C# dilinde anonim yöntemlerle de kullanabilirsiniz. (Anonim yöntemlere giriş için bkz . Anonim Yöntemler.)

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

Aşağıdaki örnekte gösterildiği gibi temsilci örneğe lambda Action<T1,T2,T3,T4> ifadesi de atayabilirsiniz. (Lambda ifadelerine giriş için bkz. Lambda İfadeleri (C#) veya Lambda İfadeleri (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

Uzantı Metotları

GetMethodInfo(Delegate)

Belirtilen temsilci tarafından temsil edilen yöntemi temsil eden bir nesnesi alır.

Şunlara uygulanır

Ayrıca bkz.

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

Aracılığıyla paylaş