C# 12 : Les nouvelles fonctionnalités à maîtriser absolument

C# 12 : Une évolution majeure du langage

C# 12 marque une étape importante dans l'évolution du langage avec des fonctionnalités qui simplifient le code et améliorent la productivité des développeurs.

1. Collection Expressions

Les collection expressions révolutionnent la façon dont nous initialisons les collections :

// Syntaxe traditionnelle
var numbers = new List<int> { 1, 2, 3, 4, 5 };
var moreNumbers = new int[] { 6, 7, 8, 9, 10 };

// C# 12 - Collection expressions
int[] numbers = [1, 2, 3, 4, 5];
List<string> names = ["Alice", "Bob", "Charlie"];
Span<int> span = [1, 2, 3, 4, 5];

// Spread operator
int[] first = [1, 2, 3];
int[] second = [4, 5, 6];
int[] combined = [..first, ..second]; // [1, 2, 3, 4, 5, 6]

2. Primary Constructors

Simplifiez vos classes avec les constructeurs primaires :

// Syntaxe traditionnelle
public class Person
{
    public string FirstName { get; }
    public string LastName { get; }
    
    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }
}

// C# 12 - Primary constructors
public class Person(string firstName, string lastName)
{
    public string FirstName { get; } = firstName;
    public string LastName { get; } = lastName;
    
    public string FullName => $"{firstName} {lastName}";
}

// Encore plus concis avec des records
public record PersonRecord(string FirstName, string LastName)
{
    public string FullName => $"{FirstName} {LastName}";
}

3. Default Lambda Parameters

// C# 12 permet des paramètres par défaut dans les lambdas
var addWithDefault = (int x, int y = 10) => x + y;

Console.WriteLine(addWithDefault(5)); // Output: 15
Console.WriteLine(addWithDefault(5, 3)); // Output: 8

// Utile avec LINQ
var filteredData = data.Where((item, index = 0) => item.IsValid || index < 10);

4. Alias pour tout type

// C# 12 étend les alias aux types génériques et aux tuples
using StringList = System.Collections.Generic.List<string>;
using UserTuple = (string Name, int Age, string Email);
using StringIntDictionary = System.Collections.Generic.Dictionary<string, int>;

public class UserService
{
    public StringList GetUserNames() => new();
    public UserTuple CreateUser(string name, int age, string email) => (name, age, email);
    public StringIntDictionary GetUserScores() => new();
}

5. Interceptors (Preview)

Les interceptors permettent de modifier des appels de méthodes au moment de la compilation :

// Méthode originale
public static void Log(string message)
{
    Console.WriteLine($"[LOG] {message}");
}

// Interceptor qui remplace l'appel
[InterceptsLocation("Program.cs", 42, 8)]
public static void EnhancedLog(string message)
{
    Console.WriteLine($"[{DateTime.Now:HH:mm:ss}] [ENHANCED] {message}");
}

// Lors de la compilation, l'appel à Log() sera remplacé par EnhancedLog()

6. Experimental Attribute

[Experimental("MYLIB001")]
public class ExperimentalFeature
{
    public void NewMethod() 
    {
        // Cette méthode génère un warning car elle est expérimentale
    }
}

// Usage génère un warning MYLIB001
#pragma warning disable MYLIB001
var feature = new ExperimentalFeature();
feature.NewMethod();
#pragma warning restore MYLIB001

Bonnes pratiques avec C# 12

• Collection expressions : Utilisez-les pour une syntaxe plus claire
• Primary constructors : Parfaits pour les DTOs et classes simples
• Alias étendus : Améliorent la lisibilité du code complexe
• Default parameters : Réduisent la verbosité des lambdas

Conclusion

C# 12 continue d'évoluer vers un langage plus expressif et concis, tout en maintenant ses performances et sa robustesse. Ces nouvelles fonctionnalités s'intègrent naturellement dans l'écosystème .NET existant.