Discussion :

[Anthony]

Microsoft présente un aperçu de trois nouvelles fonctionnalités de C# 12, dont les constructeurs primaires pour les classes ou les structures et la définition d'alias pour tous les types

Nous sommes ravis de présenter en avant-première trois nouvelles fonctionnalités de C# 12 :

• Constructeurs primaires pour les classes et les structures non enregistrées
• Utilisation d'alias pour n'importe quel type
• Valeurs par défaut pour les paramètres des expressions lambda

Pour tester vous-même ces fonctionnalités, vous pouvez télécharger la dernière version préliminaire de Visual Studio 17.6 ou la dernière version préliminaire de .NET 8.

Constructeurs primaires pour les classes et les structures non enregistrées

Les constructeurs primaires vous permettent d'ajouter des paramètres à la déclaration de la classe elle-même et d'utiliser ces valeurs dans le corps de la classe. Par exemple, vous pouvez utiliser les paramètres pour initialiser les propriétés ou dans le code des méthodes et des accesseurs de propriété. Les constructeurs primaires ont été introduits pour les enregistrements en C# 9 dans le cadre de la syntaxe positionnelle des enregistrements. C# 12 les étend à toutes les classes et structures.

La syntaxe de base et l'utilisation d'un constructeur primaire sont les suivantes :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
public class Student(int id, string name, IEnumerable<decimal> grades)
 
{
 
    public Student(int id, string name) : this(id, name, Enumerable.Empty<decimal>()) { }
    public int Id => id;
    public string Name { get; set; } = name.Trim();
    public decimal GPA => grades.Any() ? grades.Average() : 4.0m;
}

Les paramètres du constructeur primaire de la classe Student ci-dessus sont disponibles dans tout le corps de la classe. L'une des façons de les utiliser est d'initialiser les propriétés. Contrairement aux enregistrements, les propriétés ne sont pas automatiquement créées pour les paramètres du constructeur primaire dans les classes et les structures sans enregistrement. Cela s'explique par le fait que les classes et les structures non enregistrées sont souvent plus complexes que les enregistrements, car elles combinent des données et un comportement. Par conséquent, elles ont souvent besoin de paramètres de construction qui ne doivent pas être exposés. La création explicite de propriétés permet de savoir quelles données sont exposées, ce qui est conforme à l'utilisation courante des classes. Les constructeurs primaires permettent d'éviter de déclarer des champs privés et de faire en sorte que des corps de constructeurs triviaux attribuent des valeurs de paramètres à ces champs.

Lorsque les paramètres du constructeur primaire sont utilisés dans des méthodes ou des accesseurs de propriété (le paramètre grades dans la classe Student), ils doivent être capturés afin de rester présents après l'exécution du constructeur. Ceci est similaire à la façon dont les paramètres et les variables locales sont capturés dans les expressions lambda. Pour les paramètres du constructeur primaire, la capture est mise en œuvre en générant un champ de soutien privé sur la classe ou la structure elle-même. Le champ a un nom "unspeakable", ce qui signifie qu'il n'entrera pas en collision avec d'autres noms et qu'il n'est pas évident par réflexion. Réfléchissez à la manière dont vous affectez et utilisez les paramètres du constructeur primaire afin d'éviter le double stockage. Par exemple, name est utilisé pour initialiser l'auto-propriété Name, qui possède son propre champ d'appui. Si un autre membre faisait directement référence au paramètre name, ce dernier serait également stocké dans son propre champ de sauvegarde, ce qui entraînerait une duplication regrettable.

Une classe dotée d'un constructeur primaire peut avoir des constructeurs supplémentaires. Ces derniers doivent utiliser un initialisateur this(...) pour appeler un autre constructeur sur la même classe ou structure. Cela permet de s'assurer que le constructeur primaire est toujours appelé et que toutes les données nécessaires à la création de la classe sont présentes. Une structure possède toujours un constructeur sans paramètre. Le constructeur implicite sans paramètre n'utilise pas d'initialisateur this()pour appeler le constructeur primaire. Dans le cas d'une struct, vous devez écrire un constructeur sans paramètre explicite pour faire en sorte que le constructeur primaire soit appelé.

Directives d'utilisation pour les types supplémentaires

C# 12 étend la prise en charge des directives d'utilisation à n'importe quel type. Voici quelques exemples :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
using Measurement = (string, int);
using PathOfPoints = int[];
using DatabaseInt = int?;

Il est désormais possible de définir des alias pour presque tous les types. Vous pouvez créer des alias pour les types valeur nullable, mais vous ne pouvez pas créer d'alias pour les types référence nullable. Les tuples sont particulièrement intéressants car ils permettent d'inclure des noms et des types d'éléments :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

using Measurement = (string Units, int Distance);

