ASP.NET Tutorial: Use of Action Delegate in C# in Detail

The Action delegate type in C# represents a method that can be called, but as its return type is void, it does not produce a value. It can take in one or more parameters as input.

Action exists in the System namespace and can be accessed in multiple overloads to support varying numbers of parameters. It's commonly used to create event handlers, callbacks, and functions to pass as arguments.

Action Syntax

• No Parameters: An Action can be defined as a method that does not accept any parameters and returns no value.

  Action myAction = () => Console.WriteLine("Hello, World!");
  myAction();  // Output: Hello, World!

One or More Parameters: It is possible to create an Action that accepts one or more parameters while still returning no value.

Action<string> greetAction = (name) => Console.WriteLine($"Hello, {name}!");
greetAction("Alice");  // Output: Hello, Alice!

Action<int, int> addAction = (x, y) => Console.WriteLine(x + y);
addAction(5, 10);  // Output: 15

Key Features

• Absence of Return Value: In contrast to Func<T>, the Action delegate does not yield a return value; it consistently returns void.
• Capability for Multiple Parameters: Action<T1, T2, ..., T16> allows for the definition of a delegate that can accept as many as 16 parameters.
• Utilization of Anonymous Methods and Lambda Expressions: Action is frequently employed alongside lambda expressions or anonymous methods, promoting more succinct code.
• Application in Event Handlers: Action proves beneficial when it is necessary to transfer methods (including parameters), particularly for callbacks or event-handling scenarios.

Comparison with Func

• Action<T>: Used when the method returns void and can take zero or more parameters.
• Func<T, TResult>: Used when the method returns a value (TResult) and can take zero or more input parameters.

For example

• Func<int, int, int> could represent a method that takes two integers and returns an integer (like an addition function).
• Action<int, int> could represent a method that takes two integers and performs an action (like printing the sum), but doesn't return a value.

The appropriate context for utilizing Action

1. Action is a delegate type used for methods that don't return values.
2. It is useful for passing methods as parameters or defining callbacks.
3. You can use Action for methods with zero to 16 input parameters.

Examples of different types of Action delegates

• Action with No Parameters

  Action action = () => Console.WriteLine("Action with no parameters!");
  action();
  // Output: Action with no parameters!

Action with One Parameter

Action<string> printMessage = (message) => Console.WriteLine(message);
printMessage("Hello!");

// Output: Hello!

Action with Multiple Parameters

Action<int, int> multiplyNumbers = (a, b) => Console.WriteLine(a * b);
multiplyNumbers(4, 5);

// Output: 20

Passing Action as a Parameter to a Method: You can pass an Action as a method parameter to be executed later.

public void PerformAction(Action action)
{
    Console.WriteLine("Before action.");
    action();
    Console.WriteLine("After action.");
}
// Usage:
PerformAction(() => Console.WriteLine("Executing action..."));
// Output:
// Before action.
// Executing action...
// After action

Using Action with Event Handling

public class Button
{
    public Action Click { get; set; }

    public void OnClick()
    {
        Click?.Invoke(); // Invoke the Action if it's not null
    }
}
Button button = new Button();
button.Click = () => Console.WriteLine("Button clicked!");
button.OnClick();
// Output: Button clicked!

Execution of all previously mentioned actions within the application

Step 1. I have developed a WPF user interface, as illustrated below. You may select any application type that aligns with your specific requirements.

MainWindow.Xaml code

<Window
    x:Class="ActionDelegateExample.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    xmlns:local="clr-namespace:ActionDelegateExample"
    mc:Ignorable="d"
    Title="MainWindow"
    Height="450"
    Width="800">

    <Grid>
        <StackPanel Orientation="Vertical">
            <Button
                x:Name="BtnNoParameter"
                Content="Action with no Parameter"
                Click="BtnNoParameter_Click"
                Height="40"
                Margin="20"/>

            <Button
                x:Name="BtnWithSingleParameter"
                Content="Action with single Parameter"
                Click="BtnWithSingleParameter_Click"
                Height="40"
                Margin="20"/>

            <Button
                x:Name="BtnMultipleParameter"
                Content="Action with multiple Parameter"
                Click="BtnMultipleParameter_Click"
                Height="40"
                Margin="20"/>

            <Button
                x:Name="BtnCallbackParameter"
                Content="Action with call back"
                Click="BtnCallbackParameter_Click"
                Height="40"
                Margin="20"/>

            <Button
                x:Name="BtnCallEvenHandlingParameter"
                Content="Action with CallEvenHandling"
                Click="BtnCallEvenHandlingParameter_Click"
                Height="40"
                Margin="20"/>
        </StackPanel>
    </Grid>
</Window>

MainWindow.Xaml.cs code

using System.Windows;

