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

Le 23 février 2022 à 11:21, par Bill Fassinou

146PARTAGES

Microsoft a publié mardi un aperçu premier des nouvelles fonctionnalités de C# 11. Ces nouveautés incluent l'autorisation de nouvelles lignes dans les "trous" des chaînes interpolées, les motifs de liste, la vérification des paramètres null, etc. Selon Microsoft, Visual Studio 17.1 (Visual Studio 2022 Update 1) et .NET SDK 6.0.200 incluent des fonctionnalités de prévisualisation pour C# 11. Vous pouvez mettre à jour Visual Studio ou télécharger la dernière version du SDK .NET pour bénéficier de ces fonctionnalités. En attendant, voici les points forts de ce premier aperçu.

Autoriser les nouvelles lignes dans les "trous" des chaînes interpolées

C# supporte deux styles de chaînes interpolées : les chaînes interpolées verbatim et non verbatim ($@"" et $"", respectivement). Selon Kathleen Dollard de Microsoft, l'une des principales différences entre ces deux types de chaînes est qu'une chaîne interpolée non verbatim ne peut pas contenir de nouvelles lignes dans ses segments de texte et doit utiliser des échappatoires (comme rn). Une chaîne interpolée verbatim peut contenir de nouvelles lignes dans ses segments de texte, et n'échappe pas les nouvelles lignes ou tout autre caractère (à l'exception de "" pour échapper à une citation elle-même). Tout ce comportement reste le même.

Auparavant, ces restrictions s'étendaient aux trous des chaînes interpolées non verbatim. Les trous sont une façon abrégée de dire "expressions d'interpolation" et sont les portions à l'intérieur des accolades qui fournissent des valeurs d'exécution. Les trous eux-mêmes ne sont pas du texte, et ne doivent pas être soumis aux règles d'échappement/saut de ligne des segments de texte de la chaîne interpolée. Par exemple, l'exemple suivant aurait entraîné une erreur de compilation en C# 10, mais est autorisé dans cet aperçu de C# 11 :

Code C# :

Sélectionner tout

1
2
3
4
var v = $"Count ist: { this.Is.Really.Something() 
                            .That.I.Should( 
                                be + able)[ 
                                    to.Wrap()] }.";

Les motifs de liste (List patterns)

Selon l'équipe C#, le nouveau motif de liste vous permet d'établir des correspondances avec des listes et des tableaux. Vous pouvez faire correspondre des éléments et éventuellement inclure un motif de tranche qui correspond à zéro ou plusieurs éléments. En utilisant les motifs de tranche, vous pouvez écarter ou capturer zéro ou plusieurs éléments. La syntaxe des motifs de liste est constituée de valeurs entourées de crochets et celle des motifs de tranche de deux points. Le motif de tranche peut être suivi d'un autre motif de liste pour capturer le contenu de la tranche.

Le motif [1, 2, ..., 10] correspond à tous les éléments suivants :

Code C# :

Sélectionner tout

1
2
3
int[] arr1 = { 1, 2, 10 }; 
int[] arr1 = { 1, 2, 5, 10 }; 
int[] arr1 = { 1, 2, 5, 6, 7, 8, 9, 10 };

Pour explorer les modèles de liste, considérez :

Code C# :

Sélectionner tout

1
2
3
4
5
6
7
8
9
public static int CheckSwitch(int[] values) 
    => values switch 
    { 
        [1, 2, .., 10] => 1, 
        [1, 2] => 2, 
        [1, _] => 3, 
        [1, ..] => 4, 
        [..] => 50 
    };

Lorsqu'on lui passe les tableaux suivants, les résultats sont ceux indiqués :

Code C# :

Sélectionner tout

1
2
3
4
5
6
WriteLine(CheckSwitch(new[] { 1, 2, 10 }));          // prints 1 
WriteLine(CheckSwitch(new[] { 1, 2, 7, 3, 3, 10 })); // prints 1 
WriteLine(CheckSwitch(new[] { 1, 2 }));              // prints 2 
WriteLine(CheckSwitch(new[] { 1, 3 }));              // prints 3 
WriteLine(CheckSwitch(new[] { 1, 3, 5 }));           // prints 4 
WriteLine(CheckSwitch(new[] { 2, 5, 6, 7 }));        // prints 50

Vous pouvez également capturer les résultats d'un motif de tranche :

Code C# :

Sélectionner tout

1
2
3
4
5
6
public static string CaptureSlice(int[] values) 
    => values switch 
    { 
        [1, .. var middle, _] => $"Middle {String.Join(", ", middle)}", 
        [.. var all] => $"All {String.Join(", ", all)}" 
    };

Les motifs de liste fonctionnent avec tout type qui est dénombrable et indexable, ce qui signifie qu'il possède une propriété Length ou Count accessible et un indexeur avec un paramètre int ou System.Index. Les modèles de tranche fonctionnent avec tout type qui est dénombrable et "tranchable", ce qui signifie qu'il a un indexeur accessible qui prend un Range comme argument ou a une méthode Slice accessible avec deux paramètres int. L'équipe envisage également d'ajouter la prise en charge des motifs de liste pour les types IEnumerable.

Vérification des paramètres null