Vous pouvez utiliser des alias partout où vous utiliseriez un type, par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
public void F(Measurement x)
 
{ }

Les alias vous permettent de faire abstraction des types que vous utilisez et de donner des noms conviviaux à des noms génériques longs ou confus. Cela peut faciliter la lecture de votre code.

Valeurs par défaut pour les expressions lambda

C# 12 franchit une nouvelle étape dans l'autonomisation des expressions lambda en vous permettant de spécifier des valeurs par défaut pour les paramètres. La syntaxe est la même que pour les autres paramètres par défaut :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
var addWithDefault = (int addTo = 2) => addTo + 1;
addWithDefault(); // 3
addWithDefault(5); // 6

Comme pour les autres valeurs par défaut, la valeur par défaut sera émise dans les métadonnées et sera disponible par réflexion en tant que DefaultValue du ParameterInfo de la propriété Method de l'expression lambda. Par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
var addWithDefault = (int addTo = 2) => addTo + 1;
addWithDefault.Method.GetParameters()[0].DefaultValue; // 2

Avant C# 12, vous deviez utiliser une fonction locale ou la difficile DefaultParameterValue de l'espace de noms System.Runtime.InteropServices pour fournir une valeur par défaut aux paramètres de l'expression lambda. Ces approches fonctionnent toujours, mais elles sont plus difficiles à lire et ne sont pas cohérentes avec les valeurs par défaut des méthodes. Avec les nouvelles valeurs par défaut des lambdas, vous aurez un aspect cohérent pour les valeurs des paramètres par défaut des méthodes, des constructeurs et des expressions lambda.

Prochaines étapes

Nous espérons que vous téléchargerez l'aperçu et que vous découvrirez ces fonctionnalités. Nous expérimentons en C# 12 avec un numéro dédié pour chaque fonctionnalité. Nous espérons que cela permettra de concentrer les commentaires et de faciliter l'adoption de ce que les autres disent.

Nous attendons vos commentaires avec impatience !

Source : Microsoft

Et vous ?

Que pensez-vous de ces nouvelles fonctionnalités de C# 12 ?

Voir aussi

Un premier aperçu des fonctionnalités de C# 11 est disponible avec la vérification des paramètres null, et les motifs de liste

Microsoft annonce la sortie de C# 10 dans le cadre de .NET 6 et Visual Studio 2022. C# 10 apporte des améliorations aux expressions lambda et plusieurs fonctionnalités

Une nouvelle Preview de C# 11 est disponible et s'accompagne d'une amélioration de l'initialisation des objets, ainsi que du support mathématique générique

[Jade Emy]

Microsoft présente un aperçu des nouvelles fonctionnalités de C# 12, dont l'amélioration de l'InlineArrayAttribute et de l'introduction de l'Interceptors.

Visual Studio 17.7 Preview 3 et .NET 8 Preview 6 poursuivent l'évolution de C# 12. Cet aperçu comprend des fonctionnalités conçues pour préparer le terrain en vue d'améliorations futures des performances. L'accès aisé aux "Inline arrays" permettra aux bibliothèques de les utiliser dans un plus grand nombre de cas, sans effort de votre part. Cet aperçu présente une fonctionnalité expérimentale appelée "Interceptors", qui permet aux générateurs de réacheminer le code, par exemple pour fournir une optimisation spécifique au contexte. Enfin, nameof est amélioré pour fonctionner dans un plus grand nombre de cas.

Vous pouvez obtenir C# 12 en installant la dernière version de Visual Studio ou la dernière version du SDK .NET. Pour découvrir les fonctionnalités de C# 12, vous devez définir la version linguistique de votre projet sur "preview" :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
<PropertyGroup>
   <LangVersion>preview</LangVersion>
</PropertyGroup>

nameof : Accès des membres à l'instance

Le mot-clé nameof fonctionne désormais avec les noms de membres, y compris les intiales, sur les membres statiques et dans les attributs :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
internal class NameOf
{
    public string S { get; } = "";
    public static int StaticField;
    public string NameOfLength { get; } = nameof(S.Length);
    public static void NameOfExamples()
    {
        Console.WriteLine(nameof(S.Length));
        Console.WriteLine(nameof(StaticField.MinValue));
    }
    [Description($"String {nameof(S.Length)}")]
    public int StringLength(string s)
    { return s.Length; }
}

Inline arrays ou tableaux en ligne

L'InlineArrayAttribute a été introduit dans le moteur d'exécution lors d'un précédent aperçu de .NET 8. Il s'agit d'une fonctionnalité avancée qui sera principalement utilisée par le compilateur, les bibliothèques .NET et quelques autres bibliothèques. L'attribut identifie un type qui peut être traité comme une séquence contiguë de primitives pour des données en ligne indexables ou découpables efficaces, sécurisées en termes de type et de dépassement de capacité. Les bibliothèques .NET améliorent les performances de vos applications et outils utilisant des tableaux en ligne.

