My Point of View

Most times you’re going to want Func or Action if all that needs to happen is to run some code. You need Expression when the code needs to be analyzed, serialized, or optimized before it is run. Expression is for thinking about code, Func/Action is for running it.

In C#, passing a function as a parameter to another method or function is a powerful feature that allows for increased flexibility and code reusability. This technique, often referred to as “higher-order functions” or “function pointers,” enables you to treat functions as first-class citizens in your code.

Using Action Delegate

The Action delegate is a predefined delegate type provided by C# that represents a method that does not return a value but can accept up to sixteen input parameters.

Define the function signature that matches the action delegate you want to use. The action delegate represents a method that does not return a value and can accept up to 16 input parameters. For example, if you have a function with two input parameters of type int and string, the signature would be Action.

Create a method that takes an action delegate as an argument to use this delegate. The parameter should have the same signature as the function you want to pass. Inside the method, you can invoke the passed action delegate and use it just like any other function.

Here’s an example that demonstrates how to pass a function using the action delegate:

 // Define the function signature that matches the Action delegate
        static internal void MyFunction(int param1, string param2)
        {
            Console.WriteLine($"Action delegate demo - Parameters: {param1}, {param2}");
        }

        // Create a method that accepts a Action delegate as a parameter

        static internal void ProcessAction(Action<int, string> action)

        {
            // Invoke the passed action
            action(10, "Hello");
        }

        static void Main()
        {
            //usage example
            ProcessAction(MyFunction);
        }

In this example, we have a MyFunction method that matches the signature of the Action<int, string> delegate, and it does not return a value and only accepts two parameters: an int and a string.

The ProcessAction method accepts an Action<int, string> delegate as a parameter. It invokes the passed function using the delegate by calling action(10, “Hello”).

In the Main() method, we demonstrate the usage by calling ProcessAction and passing MyFunction as the argument. This will invoke MyFunction inside ProcessAction and output the parameters passed to it.

Using Func Delegate

The Func delegate is another predefined delegate type in C# that represents a method that takes input parameters and returns a value.

So to use this delegate, define the function signature that matches the Func delegate you want to use. The Func delegate can handle functions with up to 16 input parameters and a return type as the last type parameter. For example, if you have a function with two input parameters of type int and string that returns a bool, the signature would be Func<int, string, bool>.

A method that takes a Func delegate as a parameter should then be created, and the parameter’s signature should match that of the function you intend to pass. Inside the method, you can invoke the passed Func delegate and use it just like any other function. Here’s an example that demonstrates how to pass a function using the Func delegate:

 // Define the function signature that matches the Func delegate
        static internal bool MyFunction(int param1, string param2)
        {
            Console.WriteLine($"Function delegate deom - Parameters: {param1}, {param2}");
            return true;
        }


        // Create a method that accepts a Function delegate as a parameter

        static internal void ProcessFunc(Func<int, string, bool> func)
        {
            // Invoke the passed func and get the result
            bool result = func(10, "Hello");
            // Process the result
            Console.WriteLine($"Result: {result}");
        }

        static void Main()
        {
            // Usage example
            ProcessFunc(MyFunction);
        }

In this example, we have a MyFunction method that matches the signature of the Func<int, string, bool> delegate. It receives two parameters—an int and a string—and outputs a bool.

The ProcessFunc method accepts a Func<int, string, bool> delegate as a parameter. It invokes the passed function using the delegate and stores the result in the result variable. Finally, it processes the result by printing it to the console.

Using Expression

An expression simply turns a delegate into a data about itself. So a => a + 1 becomes something like “On the left side there’s an int a. On the right side you add 1 to it.” That’s it. You can go home now. It’s obviously more structured than that, but that’s essentially all an expression tree really is–nothing to wrap your head around.

So, in other words, an Expression contains the meta-information about a certain delegate.

An expression tree is a data structure that represents some code. It isn’t compiled and executable code. If you want to execute the .NET code represented by an expression tree, you must convert it into executable IL instructions. Executing an expression tree may return a value, or it may just perform an action such as calling a method.

You would convert an expression into a delegate using the following code:

Expression<Func<int>> add = () => 1 + 2;
var func = add.Compile(); // Create Delegate
var answer = func(); // Invoke Delegate
Console.WriteLine(answer);

Reference

https://learn.microsoft.com/en-us/dotnet/csharp/advanced-topics/expression-trees/expression-trees-execution

https://stackoverflow.com/questions/793571/why-would-you-use-expressionfunct-rather-than-funct

https://www.daveaglick.com/posts/using-expression-trees-to-get-class-and-member-names