O tipo de dado delegate Action encapsula uma referência a um método podendo ter parâmetros e não possui retorno.

O delegate Action utiliza generics, pode conter até 16 parâmetros e podemos utilizar o seu contrutor padrão para instanciar um objeto Action.

Com o delegate Action, podemos utilizar expressões lambda para declarar métodos anônimos.

Para utilizar Func precisamos adicionar o namespace System.

Para declarmos uma Func nos baseamos na sintaxe 1 abaixo. A sintaxe 2 mostra a atribuição de um método à uma variável Action.

Sintaxe 1

public delegate void Action()

Sintaxe 2

Action nome_action = nome_metodo;
Action nome_action = new Action(nome_metodo);

Exemplo 1

using System;
public class Program
{
    public static void Print() //static Main
    {
        //omitido
    }
    
    public static void Main(string[] args)
    {
        //Atribuição de método
        Action minhaAction = Print;
        minhaAction = new Action(Print);
    }
}

Saída

-

Como mencionado anteriormente, um delegate Action pode conter até 16 parâmetros utilizando generics. O uso das palavras reservadas ref e out, vistas nos conceitos de passagem por valor e referência em C# POO: Métodos, também podem ser utilizados.

Sintaxe 1

public delegate void Action<T1,T2,...,T16>(T1 obj1, T2 obj, TN objN)

Sintaxe 2

Action<T1,T2,...,T16> nome_action = nome_metodo;
Action<T1,T2,...,T16> nome_action = new Action<T1,T2,...,T16>(nome_metodo);

Exemplo 2

using System;

public class Program
{
    public static void Print(string msg) //static Main
    {
        Console.WriteLine(msg);
    }
    
    public static void Main(string[] args)
    {
        Action<string> minhaAction = Print;
        minhaAction("Action em C#");
        minhaAction = new Action<string>(Print);
    }
}

Saída

Action em C#

Assim como Delegate, C# também permite que um Action seja utilizado como parâmetro de um método. Abaixo a sintaxe que mostra o que foi discutido:

Sintaxe

modificador_acesso tipo_retorno nome_metodo(Action<T1,TN> nome_parametro)
{
    //corpo
}

Exemplo 3

using System;

public class Program
{
    public static void Print(string msg) //static Main
    {
        Console.WriteLine(msg);
    }
    
    public static void Metodo(Action<string> Print, string msg)
    {
        Print(msg);
    }
    
    public static void Main(string[] args)
    {
        Action<string> minhaAction = Print;
        Metodo(Print,"Action como parametro");
    }
}

Saída

Action como parametro

Outra forma de utilizar Action é para a criação de métodos anônimos. Esses possuem as mesma características em relação ao uso de um ou mais parâmetros e também o uso de ref e out.

Um método anônimo não possui nome, mas precisa utilizar a palavra reservada delegate como mostrado na sintaxe abaixo:

Sintaxe

Action<T1,T2,...,T16> = delegate(T1 obj1, T2 obj, TN objN) 
{ 
   //corpo
}

Exemplo 4

using System;

public class Program
{
    public static void Main(string[] args)
    {
        Action<string> minhaAction = delegate(string msg) 
        {
            Console.WriteLine(msg);
        };
        minhaAction("Metodo anonimo com Action");
    }
}

Saída

Metodo anonimo com Action

Com Action podemos declarar métodos anônimos utilizando expressão lambda como no exemplos abaixo mostrado.

Exemplo 5

using System;

public class Program
{ 
    public static void Main(string[] args)
    {
        Action<string> minhaAction = (msg) => Console.WriteLine(msg);
        minhaAction("Action com lambda");
    }
}

Saída

Action com lambda

É válido lembra que expressões lambda podem acessar variáveis e objetos em um escopo superior da qual foi declarada.

Os métodos anônimos com Action também podem ser utilizados como parâmetro de métodos. Abaixo a sintaxe que mostra a declaração de um método que recebe um método anônimo como argumento:

Sintaxe: Declaração

modificador_acesso tipo_retorno nome_metodo(Action<T1,TN> nome_parametro);

Sintaxe: Uso

nome_metodo(metodo_action, lista_parametros);

Exemplo 6

using System;

public class Program
{   
    public static void Main(string[] args)
    {
       Metodo((msg) => Console.WriteLine(msg),"metodo anonimo como parametro via lambda");
       
       Metodo(delegate(string msg){
           Console.WriteLine(msg);
       }
       , "metodo anonimo como parametro via delegate");
    }
}

Saída

metodo anonimo como parametro via lambda
metodo anonimo como parametro via delegate

De forma semelhante a Predicate, podemos também declarar arrays de Action. A atribuição de métodos aos elementos de um array é feita utilizando a posição/índice passado como argumento para o indexador [].

Sintaxe: Declaração

modificador_acesso Action<T1,TN>[] nome_array; //atributo
Action<T1,TN>[] nome_array[]; 

Sintaxe: Atribuição

Action<T1,TN>[] nome_variavel_array[] = { nome_metodo1, nome_metodo2, nome_metodoN }; //iniciado
nome_array[indice] = nome_metodo; //atribuição

Sintaxe: Uso

nome_array[indice](lista_argumentos)

Exemplo 7

using System;
public class Program
{
    //static Main
    public static void Metodo1(){ Console.WriteLine("Metodo1");}
    public static void Metodo2(){ Console.WriteLine("Metodo2");}
    public static void Metodo3(){ Console.WriteLine("Metodo3");}

	public static void Main()
	{
        Action[] vetorAction = { Metodo1, Metodo2, Metodo3};
        vetorAction[0]();
        vetorAction[1]();
        vetorAction[2]();
	}
}

Saída

Metodo1
Metodo2
Metodo3

1. 11/10/2024 - revisão 1 - Correção: Sintaxes; Ajustes pontuais
2. 22/03/2024 - versão inicial