HTML to PDF with QuestPDF in .NET 8

 C# 12 introduces several new features aimed at improving developer productivity and code readability. Here are some:

1. Primary Constructors:

• Allows defining constructor parameters directly within the class or struct declaration, simplifying code for basic scenarios.
• Example:

C#

public class Point
{
    public int X { get; }
    public int Y { get; }

    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }
}

// Now possible with C# 12:
public record Point(int X, int Y);

2. Collection Expressions:

• Provides a concise syntax for initializing common collection types like lists, arrays, and dictionaries.
• Example:

C#

// Old way:
List<int> numbers = new List<int>() { 1, 2, 3 };

// C# 12:
List<int> numbers = [1, 2, 3];

3. Inline Arrays:

• Allows defining small, fixed-size arrays directly within method arguments or local variables.
• Example:

C#

// Old way:
int[] points = new int[] { 10, 20 };

// C# 12:
int[] points = { 10, 20 };

4. Optional Parameters in Lambda Expressions:

• Enables defining default values for parameters in lambda expressions.
• Example:

C#

// Old way (required parameter):
Func<int, string> formatNumber = (x) => x.ToString();

// C# 12 (optional parameter with default value):
Func<int, string, string> formatNumber = (x, format = "G") => x.ToString(format);

5. Alias any Type:

• Allows creating an alias for any named type using the using alias directive.
• Example:

C#

using LongType = System.Int64;

LongType myLongValue = 1234567890L;

6. ref readonly Parameters:

• Provides a new way to pass arguments by reference while ensuring they cannot be modified within the method.
• Useful for scenarios where you need to access the original memory location without modifying the value.

7. Interceptors (preview feature):

• Introduces a new experimental feature that allows intercepting method calls and potentially modifying their behavior.
• Use with caution as it's still under development and subject to change in future releases.

These are some of the key features introduced in C# 12. Exploring these features can help you write cleaner, more concise, and potentially more performant code.