C# 12 est disponible ! C# 12 améliore la productivité des développeurs grâce à une syntaxe simplifiée et à une exécution plus rapide. Voici quelques fonctionnalités et améliorations.Vous pouvez obtenir C# 12 en téléchargeant .NET 8, la dernière version de Visual Studio ou le kit de développement C# de Visual Studio Code.
Pour vos projets existants, vous devrez également indiquer que vous souhaitez changer de version linguistique. Vous pouvez modifier votre version linguistique en remplaçant votre TargetFramework par .NET 8 :
| Code : | Sélectionner tout |
1 2 3 4 5 6 | <Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
...
</PropertyGroup>
</Project> |
Simplification du code
Chaque version de C# vous aide à écrire un meilleur code, un code plus simple qui exprime mieux votre intention. Par rapport au code que vous avez écrit précédemment, la nouvelle approche est aussi rapide, voire plus rapide, et comporte le même nombre d'allocations, voire moins. Vous pouvez adopter ces nouvelles fonctionnalités en toute confiance. L'un des objectifs de conception des nouvelles fonctionnalités est de s'assurer que leur adoption ne dégrade pas les performances.
C# 12 introduit des expressions de collection, des constructeurs primaires pour toutes les classes et les structures, une syntaxe permettant d'aliaser n'importe quel type et des paramètres par défaut pour les expressions lambda qui simplifient votre code.
Expressions de collection
Avant C# 12, la création de collections nécessitait une syntaxe différente selon les scénarios. L'initialisation d'une List<int> nécessitait une syntaxe différente de celle d'un int[] ou d'un Span<int>. Voici quelques-unes des façons dont les collections peuvent être créées :
| Code : | Sélectionner tout |
1 2 3 4 5 6 | int[] x1 = new int[] { 1, 2, 3, 4 };
int[] x2 = Array.Empty<int>();
WriteByteArray(new[] { (byte)1, (byte)2, (byte)3 });
List<int> x4 = new() { 1, 2, 3, 4 };
Span<DateTime> dates = stackalloc DateTime[] { GetDate(0), GetDate(1) };
WriteByteSpan(stackalloc[] { (byte)1, (byte)2, (byte)3 }); |
| Code : | Sélectionner tout |
1 2 3 4 5 6 | int[] x1 = [1, 2, 3, 4]; int[] x2 = []; WriteByteArray([1, 2, 3]); List<int> x4 = [1, 2, 3, 4]; Span<DateTime> dates = [GetDate(0), GetDate(1)]; WriteByteSpan([1, 2, 3]); |
Et comme si cela ne suffisait pas, vous pouvez utiliser l'opérateur new spread pour inclure les éléments d'une ou plusieurs collections ou expressions énumérables dans une expression de collection :
| Code : | Sélectionner tout |
1 2 3 4 | int[] numbers1 = [1, 2, 3]; int[] numbers2 = [4, 5, 6]; int[] moreNumbers = [.. numbers1, .. numbers2, 7, 8, 9]; // moreNumbers contains [1, 2, 3, 4, 5, 6, 7, 8, ,9]; |
Comme pour de nombreuses nouvelles fonctionnalités de C#, les analyseurs peuvent vous aider à vérifier la nouvelle fonctionnalité et à mettre à jour votre code :
Constructeurs primaires sur n'importe quelle classe ou structure
C# 12 étend les constructeurs primaires à toutes les classes et structures, et pas seulement aux enregistrements. Les constructeurs primaires vous permettent de définir les paramètres du constructeur lors de la déclaration de la classe :
| Code : | Sélectionner tout |
1 2 3 4 5 6 7 | public class BankAccount(string accountID, string owner)
{
public string AccountID { get; } = accountID;
public string Owner { get; } = owner;
public override string ToString() => $"Account ID: {AccountID}, Owner: {Owner}";
} |
- Comme argument à l'invocation du constructeur base().
- Pour initialiser un champ membre ou une propriété.
- Faire référence au paramètre du constructeur dans un membre de l'instance.
- Pour supprimer les éléments parasites dans l'injection de dépendances.
Vous pouvez considérer qu'un paramètre de constructeur primaire est un paramètre dont la portée s'étend à l'ensemble de la déclaration de la classe.
Vous pouvez ajouter des constructeurs primaires à n'importe quel type : classe, structure, classe d'enregistrement et structure d'enregistrement. Lorsqu'ils sont utilisés pour les types classe et structure, les paramètres des constructeurs primaires sont pris en compte dans l'ensemble de la définition de la classe ou de la structure. Vous pouvez utiliser les paramètres pour initialiser des champs ou des propriétés, ou dans le corps d'autres membres. Lorsqu'ils sont utilisés sur des types d'enregistrement, le compilateur génère une propriété publique pour chaque paramètre de constructeur primaire. Ces propriétés sont simplement l'un des nombreux membres générés automatiquement pour les types d'enregistrements.
Alias de n'importe quel type
L'alias de type est un moyen pratique de supprimer les signatures de type complexes de votre code. À partir de C# 12, des types supplémentaires sont valides pour l'utilisation des directives d'alias. Par exemple, ces alias ne sont pas valables dans les versions antérieures de C# :
| Code : | Sélectionner tout |
1 2 3 | using intArray = int[]; // Array types. using Point = (int x, int y); // Tuple type using unsafe ArrayPtr = int*; // Pointer type (requires "unsafe") |
Paramètres lambda par défaut
À partir de C# 12, vous pouvez déclarer des paramètres par défaut dans les expressions lambda :
| Code : | Sélectionner tout |
1 2 3 4 | var IncrementBy = (int source, int increment = 1) => source + increment; Console.WriteLine(IncrementBy(5)); // 6 Console.WriteLine(IncrementBy(5, 2)); // 7 |
Accélérer votre code
Microsoft continue à améliorer votre capacité à travailler avec la mémoire brute afin d'améliorer les performances des applications.
Les améliorations apportées à C# au fil des ans sont importantes, que vous les utilisiez directement ou non. La plupart des applications deviennent plus rapides parce que le moteur d'exécution .NET et d'autres bibliothèques tirent parti de ces améliorations. Bien entendu, si votre application utilise des tampons de mémoire dans des chemins d'accès rapides, vous pouvez également tirer parti de ces fonctionnalités. Votre application n'en sera que plus rapide.
En C# 12, on a ajouté les paramètres ref readonly et les tableaux inline.
Paramètres ref readonly
L'ajout des paramètres ref readonly permet de combiner le passage de paramètres par référence ou par valeur. L'argument d'un paramètre ref readonly doit être une variable. Comme pour les arguments ref et out, l'argument ne doit pas être une valeur littérale ou une constante. Un argument littéral génère un avertissement et le compilateur crée une variable temporaire. Comme les paramètres in, un paramètre ref readonly ne peut pas être modifié. Une méthode doit déclarer des paramètres ref readonly lorsqu'elle ne modifiera pas l'argument, mais qu'elle a besoin de son emplacement en mémoire.
Tableaux en ligne
Les tableaux en ligne constituent un moyen sûr de travailler avec des tampons de mémoire. Un tableau en ligne est un type de tableau de longueur fixe basé sur une structure. Vous avez pu manipuler un bloc de mémoire en utilisant le stockage stackalloc ou les pointeurs. Mais ces techniques nécessitaient que votre assemblage permette un code non sécurisé. Lorsque votre application doit utiliser un bloc de mémoire pour stocker un tableau de structures, vous pouvez désormais déclarer un type de tableau en ligne. Ce type représente un tableau de taille fixe. Vous pouvez les utiliser dans du code sûr et améliorer les performances de votre application lors de la manipulation de tampons.
Aider Microsoft à aller plus vite
Parfois des fonctionnalités à C# sont ajoutées à titre expérimental ou pour rendre le développement de C# ou de .NET plus efficace. C# 12 apporte deux de ces fonctionnalités : l'attribut expérimental et les intercepteurs.
Attribut expérimental
Microsoft place parfois des fonctionnalités dans les versions publiées de .NET ou de C# pour obtenir un retour d'information ou parce que...
La fin de cet article est réservée aux abonnés. Soutenez le Club Developpez.com en prenant un abonnement pour que nous puissions continuer à vous proposer des publications.
