Ce qui a été ajouté à C# 10

Voici quelques-unes de mes nouvelles fonctionnalités préférées dans C# 10 et comment je me vois les utiliser.

Dans un précédent postj'ai parlé de toutes les nouvelles fonctionnalités de C# 9. Avec le version de .NET 6 récemment, je voulais partager certaines des nouvelles fonctionnalités de langage de C# 10.

Jetons un coup d'œil à certaines des nouvelles fonctionnalités de langage.

Gain de temps

.NET en a ajouté quelques-unes fonctionnalités au langage qui peuvent vous faire gagner beaucoup de temps.

Espaces de noms à portée de fichier

À mon avis, les espaces de noms à portée de fichier sont un excellent moyen d'organiser votre code. Ils vous permettent d'organiser votre code en groupes logiques et d'éviter que votre code ne soit trop encombré.

Les espaces de noms à portée de fichier vous permettent d'enregistrer certaines frappes et indentations dans votre code. Maintenant, vous pouvez déclarer votre espace de noms en haut de votre fichier, en supposant que vous n'ayez qu'un seul espace de noms pour votre fichier. Ce que je pense que vous devriez toujours faire.

Ancien code :

namespace MyNamespace
{
  class MaClass
  {
    public void MaMéthode()
    {
        
    }
  }[19659022]}

Devient maintenant :

namespace MyNamespace;

class MyClass
{
  public void MyMethod([19659017])
  {
      
  }
}

Maintenant, nous enregistrons deux accolades et un niveau d'indentation. J'aimerais en quelque sorte que cette fonctionnalité soit dans .NET 1, car vous ne devriez vraiment avoir qu'un seul espace de noms par fichier. 😄

Global Using Directives

À quelle fréquence voyez-vous ou saisissez-vous les mêmes espaces de noms encore et encore ? using System;pour moi, est déclaré dans presque tous les fichiers de mon projet. Avec les directives Global Using Directives de C# 10, vous pouvez déclarer vos directives using en haut de votre fichier, puis les utiliser tout au long de votre fichier. Maintenant, je peux ajouter global using System; à un fichier de mon projet, et l'instruction using sera référencée dans tous mes fichiers/classes.

Je me vois utiliser régulièrement le code suivant dans mon projet maintenant :

global using System;
global using System.Collections.Generic;
global using System.Linq;

Bien que cela ne soit pas requis, je vous recommande de placer tous vos global en utilisant des directives dans un nom de fichier standard dans vos projets. Je prévois d'utiliser GlobalUsings.csmais n'hésitez pas à utiliser ce que vous voulez.

Si mettre vos directives global using dans un fichier n'est pas votre préférence, vous pouvez également ajouter dans votre fichier .csproj. Si je voulais inclure les trois directives global using ci-dessus dans mon fichier .csprojj'ajouterais ce qui suit à mon fichier .csproj :

< ItemGroup>
  <Utiliser Inclure="Système" />
  <Utiliser Inclure=[19659050]"System.Collections.Generic" />
  <Utilisation d'Inclure="System.Linq" />
<[19659052]/ItemGroup>

L'une ou l'autre approche fonctionnera, mais l'approche .csproj semble être plus facile à découvrir.

Si global using est pas votre truc ou celui de votre équipe, vous pouvez le désactiver en ajoutant ce qui suit à votre fichier .csproj :

<PropertyGroup>
  <ImplicitUsings >désactiver</ImplicitUsings> 
</PropertyGroup>

Extended Property Patterns

Pattern Matching a été introduit dans C# 7. Il vous permet de faire correspondre les propriétés de un objet contre un motif. La correspondance de motifs est un excellent moyen d'écrire un code plus propre. Dans C# 8, la fonctionnalité Property Patterns a été ajoutée, ce qui vous a permis de faire correspondre les propriétés d'un objet comme celui-ci :

Person person = new Person  {
  Prénom = "Joe",
  Nom = "Guadagno",
  Adresse = nouvelle Adresse {
    Ville = "Chandler",
    État = "AZ"
  }
}



if (personne est Personne {Adresse : {State: "AZ"}})
{
  
}

Maintenant avec C# 10, vous pouvez référencer propriétés imbriquées des objets avec notation par points. Par exemple, vous pouvez comparer les propriétés City et State d'un objet Person comme ceci :

