Compartir a través de

  • Artículo

Action<T1, T2, T3> Delegate

Microsoft Silverlight will reach end of support after October 2021. Learn more.

Updated: October 2010

Encapsulates a method that takes three parameters and does not return a value.

Namespace:  System
Assembly:  mscorlib (in mscorlib.dll)

Syntax

'Declaration
<TypeForwardedFromAttribute("System.Core, Version=2.0.5.0, Culture=Neutral, PublicKeyToken=7cec85d7bea7798e")> _
Public Delegate Sub Action(Of In T1, In T2, In T3) ( _
    arg1 As T1, _
    arg2 As T2, _
    arg3 As T3 _
)

[TypeForwardedFromAttribute("System.Core, Version=2.0.5.0, Culture=Neutral, PublicKeyToken=7cec85d7bea7798e")]
public delegate void Action<in T1, in T2, in T3>(
    T1 arg1,
    T2 arg2,
    T3 arg3
)

Type Parameters

  • inT1
    The type of the first parameter of the method that this delegate encapsulates.

    This type parameter is contravariant. That is, you can use either the type you specified or any type that is less derived. For more information about covariance and contravariance, see 2678dc63-c7f9-4590-9ddc-0a4df684d42e.

  • inT2
    The type of the second parameter of the method that this delegate encapsulates.
  • inT3
    The type of the third parameter of the method that this delegate encapsulates.

Parameters

  • arg1
    Type: T1
    The first parameter of the method that this delegate encapsulates.
  • arg2
    Type: T2
    The second parameter of the method that this delegate encapsulates.
  • arg3
    Type: T3
    The third parameter of the method that this delegate encapsulates.

Remarks

You can use the Action<T1, T2, T3> delegate to pass a method as a parameter without explicitly declaring a custom delegate. The encapsulated method must correspond to the method signature that is defined by this delegate. This means that the encapsulated method must have three parameters that are all passed to it by value, and it must not return a value. (In C#, the method must return void. In Visual Basic, it must be defined by the Sub…End Sub construct. It can also be a method that returns a value that is ignored.) Typically, such a method is used to perform an operation.

NoteNote:

To reference a method that has three parameters and returns a value, use the generic Func<T1, T2, T3, TResult> delegate instead.

When you use the Action<T1, T2, T3> delegate, you do not have to explicitly define a delegate that encapsulates a method with two parameters. For example, the following code explicitly declares a delegate named StringCopy and assigns a reference to the CopyStrings method to its delegate instance.

Delegate Sub StringCopy(ByVal stringArray1() As String, _
                        ByVal stringArray2() As String, _
                        ByVal indexToStart As Integer)

Module Example
   Public Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)
      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
         outputBlock.Text &= CStr(IIf(String.IsNullOrEmpty(ordinal), "<None>", ordinal)) & vbCrLf
      Next
   End Sub

   Private Sub CopyStrings(ByVal source() As String, ByVal target() As String, ByVal 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) = String.Copy(source(ctr))
      Next
   End Sub
End Module

using System;

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

public class Example
{
   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      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)
         outputBlock.Text += String.Format("{0}\n", 
                             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] = String.Copy(source[ctr]);
   }

}

The following example simplifies this code by instantiating the Action<T1, T2, T3> delegate rather than explicitly defining a new delegate and assigning a named method to it.

Module Example
   Public Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)
      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
         outputBlock.Text &= CStr(IIf(String.IsNullOrEmpty(ordinal), "<None>", ordinal)) & vbCrLf
      Next
   End Sub

   Private Sub CopyStrings(ByVal source() As String, ByVal target() As String, ByVal 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) = String.Copy(source(ctr))
      Next
   End Sub
End Module

using System;

public class Example
{
   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      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)
         outputBlock.Text += String.Format("{0}\n", 
                             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] = String.Copy(source[ctr]);
   }
}

You can also use the Action<T1, T2, T3> delegate with anonymous methods in C#, as the following example illustrates.

using System;

public class Example
{
   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      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)
         outputBlock.Text += String.Format("{0}\n", 
                             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] = String.Copy(source[ctr]);
   }
}

You can also assign a lambda expression to an Action<T1, T2, T3> delegate instance, as the following example illustrates.

Module Example
   Public Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)
      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
            outputBlock.Text += "<None>" + vbCrLf
         Else
            outputBlock.Text += ordinal + vbCrLf
         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) = String.Copy(source(ctr))
      Next
      Return source.Length - startPos 
   End Function
End Module
' The example displays the following output:
'       <None>
'       <None>
'       <None>
'       Fourth
'       Fifth

using System;

public class Example
{
   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      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)
         outputBlock.Text += String.Format("{0}\n", 
                             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] = String.Copy(source[ctr]);
   }
}

Version Information

Silverlight

Supported in: 5, 4, 3

Silverlight for Windows Phone

Supported in: Windows Phone OS 7.1, Windows Phone OS 7.0

XNA Framework

Supported in: Xbox 360, Windows Phone OS 7.0

Platforms

For a list of the operating systems and browsers that are supported by Silverlight, see Supported Operating Systems and Browsers.

See Also

Reference

System Namespace

Change History

Date

History

Reason

October 2010

Modified Visual Basic lambda expression to use Sub keyword.

Customer feedback.