Dollard a déclaré que l'équipe a mis cette fonctionnalité dans ce premier aperçu pour s'assurer qu'elle a le temps de recevoir des commentaires. Selon elle, il y a eu des discussions sur une syntaxe très succincte par rapport à une syntaxe plus verbeuse. « Nous voulons obtenir les commentaires des clients et des utilisateurs qui ont eu la chance d'expérimenter cette fonctionnalité », a-t-elle déclaré. Il est assez courant de valider si les arguments d'une méthode sont null avec des variations de code passe-partout comme :

Code C# :

Sélectionner tout

1
2
3
4
5
6
7
8
public static void M(string s) 
{ 
    if (s is null) 
    { 
        throw new ArgumentNullException(nameof(s)); 
    } 
    // Body of the method 
}

Avec la vérification des paramètres null, vous pouvez abréger votre intention en ajoutant !! au nom du paramètre :

Code C# :

Sélectionner tout

1
2
3
4
public static void M(string s!!) 
{ 
    // Body of the method 
}

Ainsi, du code sera généré pour effectuer le contrôle de nullité. Le contrôle de nullité généré sera exécuté avant tout code de la méthode. Pour les constructeurs, la vérification des paramètres null se produit avant l'initialisation du champ, les appels aux constructeurs de base et les appels à ce constructeur. De plus, l'équipe a déclaré que cette fonctionnalité est indépendante des types de référence nullable (NRT - Nullable Reference Types), bien qu'elles fonctionnent bien ensemble. NRT vous aide à savoir, au moment de la conception, si un null est possible.

La vérification des paramètres null permet de vérifier plus facilement, au moment de l'exécution, si des valeurs null ont été transmises à votre code. Ceci est particulièrement important lorsque votre code interagit avec du code externe qui peut ne pas avoir de NRT activé. La vérification est similaire à if (param is null) throw new ArgumentNullException(...). Lorsque plusieurs paramètres contiennent l'opérateur !!, les vérifications sont effectuées dans l'ordre de déclaration des paramètres. Il existe quelques directives limitant l'utilisation de l'opérateur !!, notamment :

les contrôles de nullité ne peuvent être appliqués aux paramètres que lorsqu'il existe une implémentation. Par exemple, un paramètre de méthode abstraite ne peut pas utiliser !!. Parmi les autres cas où il ne peut pas être utilisé, citons : les paramètres de méthodes externes, les paramètres des délégués, les paramètres des méthodes d'interface lorsque la méthode n'est pas une méthode d'interface par défaut (DIM - Default Interface Method) ;
les contrôles de nullité ne peuvent être appliqués qu'aux paramètres qui peuvent être vérifiés.

Les paramètres de rejet et de sortie sont un exemple de scénarios exclus en vertu de la deuxième règle. Le contrôle des valeurs null peut être effectué sur les paramètres ref et in. La vérification du caractère null est autorisée pour les paramètres de l'indexeur, et la vérification est ajoutée à l'accesseur get et set. Par exemple :

Code C# :

Sélectionner tout

public string this[string key!!] { get { ... } set { ... } }

Les contrôles de nullité peuvent être utilisés sur les paramètres lambda, qu'ils soient ou non entourés de parenthèses :

Code C# :

Sélectionner tout

1
2
// An identity lambda which throws on a null input 
Func<string, string> s = x!! => x;

Les méthodes asynchrones peuvent avoir des paramètres vérifiés comme null. La vérification de la nullité a lieu lorsque la méthode est invoquée. La syntaxe est également valable pour les paramètres des méthodes d'itération. La vérification du caractère null se produit lorsque la méthode de l'itérateur est invoquée, et non lorsque l'énumérateur sous-jacent est parcouru. Ceci est vrai pour les itérateurs traditionnels ou asynchrones :

Code C# :

Sélectionner tout

1
2
3
4
5
6
7
8
9
10
11
12
class Iterators { 
    IEnumerable<char> GetCharacters(string s!!) { 
        foreach (var c in s) { 
            yield return c; 
        } 
    } 
  
    void Use() { 
        // The invocation of GetCharacters will throw 
        IEnumerable<char> e = GetCharacters(null); 
    } 
}

Interaction avec les types de référence null

Tout paramètre dont le nom est accompagné de l'opérateur !! commencera avec l'état nullable, c'est-à-dire non null. Ceci est vrai même si le type du paramètre lui-même est potentiellement null. Cela peut se produire avec un type explicitement nullable, comme string?, ou avec un paramètre de type non contraint. Lorsque la syntaxe !! sur les paramètres est combinée avec un type explicitement nullable sur le paramètre, le compilateur émet un avertissement :

Code C# :

Sélectionner tout

1
2
3
4
void WarnCase<T>( 
    string? name!!,     // CS8995   Nullable type 'string?' is null-checked and will throw if null.  
    T value1!!        // Okay 
)

Constructeurs

Selon l'équipe, il y a un petit changement, mais observable, lorsque vous passez de contrôles de nullité explicites dans votre code à des contrôles de nullité utilisant la syntaxe de vérification des nullités (!!). Votre vérification explicite se produit après les initialisateurs de champ, les constructeurs de classe de base et les constructeurs appelés à l'aide de ceci. Les contrôles de nullité effectués avec la syntaxe de contrôle de nullité des paramètres se produiront avant l'exécution de l'un de ces éléments.

Source : Microsoft

Et vous ?