Le compilateur crée différentes IL pour accéder aux tableaux en ligne. Il en résulte quelques restrictions, telles que l'impossibilité de prendre en charge les modèles de liste. Dans la plupart des cas, vous accédez aux tableaux en ligne de la même manière qu'aux autres tableaux. La différence d'interface utilisateur permet de gagner en performance sans modifier le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
private static void InlineArrayAccess(Buffer10<int> inlineArray)
{
    for (int i = 0; i < 10; i++)
    {
        inlineArray[i] = i * i;
    }
    foreach (int i in inlineArray)
    {
        Console.WriteLine(i);
    }
}

La plupart des gens utiliseront des tableaux en ligne plutôt que d'en créer. Mais il est bon de comprendre comment les choses fonctionnent. Les tableaux en ligne sont rapides parce qu'ils reposent sur une disposition exacte d'une longueur spécifiée. Un tableau en ligne est un type comportant un seul champ et marqué par l'attribut InlineArrayAttribute qui spécifie la longueur du tableau. Dans le type utilisé dans l'exemple précédent, l'exécution crée un espace de stockage pour exactement dix éléments dans Buffer10<T> en raison du paramètre d'attribut :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
[System.Runtime.CompilerServices.InlineArray(10)]
public struct Buffer10<T>
{
    private T _element0;
}

Interceptors ou Intercepteurs

Cet aperçu introduit une fonctionnalité expérimentale appelée interceptors. Elle est destinée à des scénarios avancés, permettant notamment d'améliorer la compilation anticipée (ahead of time-AOT). En tant que partie expérimentale de .NET 8, elle peut être modifiée ou supprimée dans une version future. Il ne doit donc pas être utilisé dans un contexte de production.

Les intercepteurs permettent de réacheminer des appels de méthodes spécifiques vers un code différent. Les attributs spécifient l'emplacement réel du code source, de sorte que les intercepteurs ne conviennent généralement qu'aux générateurs de sources.

Les intercepteurs étant une fonctionnalité expérimentale, vous devrez les activer explicitement dans votre fichier de projet :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
<PropertyGroup>
   <Features>InterceptorsPreview<Features>
</PropertyGroup>

Les intercepteurs permettent de créer des modèles de code intéressants. En voici quelques exemples :

• Les appels connus au moment de la compilation, comme Regex.IsMatch(@"a+b+") avec un motif constant, peuvent être interceptés afin d'utiliser un code généré de manière statique pour une optimisation qui est favorable à l'AOT.
• Les appels ASP.NET Minimal API comme app.MapGet("/products", handler: (int? page, int? pageLength, MyDb db) => { ... }) peuvent être interceptés pour enregistrer un thunk généré statiquement qui appelle directement le handler de l'utilisateur, en évitant l'allocation et l'indirection.
• Dans la vectorisation, où les boucles foreach contiennent des appels à des méthodes utilisateur, le compilateur peut réécrire le code pour vérifier et utiliser les éléments intrinsèques pertinents au moment de l'exécution, mais revenir au code d'origine si ces éléments intrinsèques ne sont pas disponibles.
• Résolution statique du graphe de dépendance pour l'injection de dépendance, où provider.Register<MyService>() peut être intercepté.
• Les appels aux fournisseurs de requêtes pourraient être interceptés pour offrir une traduction dans un autre langage (par exemple SQL) au moment de la compilation, plutôt que d'évaluer les arbres d'expression à traduire au moment de l'exécution.
• Les sérialiseurs pourraient générer une (dé)sérialisation spécifique au type en fonction du type concret des appels tels que Serialize<MyType>(), le tout au moment de la compilation.

La plupart des programmeurs n'utiliseront pas directement les intercepteurs, mais Microsoft espère qu'ils joueront un rôle important dans leur démarche visant à accélérer l'exécution de vos applications et à faciliter leur déploiement. Les intercepteurs devraient rester expérimentaux dans la version C# 12/.NET 8 et pourraient être inclus dans une future version de C#.

Source : Microsoft

Et vous ?

Que pensez-vous de ces nouvelles fonctionnalités de C# 12 ?

Voir aussi :

Augmentation de la popularité de C#, selon l'indice Tiobe
Qui lui a observé une croissance de près de 2% au cours des 12 derniers mois, tandis que C a perdu pratiquement autant en popularité

Un premier aperçu des fonctionnalités de C# 11 est disponible avec la vérification des paramètres null,
Et les motifs de liste

Microsoft présente un aperçu de trois nouvelles fonctionnalités de C# 12
Dont les constructeurs primaires pour les classes ou les structures et la définition d'alias pour tous les types

[Jade Emy]