if (person est Personne {Adresse.État: "AZ"})
{
  
}[19659105]Améliorations des chaînes
C# 10 a apporté des améliorations aux chaînes interpolées dans C# 10. Les variables const peuvent désormais être utilisées avec des chaînes interpolées.
J'ai du mal à trouver un "réel ]" exemple de ceci, voici donc un exemple de comment cela fonctionne :



  


               




const string salutation = "Bonjour";
const string  nom = "Joe";
const string message = $"{salutation}, {nom} ! ";
La variable message sera la val ue de Bonjour, Joe!.
L'interpolation n'a pas seulement été améliorée pour les consts mais pour les variables qui peuvent être déterminées au moment de la compilation. Disons que vous maintenez une bibliothèque et que vous décidez de rendre obsolète une méthode nommée OldMethod. Dans le passé, vous deviez faire quelque chose comme ceci :
public class MyClass
{
    [Obsolete($"Utiliser NouvelleMéthode à la place", true)]
    public void AncienneMéthode() { }

     public void NewMethod() { }
}
Mais maintenant, vous pouvez faire ceci :
public class[19659012]MaClasse
{
    [Obsolète($"Utiliser {nameof(NewMethod)} à la place", true) ]
    public void AncienneMéthode() { }

    public void NouvelleMéthode()[19659075]{ }
}
Cela facilite la mise à jour de votre code lorsque vous en avez besoin. Désormais, vous n'avez plus besoin de vous souvenir partout où vous avez utilisé le nom hardcoded de la méthode que vous souhaitez rendre obsolète.
CallerArgumentExpression
CallerArgumentExpression L'attribut est une nouvelle fonctionnalité de C# 10 qui vous permet de capturer l'expression qui est transmise à une méthode qui est utile à des fins de débogage.
 Disons que nous avons une méthode appelée Validate qui vérifie et valide les propriétés assorties d'une Person objet.
public static class Validation {
  public static book IsValid(Person personne)
  {
    Debug.Assert(person != null);
    Debug.Assert(!string.IsNullOrEmpty(person.Prénom)[19659017]);
    Debug.Assert(!string.IsNullOrEmpty(person.LastName)[19659017]);
    Debug.Assert(!string.IsNullOrEmpty(person.Adresse.Ville));
    Debug.Assert(person.Age > 18);
    retour true[19659017];
  }
}
Nous avons maintenant le code suivant qui appelle la méthode Validate :
Person person;
var result = Validation.EstValide(person);

Personne personne = nouveau Person{
  Prénom = "Joe",
  Nom = "Guadagno",
  Adresse = nouvelle Adresse {
    Ville = "Chandler",
    État = "AZ"
  },
  Âge = 17
};
result = Validation.IsValid(person); 
Chaque appel échouera car au moins une assertion échoue. Mais lequel a échoué ? C'est là que CallerArgumentExpression entre en jeu. Pour résoudre ce problème, nous allons créer une méthode personnalisée Assert et ajouter l'attribut CallerArgumentExpression à la méthode :
public static void Assert[19659017](bool condition, [CallerArgumentExpression("condition")] chaîne expression = default)
{
  if (!condition)
  {
    Console.WriteLine($"La condition a échoué : {expression}");
  }
}
Maintenant si nous appelez la méthode Validate avec l'exemple ci-dessus, nous obtiendrons la sortie suivante :
Condition failed : person != null
and
Condition échec : person.Age > 18)
Null Argument Checks
L'introduction de l'attribut CallerArgumentExpression a permis quelques nouvelles méthodes d'extension au framework. Par exemple, il existe maintenant une méthode d'extension ThrowIfNull qui peut être utilisée pour lever une ArgumentNullException si l'argument est null.
Nous plus besoin d'écrire ceci :
if (argument est null)
{
    throw new ArgumentNullException (nom de(argument));
}
Nous pouvons maintenant écrire ceci :
ArgumentNullException.ThrowIfNull (argument);
La méthode, en coulisse, ressemble à ceci :
public static void ThrowIfNull( 
    [NotNull] object? argument,
    [CallerArgumentExpression("argument") ] stri ng? paramName = null)
    {
        if (argument est null)[19659334]{
            throw new ArgumentNullException(paramName);
        }
    }
Conclusion
C'est pas une liste exhaustive des nouvelles fonctionnalités de langage introduites dans C# 10. Pour voir ce qui a été ajouté à C# 10, consultez  Quoi de neuf dans C# 10.0.