namespace ActionDelegateExample
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            EventHandlerManager.OnEventRaised += EventHandlerManager_OnEventRaised;
        }
        private void EventHandlerManager_OnEventRaised()
        {
            MessageBox.Show("Event handled by Subscriber");
        }
        private void BtnNoParameter_Click(object sender, RoutedEventArgs e)
        {
            ActionMethods.NoParameterActionVariable();
        }
        private void BtnWithSingleParameter_Click(object sender, RoutedEventArgs e)
        {
            // Create a RequestMessage
            RequestMessageWithParameter message = new RequestMessageWithParameter
            {
                Content = "This is a single parameter request."
            };
            ActionMethods.ActionWithOneParameter(message);
        }
        private void BtnMultipleParameter_Click(object sender, RoutedEventArgs e)
        {
            // Create a RequestMessage
            RequestMessageWithParameter message = new RequestMessageWithParameter
            {
                Content = "This is a multiple parameter request."
            };

            // Invoke the Action with RequestMessage and an integer
            ActionMethods.ActionWithTwoParameters(message, 42);
        }
        private void BtnCallEvenHandlingParameter_Click(object sender, RoutedEventArgs e)
        {
            EventHandlerManager.RaiseOnEventRaised();
        }
        private void BtnCallbackParameter_Click(object sender, RoutedEventArgs e)
        {
            MessageHandler handler = new MessageHandler();

            // Define the callback action that will handle the RequestMessage after processing
            Action<RequestMessageWithParameter> callback = (request) =>
            {
                MessageBox.Show($"Callback executed. Message content: {request.Content}");
            };
            // Call the method with a message and the callback action
            handler.ProcessRequest("Hello, this is a sample request!", callback);
        }
    }
}

Step 2. Establish a class titled "ActionMethods.cs" as illustrated below. It has been used to define action delegates

using System.Windows;

namespace ActionDelegateExample
{
    public class ActionMethods
    {
        public static Action NoParameterActionVariable = () => NoParameterAction();
        private static void NoParameterAction()
        {
            MessageBox.Show("Action without parameters executed.");
        }
        // Action that accepts one parameter of type RequestMessage
        public static Action<RequestMessageWithParameter> ActionWithOneParameter = (request) =>
        {
            MessageBox.Show(request.Content);
        };
        // Action that accepts two parameters: RequestMessage and an integer
        public static Action<RequestMessageWithParameter, int> ActionWithTwoParameters = (request, count) =>
        {
            MessageBox.Show($"Action with two parameters executed. Message: {request.Content}, Count: {count}");
        };
    }
}

Step 3. Create a class named “MessageHandler.cs” as shown below. It will be used to manage an event of action type.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ActionDelegateExample
{
    public class MessageHandler
    {
        // Method that accepts an Action<RequestMessage> callback
        public void ProcessRequest(string messageContent, Action<RequestMessageWithParameter> callback)
        {
            // Create the RequestMessage
            RequestMessageWithParameter requestMessage = new RequestMessageWithParameter { Content = messageContent };

            // Simulate some processing
            Console.WriteLine("Processing the message...");
            System.Threading.Thread.Sleep(10000);

            // After processing, invoke the callback with the request message
            callback?.Invoke(requestMessage);
        }
    }
}

Step 4. Create a class by the name of ‘EventHandlerManager.cs” to handle the event.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ActionDelegateExample
{
    public class EventHandlerManager
    {
        public static event Action OnEventRaised;
        // Method to raise the event
        public static void RaiseOnEventRaised()
        {
            Action onEventRaised = OnEventRaised;
            if (onEventRaised != null)
            {
                onEventRaised();
            }
        }
    }
}

A detailed description of the aforementioned code

• RaiseOnEventRaised(): A static method that triggers the OnEventRaised event.
• Action onEventRaised = OnEventRaised: Creates a local copy of the event delegate. This is done to avoid the potential issues of the event being null while invoking it.
• if (onEventRaised != null): Checks if there are any subscribers to the event. If there are, it proceeds to invoke the event.
• onEventRaised(): Invokes the event. This calls all methods that have subscribed to OnEventRaised.

Step 6. The results obtained from testing are. 

Action with No Parameters

Action with One Parameter

 Action with Multiple Parameters

 Passing Action as a Parameter to a Method(Callback)

Using Action with Event Handling
 

Windows Hosting Recommendation

HostForLIFEASP.NET receives Spotlight standing advantage award for providing recommended, cheap and fast ecommerce Hosting including the latest Magento. From the leading technology company, Microsoft. All the servers are equipped with the newest Windows Server 2022 R2, SQL Server 2022, ASP.NET Core 7.0.10 , ASP.NET MVC, Silverlight 5, WebMatrix and Visual Studio Lightswitch. Security and performance are at the core of their Magento hosting operations to confirm every website and/or application hosted on their servers is highly secured and performs at optimum level. mutually of the European ASP.NET hosting suppliers, HostForLIFE guarantees 99.9% uptime and fast loading speed. From €3.49/month , HostForLIFE provides you with unlimited disk space, unlimited domains, unlimited bandwidth,etc, for your website hosting needs.