Action and Func Delegates in C#

public Func<Messages, Action> WhatsApp { get; } = messages => () =>
{
    // ...
};

The Func delegate takes a Messages parameter and returns an Action. In this sample, we can use it to create functions that return actions for different message types (WhatsApp, SMS, Email).

The last param in Func is his return type. The example above is an Action. Let’s see a practical example:

Func<int, int, long> add = (x, y) => x + y;

var result = add(5, 10);

Console.WriteLine("Result: " + result);

As the last type in Func is long, the result of add(5, 10) is a long .NET type.

What is the difference between Action and Func delegates?

The primary distinction between Action and Func delegates is based on their return types and intended purpose. Action delegates are intended for methods that do not return a value and conduct actions or have side effects. Func delegates, on the other hand, are designed for processes that return a value and have a return type given as their last parameter.

Because of this fundamental distinction, Action may represent methods that execute tasks without delivering data, whereas Func can represent methods that compute and produce a result. The decision between Action and Func is determined by whether we need to conduct an action or obtain a value from the method encapsulated by the delegate.

Practical example

This code will read the CSV file, parse each row into a Messages object, and then use the delegate functions in SendNotifications to send the messages based on their TypeMessage property. If the TypeMessage value doesn’t match any expected types (0 for WhatsApp, 1 for SMS, 2 for Email), it will print an error message.

Here we read from the console the file path:

Console.WriteLine("Please type the CSV file path:");

var file = Console.ReadLine();

We create the notificationServices and call ProcessFile from the SenderProcess class:

var notificationService = new SendNotifications();

var procSenders = new SenderProcess();

try
{
    var result = procSenders.ProcessFile(file, notificationService);

    if (result == null)
    {
        Console.WriteLine("Result is null!");
    }
    else
    {
        var totalProcessed = result.CountTypes.Sum();


        Console.WriteLine($"Total WhatsApp processed: {notificationService.CountTypes[0]}");

        Console.WriteLine($"Total Sms processed: {notificationService.CountTypes[1]}");

        Console.WriteLine($"Total Email processed: {notificationService.CountTypes[2]}");

        Console.WriteLine($"Total messages processed: {totalProcessed}");
    }
}
catch (Exception ex)
{
    Console.WriteLine($"Error processing: {ex.Message}");
}

The ProcessFile transforms the file into a List Messages in the local function Read() and, after that, calls ProcessListMessages:

var processMessages = new SenderProcess();

// ...

processMessages.ProcessListMessages(records, notificationService, Processed);

Let's look again into how we've applied Action and Func delegates to send messages based on their types in our code.

public void ProcessRecords(
    List<Messages>? records,
    SendNotifications notificationService,
    Action<int, SendNotifications> processed)
{
    try
    {
        foreach (var record in records)
        {
            Action sender;

            switch (record.TypeMessage)
            {
                case 0:
                    sender = () => notificationService.WhatsApp(record);
                    break;
                case 1:
                    sender = () => notificationService.Sms(record);
                    break;
                case 2:
                    sender = () => notificationService.Email(record);
                    break;
                default:
                    Console.WriteLine($"Type mismatch {record.TypeMessage}");
                    continue;
            }
            sender.Invoke();
            processed(record.TypeMessage, notificationService);
        }
    }
    catch
    {
        throw new Exception("Error on records.");
    }
}

In this method, we receive a collection of Messages records and use the Action delegate to send messages based on their TypeMessage. The Func delegates within notificationService return the appropriate actions for each message type, and the notificationService methods are all Func type.

How do delegates enhance code modularity and reusability in C# applications?

Delegates improve C# code modularity by encapsulating certain behaviors or operations, facilitating clear separation and easy feature management. They promote reusability by allowing delegate instances to be reused, allowing the same behavior to be used across several areas of an application.

Furthermore, delegates support expressive programming through functional paradigms, event handling, and callback mechanisms. This results in more concise, readable, and adaptable code that describes program behavior at a higher level, ultimately contributing to modular, reusable, and expressive C# applications.

Conclusion

Action and Func delegates are handy tools for managing methods as first-class entities. They allow us to encapsulate specific actions and functions, which results in code that is clearer and easier to maintain in our C# applications. When we design code that is both flexible and modular, it is vital to have a solid understanding of how to use these delegates.

Accecompletehe full example at my GitHub https://github.com/jssmotta/DelegateActionAndFuncAppSample