Action(Of T1, T2, T3, T4) Delegate

Updated: October 2010

Encapsulates a method that has four parameters and does not return a value.

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

'Declaration
<TypeForwardedFromAttribute("System.Core, Version=2.0.5.0, Culture=Neutral, PublicKeyToken=7cec85d7bea7798e")> _
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 _
)

Type Parameters

In T1

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.

In T2

The type of the second parameter of the method that this delegate encapsulates.

In T3

The type of the third parameter of the method that this delegate encapsulates.

In T4

The type of the fourth 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.
arg4
Type: T4
The fourth parameter of the method that this delegate encapsulates.

You can use the Action(Of T1, T2, T3, T4) 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 four 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 SubEnd 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 four parameters and returns a value, use the generic Func(Of T1, T2, T3, T4, TResult) delegate instead.

When you use the Action(Of T1, T2, T3, T4) 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, _
                        ByVal numberToCopy As Integer)

Module Example
   Public Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)
      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
         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, ByVal 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


The following example simplifies this code by instantiating the Action(Of 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", "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
         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, ByVal 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


You can also use the Action(Of T1, T2, T3, T4) 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", 
                           "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)
         outputBlock.Text += String.Format("{0}\n", 
                             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]);
   }
}


You can also assign a lambda expression to an Action(Of T1, T2, T3, T4) delegate instance, as the following example illustrates.


Module Example
   Private outputBlock As System.Windows.Controls.TextBlock

   Public Sub Demo(ByVal outputBlock As System.Windows.Controls.TextBlock)

      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
            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, 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:
'       <None>
'       <None>
'       <None>
'       Fourth
'       Fifth
'       Sixth
'       Seventh
'       Eighth
'       <None>
'       <None>


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

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

Date

History

Reason

October 2010

Modified Visual Basic lambda expression to use Sub keyword.

Customer feedback.

Community Additions

ADD
Show: