C# 12: Embracing the Quirks and Magic of Modern Programming
Tags: csharp, abotwrotethis
Published: 2023-07-30 14:56:41

### Introduction:
Welcome to the exciting world of C# 12, where modern programming meets a touch of magic and humor! In this blog, we will explore the latest features introduced in C# 12, from primary constructors to code sorcery. So fasten your seatbelts, and let's dive into the quirky wonders of C#!

- **Constructors**: A Constructor Revolution

Constructors are the architects of object creation, and C# 12 brings a revolution with "Primary Constructors." Now, they are not just for record types; you can use them in any class or struct! Primary constructor parameters are in scope for the entire class, reducing boilerplate code. And remember to call the primary constructor from other constructors using "this()". Say goodbye to the mundane and welcome cleaner, more concise code!

```csharp
// Primary constructor example
public class Person
{
    public string Name { get; }
    public int Age { get; }

    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
}
```


- **Default Lambda Parameters**: Embracing Laziness!

Lambdas are powerful, and C# 12 takes them a step further with "Default Lambda Parameters." Now, you can give your lambdas default values, just like regular methods. This lazy addition to lambdas simplifies your code without sacrificing functionality. Embrace the power of defaults and let your lambdas take it easy!

```csharp
// Default Lambda Parameters
Func<int, int, int> addNumbers = (x, y = 10) => x + y;

// Usage
int result1 = addNumbers(5);      // result1 = 5 + 10 = 15
int result2 = addNumbers(5, 7);   // result2 = 5 + 7 = 12
```


-  **Alias Any Type**: The Language of Your Code

Aliases just got a significant upgrade! With "Alias Any Type," you can create semantic aliases for any type, not just named ones. Tuple types, array types, pointers - anything you want! Give your code a unique language of its own and let your creativity flow.

```csharp
// Alias Any Type
using MyArray = int[];  // Alias for int array

public class Example
{
    public void UseAlias()
    {
        MyArray numbers = new MyArray { 1, 2, 3, 4, 5 };
        foreach (var num in numbers)
        {
            Console.WriteLine(num);
        }
    }
}
```

-  **Inline Arrays**: Compact and Speedy!

Inline arrays are here to supercharge your apps! They allow developers to create fixed-size arrays in struct types without the usual overhead. As a developer, you might not create them directly, but you'll enjoy their benefits through System.Span<T> or System.ReadOnlySpan<T> objects from runtime APIs. Get ready for compact and speedy performance!

```csharp
[System.Runtime.CompilerServices.InlineArray(10)]
public struct Buffer
{
    private int _element0;
}

// Usage
var buffer = new Buffer();
for (int i = 0; i < 10; i++)
{
    buffer[i] = i;
}

foreach (var i in buffer)
{
    Console.WriteLine(i);
}
```

-  **Interceptors**: Unleashing Code Sorcery (Experimental)

_Caution: Interceptors are experimental and not for production use._

Interceptors provide a glimpse into the world of code sorcery! This experimental feature allows you to declaratively substitute calls to interceptable methods with your custom logic at compile time. Think of it as a source generator's magic wand, modifying existing code rather than adding new code. But beware, with great power comes great responsibility!

```csharp
[Interceptable]
public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }
}

// Interceptor method
[Interceptor(nameof(CustomAdd))]
public int InterceptedAdd(int a, int b)
{
    Console.WriteLine("Interceptor activated!");
    return CustomAdd(a, b);
}

// Usage
var calculator = new Calculator();
int result = calculator.Add(5, 7);   // The Interceptor will be invoked if enabled.

```

#### Conclusion:
Congratulations, adventurous programmers! You've now journeyed through the quirky world of C# 12, from primary constructors to code sorcery. Embrace these new features and let them infuse magic into your code. But remember, with great magic comes great responsibility! Enjoy exploring these innovative additions to C# and continue pushing the boundaries of your coding adventures. Happy coding, and may the quirks be with you!