C# 11 est la dernière version du langage phare de Microsoft. Annoncée en novembre 2022, elle apporte de nombreuses nouveautés et améliorations pour augmenter la productivité des développeurs. Dans cet article, nous allons examiner celles que je considère comme les plus importantes.

Le mot clé file

Le mot clé file permet de limiter l’étendue et la visibilité d’un type au fichier dans lequel il est créé. Cela éviter les collisions qu’on peut avoir lorsqu’on crée plusieurs types avec le même nom. On peut même créer d’autres types avec le même nom dans notre assembly.

La syntaxe est la suivante:

file class MyClass
{
    // implementation
}

Le modificateur required

Lorsque le mot clé required est devant une propriété cela signifie que celle-ci doit être définie lors de l’initialisation de l’objet. Il peut être utilisé dans les classes ou les structures.

Avec la classe Person suivante par exemple:

public class Person
{
    public required string  FirstName {get; set;}
    public string LastName { get; set; }
    public DateTime BirthDate { get; set; }

}

L’écriture suivante est incorrecte:

var p = new Person();

Il faut obligatoirement définir la propriété FirstName à l’initialisation:

var p = new Person() { FirstName = "toto"};

Les attributs génériques

Dans cette nouvelle version, il est désormais possible de créer des classes d’attribut génériques. On peut donc définir notre classe d’attribut et fixer un type dans sa définition.

Avant, c# 11, il fallait passer un type au constructeur de l’attribut:

public class OldAttribute : Attribute
{
    public Type ParamType { get; }

    public OldAttribute(Type t) => ParamType = t;
}

Cet attribut était ensuite utilisé de la sorte:

[OldAttribute(typeof(string))]
public double Method() => 0;

Avec C# 11, la syntaxe est la suivante:

public class GenericAttribute<T> : Attribute { }

Ce code s’utilise ainsi:

[GenericAttribute<string>()]
public bool Method() => true;

Les motifs de liste

Avec les motifs de liste, il est possible de faire correspondre un motif avec zéro, un ou plusieurs éléments d’un tableau ou d’une liste.

Exemple:

var numbers = new[] { 1, 2, 3, 4, 5 };
Console.WriteLine(numbers is [1, 2, 3, 4, 5]); // True 
Console.WriteLine(numbers is [1, 2, 5]); // False
Console.WriteLine(numbers is [1, 2, 3,..]); // True
Console.WriteLine(numbers is [_, 2, _, 4, 5]); // True 
Console.WriteLine(numbers is [_, >= 2, _, _, _]); // True
Console.WriteLine(numbers is [..]); // True

Les chaînes littérales brutes

Les chaînes littérales brutes permettent aux développeurs de créer des chaînes de caractères qui conservent exactement la même mise en forme que dans le code source, plus besoin d’utiliser des caractères d’échappement.

Un littéral de chaîne brute commence par au moins trois caractères guillemets doubles («  » »). Il se termine par le même nombre de guillemets doubles.

string longMessage = """
    There are several ways to make an HTTP request in JavaScript, but the most common is to use the XMLHttpRequest object.

    Here's an example of how to use XMLHttpRequest to make a GET request to a website:

    Copy code
    var xhr = new XMLHttpRequest();
    xhr.open("GET", "https://www.example.com", true);
    xhr.onreadystatechange = function() {
        if (xhr.readyState === 4 && xhr.status === 200) {
            console.log(xhr.responseText);
        }
    };
    xhr.send();
    """;

En conclusion, C# 11 apporte de nombreuses améliorations. Ces nouveautés montrent que Microsoft accorde énormément d’importance à ce langage et continue à répondre aux besoins en constante évolution des développeurs.