C# Action (How It Works For Developers)

What is a Func Delegate?

The Func delegate represents a method that can have a return value. The last type parameter specifies the return type, and the preceding types specify the input parameters.

For instance, a Func<int, int, string> takes two integer parameters and returns a string message.

Example of an Action Delegate

An Action delegate, a predefined delegate type, is used when you want to execute a method that does not specifically return a value, focusing instead on operations. Here's a basic example:

Action<string> display = message => Console.WriteLine(message);
display("Hello, World!");

Action<string> display = message => Console.WriteLine(message);
display("Hello, World!");

This code defines an Action delegate, illustrating the use of an anonymous method, that takes a single string parameter and prints it to the console. The => symbol is used to define a lambda expression, which is a concise way to write anonymous methods.

Example of a Func Delegate

A Func delegate, which returns a value, can be used as follows:

Func<int, int, int> add = (x, y) => x + y;
int result = add(5, 3);
Console.WriteLine(result);

Func<int, int, int> add = (x, y) => x + y;
int result = add(5, 3);
Console.WriteLine(result);

This example creates a Func delegate that takes two integer parameters and returns their sum. The sum will show on the console like this:

Anonymous Methods

Anonymous methods in C# provide a way to define inline methods without a name. They are often used with delegates to create delegate instances directly.

Lambda Expressions

Lambda expressions are a shorthand for writing anonymous methods. They allow you to write less code while achieving the same result.

Generic Delegate

A generic delegate can work with any data type. Func and Action are examples of generic delegates, providing more flexibility by allowing you to specify input and output types at runtime.

Delegate Instance

A delegate instance is created with the new keyword or by simply assigning a method that matches the delegate's signature.

System Namespace

The System namespace in .NET contains built-in types like Func and Action, which are part of the base class library.

Example: Asynchronous File Processing

Consider an application that needs to process a large file. Using an Action delegate in conjunction with asynchronous programming patterns like Task can significantly enhance application performance:

public async Task ProcessFileAsync(string filePath, Action<string> onComplete)
{
    // Asynchronously read file content
    string fileContent = await File.ReadAllTextAsync(filePath);
    // Process the file content here (omitted for brevity)

    // Once processing is complete, invoke the onComplete callback
    onComplete?.Invoke("File processing completed successfully.");
}

public async Task ProcessFileAsync(string filePath, Action<string> onComplete)
{
    // Asynchronously read file content
    string fileContent = await File.ReadAllTextAsync(filePath);
    // Process the file content here (omitted for brevity)

    // Once processing is complete, invoke the onComplete callback
    onComplete?.Invoke("File processing completed successfully.");
}

In this example, File.ReadAllTextAsync is used to read the file content without blocking the main thread. Once the file is processed, an Action delegate named onComplete is invoked to notify the caller that the operation is complete, allowing for further actions like updating the UI or logging results.

Installing IronPDF

To incorporate IronPDF into your .NET projects, you can use NuGet, which is the most straightforward method. Just open the Package Manager Console in Visual Studio and run the following command:

Install-Package IronPdf

This command fetches and installs the IronPDF package, setting up your project to start using IronPDF for PDF generation and manipulation.

Code Example with Action Delegate

Here's a simple example demonstrating how to use IronPDF in conjunction with an Action delegate to perform a PDF generation task:

using IronPdf;
using System;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // Define an Action delegate that takes HTML content as a string
        Action<string> generatePdf = html =>
        {
            // Render the HTML as a PDF
            var pdf = renderer.RenderHtmlAsPdf(html);

            // Save the PDF to a file
            pdf.SaveAs("example.pdf");
        };

        // Generate the PDF with the provided HTML
        generatePdf("<p>Hello, world!</p>");
        Console.WriteLine("PDF generated successfully.");
    }
}

using IronPdf;
using System;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // Define an Action delegate that takes HTML content as a string
        Action<string> generatePdf = html =>
        {
            // Render the HTML as a PDF
            var pdf = renderer.RenderHtmlAsPdf(html);

            // Save the PDF to a file
            pdf.SaveAs("example.pdf");
        };

        // Generate the PDF with the provided HTML
        generatePdf("<p>Hello, world!</p>");
        Console.WriteLine("PDF generated successfully.");
    }
}

This example defines an Action delegate that takes a string of HTML and uses IronPDF to render it into a PDF document. The generated PDF is then saved to the file system. This approach demonstrates how delegates can be used to encapsulate PDF generation logic, making your code more modular and flexible.

Licensing

IronPDF offers various licensing options for developers, starting from individual developer licenses to enterprise agreements. Pricing for these licenses starts from $799.