Microsoft annonce C# 12 : une meilleure productivité des développeurs avec une syntaxe simplifiée et une exécution plus rapide.

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 - Visualiser dans une fenêtre à part

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 - Visualiser dans une fenêtre à part

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 });

Les expressions de collection constituent une syntaxe unifiée :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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]);

Non seulement vous pouvez utiliser une syntaxe unique, mais le compilateur crée un code rapide pour vous. Dans de nombreux cas, le compilateur définit la capacité de la collection et évite de copier les données.

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 - Visualiser dans une fenêtre à part

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];

L'implémentation de toute expression d'étalement est optimisée et sera souvent meilleure que le code que vous pourriez écrire pour combiner des collections.

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 - Visualiser dans une fenêtre à part

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}";
}

Les utilisations les plus courantes d'un paramètre de constructeur primaire sont les suivantes :

• 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 - Visualiser dans une fenêtre à part

1
2
3
using intArray = int[]; // Array types.
using Point = (int x, int y);  // Tuple type
using unsafe ArrayPtr = int*;  // Pointer type (requires "unsafe")

Comme les autres alias d'utilisation, ces types peuvent être utilisés au début d'un fichier et dans les déclarations d'utilisation globales.

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 - Visualiser dans une fenêtre à part

1
2
3
4
var IncrementBy = (int source, int increment = 1) => source + increment;
 
Console.WriteLine(IncrementBy(5)); // 6
Console.WriteLine(IncrementBy(5, 2)); // 7

Les paramètres lambda par défaut permettent au code appelant de ne pas passer de valeurs et vous permettent d'ajouter des paramètres à des expressions lambda existantes sans interrompre le code appelant. Cela simplifie l'accès aux expressions lambda de la même manière que les paramètres par défaut des méthodes simplifient l'appel des méthodes.

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 fonctionnalité ne peut pas être réalisée en un seul cycle. Dans ces cas, il est claire que Microsoft n'est pas encore engagé dans la fonctionnalité ou l'implémentation. Ils ont ajouté l'attribut System.Diagnostics.CodeAnalysis.ExperimentalAttribute pour mieux clarifier ces cas.

Lorsque le code utilise des types ou des membres qui sont expérimentaux, une erreur se produit à moins que le code appelant ne soit également marqué comme expérimental. Chaque utilisation de ExperimentalAttribute inclut un identifiant de diagnostic, qui vous permet de supprimer l'erreur pour des fonctionnalités expérimentales individuelles par une option explicite du compilateur ou #pragma afin que vous puissiez explorer une fonctionnalité expérimentale.

Les types, les membres et les assemblages peuvent être marqués avec l'attribut ExperimentalAttribute. Si un type est marqué comme expérimental, tous ses membres sont considérés comme expérimentaux. Si un assemblage ou un module est marqué comme expérimental, tous les types qu'il contient sont marqués comme expérimentaux.

Il est vivement recommandé aux auteurs de bibliothèques qui dépendent d'un élément doté d'un attribut Experimental de marquer également tout le code qui l'utilise avec l'attribut ExperimentalAttribute. Il est également encouragé pour les auteurs de bibliothèques à utiliser l'attribut ExperimentalAttribute s'ils ont des fonctionnalités expérimentales dans leurs bibliothèques.

Intercepteurs

Les intercepteurs sont une fonctionnalité expérimentale, disponible en mode preview avec C# 12. Cette fonctionnalité peut faire l'objet de modifications ou de suppressions dans une version ultérieure. Par conséquent, elle n'est pas recommandée pour les applications de production ou publiées. Si vous utilisez des intercepteurs, marquez votre bibliothèque avec l'attribut ExperimentalAttribute.

Les intercepteurs permettent de rediriger les appels de méthodes. Par exemple, cela permettrait à une version optimisée d'une méthode générée pour des paramètres spécifiques de remplacer une méthode généralisée moins efficace.

Prochaines étapes

C# 12 n'est qu'une partie de l'excitante version de .NET 8. Pour en savoir plus sur les autres fonctionnalités, consultez l'article sur .NET 8.

Téléchargez .NET 8, Visual Studio 2022 17.8 et découvrez C# 12 !

Source : Microsoft

Et vous ?

Quel est votre avis sur le sujet ?

Voir aussi :

Microsoft annonce .NET 8 avec des améliorations en matière de performances, de stabilité et de sécurité, ainsi que des améliorations de la plateforme et des outils pour accroître la productivité

Microsoft présente un aperçu des nouvelles fonctionnalités de C# 12, dont l'amélioration de l'InlineArrayAttribute et de l'introduction d'Interceptors

Microsoft présente un aperçu de trois nouvelles fonctionnalités de C# 12, dont les constructeurs primaires pour les classes ou les structures et la définition d'alias pour tous les types