Action<T> Delegato

Definizione

Spazio dei nomi:

System

Assembly:

netstandard.dll, System.Runtime.dll

Incapsula un metodo che presenta un singolo parametro e non restituisce alcun valore.

C#

public delegate void Action<in T>(T obj);

Parametri di tipo

T

Tipo del parametro del metodo incapsulato da questo delegato.

Questo parametro di tipo è controvariante, ovvero puoi usare il tipo specificato o qualsiasi tipo meno derivato. Per altre informazioni sulla covarianza e la controvarianza, vedi Covarianza e controvarianza nei generics.

Parametri

obj

T

Parametro del metodo incapsulato da questo delegato.

Esempio

Nell'esempio seguente viene illustrato l'uso del Action<T> delegato per stampare il contenuto di un List<T> oggetto . In questo esempio, il Print metodo viene usato per visualizzare il contenuto dell'elenco nella console. Inoltre, l'esempio C# illustra anche l'uso di metodi anonimi per visualizzare il contenuto nella console. Si noti che l'esempio non dichiara in modo esplicito una Action<T> variabile. Passa invece un riferimento a un metodo che accetta un singolo parametro e che non restituisce un valore al metodo, il List<T>.ForEach cui singolo parametro è un Action<T> delegato. Analogamente, nell'esempio C# un Action<T> delegato non viene creata in modo esplicito perché la firma del metodo anonimo corrisponde alla firma del Action<T> delegato previsto dal List<T>.ForEach metodo .

C#

List<string> names = new List<string>();
names.Add("Bruce");
names.Add("Alfred");
names.Add("Tim");
names.Add("Richard");

// Display the contents of the list using the Print method.
names.ForEach(Print);

// The following demonstrates the anonymous method feature of C#
// to display the contents of the list to the console.
names.ForEach(delegate(string name)
{
    Console.WriteLine(name);
});

void Print(string s)
{
    Console.WriteLine(s);
}

/* This code will produce output similar to the following:
* Bruce
* Alfred
* Tim
* Richard
* Bruce
* Alfred
* Tim
* Richard
*/

Commenti

È possibile usare il Action<T> delegato per passare un metodo come parametro senza dichiarare esplicitamente un delegato personalizzato. Il metodo incapsulato deve corrispondere alla firma del metodo definita da questo delegato. Ciò significa che il metodo incapsulato deve avere un parametro passato per valore e non deve restituire un valore. (In C#, il metodo deve restituire void. In Visual Basic, deve essere definito dal costrutto Sub...End Sub . Può anche essere un metodo che restituisce un valore ignorato. In genere, tale metodo viene usato per eseguire un'operazione.

Nota

Per fare riferimento a un metodo con un parametro e restituisce un valore, usare invece il delegato generico Func<T,TResult> .

Quando si usa il Action<T> delegato, non è necessario definire in modo esplicito un delegato che incapsula un metodo con un singolo parametro. Ad esempio, il codice seguente dichiara in modo esplicito un delegato denominato DisplayMessage e assegna un riferimento al WriteLine metodo o al metodo all'istanza ShowWindowsMessage del delegato.

C#

using System;
using System.Windows.Forms;

delegate void DisplayMessage(string message);

public class TestCustomDelegate
{
   public static void Main()
   {
      DisplayMessage messageTarget;

      if (Environment.GetCommandLineArgs().Length > 1)
         messageTarget = ShowWindowsMessage;
      else
         messageTarget = Console.WriteLine;

      messageTarget("Hello, World!");
   }

   private static void ShowWindowsMessage(string message)
   {
      MessageBox.Show(message);
   }
}

L'esempio seguente semplifica questo codice creando un'istanza del Action<T> delegato anziché definendo in modo esplicito un nuovo delegato e assegnando un metodo denominato.

C#

using System;
using System.Windows.Forms;

public class TestAction1
{
   public static void Main()
   {
      Action<string> messageTarget;

      if (Environment.GetCommandLineArgs().Length > 1)
         messageTarget = ShowWindowsMessage;
      else
         messageTarget = Console.WriteLine;

      messageTarget("Hello, World!");
   }

   private static void ShowWindowsMessage(string message)
   {
      MessageBox.Show(message);
   }
}

È anche possibile usare il Action<T> delegato con metodi anonimi in C#, come illustrato nell'esempio seguente. Per un'introduzione ai metodi anonimi, vedere Metodi anonimi.

C#

using System;
using System.Windows.Forms;

public class TestAnonMethod
{
   public static void Main()
   {
      Action<string> messageTarget;

      if (Environment.GetCommandLineArgs().Length > 1)
         messageTarget = delegate(string s) { ShowWindowsMessage(s); };
      else
         messageTarget = delegate(string s) { Console.WriteLine(s); };

      messageTarget("Hello, World!");
   }

   private static void ShowWindowsMessage(string message)
   {
      MessageBox.Show(message);
   }
}

È anche possibile assegnare un'espressione lambda a un'istanza Action<T> del delegato, come illustrato nell'esempio seguente. Per un'introduzione alle espressioni lambda, vedere Espressioni lambda.

C#

using System;
using System.Windows.Forms;

public class TestLambdaExpression
{
   public static void Main()
   {
      Action<string> messageTarget;

      if (Environment.GetCommandLineArgs().Length > 1)
         messageTarget = s => ShowWindowsMessage(s);
      else
         messageTarget = s => Console.WriteLine(s);

      messageTarget("Hello, World!");
   }

   private static void ShowWindowsMessage(string message)
   {
      MessageBox.Show(message);
   }
}

I ForEach metodi e ForEach accettano ogni Action<T> delegato come parametro. Il metodo incapsulato dal delegato consente di eseguire un'azione su ogni elemento nella matrice o nell'elenco. Nell'esempio viene utilizzato il ForEach metodo per fornire un'illustrazione.

Metodi di estensione

GetMethodInfo(Delegate)

Ottiene un oggetto che rappresenta il metodo rappresentato dal delegato specificato.

Si applica a

Vedi anche

• Func<T,TResult>