C # 8 Caractéristiques Nullable References

La prochaine version majeure du langage C # comprend de nouvelles fonctionnalités intéressantes. L'un d'eux est le type de référence nullable, ce qui permet d'éviter les exceptions de référence null non gérées qui ont ruiné nos applications à un moment donné. Continuez à lire pendant que je vous présente cette nouvelle fonctionnalité.

C # 8 est la prochaine version majeure du langage de programmation C #. Cela a enthousiasmé les membres de la communauté C #, car il comporte de nouvelles fonctionnalités intéressantes, et je suis ravi de pouvoir en partager certaines avec vous. Le plan est de publier C 8 en même temps que .NET Core 3.0, qui est toujours en aperçu. Je publierai quelques articles sur C # 8 où je vous présenterai brièvement certaines des fonctionnalités qui me passionnent, afin de vous intéresser également.

Dans cet article, je parlerai des types de référence nullables.

Installation de .NET Core 3

.NET Core 3 est toujours en avant-première et n’a pas été fourni avec la sortie de Visual Studio 2019 en avril. 2. Pour créer des projets .NET Core 3.0 avec VS2019, procédez comme suit:

• Téléchargez .NET Core 3.0
• Ouvrez Visual Studio
• Cliquez sur Outils > Options. dans le menu supérieur
• Développez Projets et solutions | .NET Core
• Cochez la case Utiliser les aperçus de la .NET Core SDK et cliquez sur OK pour enregistrer.

Ce paramètre vous permet de créer un nouveau projet. pouvez sélectionner .NET Core 3.0 comme infrastructure ciblée. Si vous utilisez macOS ou Linux, l'exécution de dotnet new [project type] vous lance avec .NET Core 3.0 comme infrastructure cible, que vous pouvez modifier à partir du fichier de projet si vous le souhaitez. Pour vous assurer que les fonctionnalités d'aperçu C # 8.0 sont disponibles, vous pouvez définir explicitement la propriété pour votre projet. Ce paramètre est enfoui profondément dans les paramètres avancés de l'onglet Construction de votre projet. Pour mettre à jour cela, suivez les instructions ci-dessous:

• Cliquez avec le bouton droit de la souris sur votre projet dans l'Explorateur de solutions.
• Sélectionnez Propriétés pour afficher les propriétés de votre projet.
• Cliquez sur l'onglet Générer dans les propriétés de votre projet
• . Bouton Avancé en bas à droite
• Sélectionnez C # 8.0 (version bêta) comme version linguistique

. Vous pouvez également définir cette option en modifiant le fichier .csproj et en ajoutant 8.0 . valeur pour l'élément .

  
     Exe 
     netcoreapp3.0 
     8.0 
  

Types de référence Nullables

En C #, l'une des différences entre les types de valeur et les types de référence est que les types de valeur ne sont pas nullables tandis que les types de référence sont nullables. Cela signifie que la déclaration int amount = null entraînera une erreur de construction alors que Account SavingsAccount = null est une syntaxe valide et que le compilateur se compile pour vous. Il est possible d'autoriser null pour les types de valeur si vous en avez vraiment besoin. Tout ce que vous devez faire est d’orner le type avec ? ou d’utiliser le type Nullable . Alors, int? amount = null devient un code valide et votre application peut compiler sans erreur.

Si vous programmez depuis un moment, vous avez peut-être rencontré plusieurs fois des exceptions non gérées NullReferenceException . Cela peut se produire pour diverses raisons et vous devez mettre en place des protections ou des contrôles pour éviter de rencontrer cette exception. Le type de référence nullable fourni avec C # 8 est conçu pour éviter les exceptions accidentelles de référence null. La fonctionnalité est conçue pour permettre aux définitions de type de variable de spécifier si elles peuvent se voir attribuer null ou non. Ainsi, par défaut, les types de référence ne sont pas nullables et vous devez utiliser ? avec le type pour spécifier qu'il peut accepter null comme valeur. Cela rend les types de référence non nullables et vous empêche d'attribuer la valeur à la variable null mais le fait avec un avertissement que vous voyez à la compilation et non avec des erreurs qui pourraient échouer lors de la construction. [19659003] Prenons un exemple:

 static void Main (string [] args)
{
  string firstName = "Jake";
  string middleName = null; // warning CS8600: Conversion du littéral null ou de la valeur null possible en type non nullable
  string lastName = "Archibald";

  PrintFullName (firstName, middleName, lastName); // warning CS8604: Argument de référence null possible pour le paramètre 'middle' dans 'void Program.PrintFullName (chaîne en premier, chaîne au milieu, chaîne en dernier)'
}

static void PrintFullName (chaîne en premier, chaîne au milieu, chaîne en dernier)
{
} 

L'extrait de code ci-dessus entraîne deux avertissements liés à une référence nullable. Les avertissements sont placés en tant que commentaires dans l'exemple. Les avertissements pointent vers middleName auquel une valeur null est attribuée et passée en paramètre à la méthode PrintFullName . Que se passe-t-il si le deuxième prénom est facultatif pour l'application? Vous pouvez marquer le type de variable comme nullable à l'aide de la syntaxe T? .

 static void Main (string [] args)
{
  string firstName = "Jake";
  chaîne? middleName = null;
  string lastName = "Archibald";
  PrintFullName (firstName, middleName, lastName);
}

static void PrintFullName (chaîne en premier, chaîne? milieu, chaîne en dernier)
{
  Console.WriteLine (middle? .Length);
  Console.WriteLine (premier + milieu + dernier);
} 

Dans le code ci-dessus, nous avons utilisé la chaîne ? pour marquer la variable et le type de paramètre comme étant nullable, et l'exécution de l'application ne génère aucun avertissement. Bien que la syntaxe T? soit utilisée pour désigner les types de référence nullables, il n'y a pas de forme longue pour cela. Vous pensez peut-être que vous pouvez utiliser Nullable mais cela ne fonctionnera pas et ne prend en charge que l'utilisation de la syntaxe T? .

Activer les types de référence nullables

Vous pouvez choisir de participer. utiliser cette fonctionnalité. Il peut être défini au niveau du projet ou dans un fichier source à l'aide des directives de pré-processeur #nullable et #pragma warning . Le contexte d'annotation Nullable et Le contexte d'avertissement Nullable détermine si les annotations Nullable sont effectives et si des avertissements de nullabilité sont donnés.

Pour activer cette fonctionnalité dans l'ensemble du projet, vous devez ajouter le [19659037] élément du premier PropertyGroup du fichier de projet.

  
     Exe 
     netcoreapp3.0 
     enable 
  
 

S'il n'y a pas de paramètre de niveau de projet, cette fonctionnalité est désactivée par défaut (c'est-à-dire que les deux contextes pouvant être annulés doivent être désactivés). La directive #nullable contrôle à la fois les contextes d'annotation et d'avertissement, tandis que les directives #pragma warning ... nullable contrôlent uniquement le contexte d'avertissement, laissant le contexte d'annotation inchangé.

 void Main (string [] args)
{
  #nullable enable
  string firstName = "Jake";
  string middleName = null; // warning CS8600: Conversion du littéral null ou de la valeur null possible en type non nullable.
  string lastName = "Archibald";
  #nullable restore

  PrintFullName (firstName, middleName, lastName);
}

static void PrintFullName (chaîne en premier, chaîne? milieu, chaîne en dernier) // warning CS8632: L'annotation pour les types de référence nullable ne doit être utilisée dans le code que dans un contexte '#nullable'
{
} 

Dans le code ci-dessus, le contexte Nullable est activé pour quelques lignes de code (en supposant qu'il soit désactivé dans le paramètre de projet) et le paramètre est restauré dans son contexte précédent avant que nous ne l'activions. Si nous avions utilisé #nullable disable cela l'aurait désactivé pour le code qui suit, ce qui pourrait ne pas être ce que vous voulez. Par conséquent, il vaut mieux utiliser la restauration et non la désactivation. Vous devriez remarquer l'avertissement qu'il donne à la ligne la méthode PrintFullName a été déclarée. En effet, nous avons utilisé la syntaxe pour créer un type de variable Nullable alors que la fonctionnalité est désactivée.

Pour plus d'informations sur les directives de contexte et de préprocesseur Nullable, consultez la spécification de fonctionnalité .

A Wrap 1965

La version 8 de C # 8 est la prochaine version majeure du langage C #, dotée de nouvelles fonctionnalités intéressantes. J'en partagerai quelques-unes avec vous dans quelques articles de blog à venir – j'ai parlé du type de référence nullable dans cet article. L'idée sous-jacente est de permettre aux développeurs de spécifier si une définition de type de variable ou de paramètre doit accepter null . Vous pouvez activer cette fonctionnalité et l'activer dans les paramètres du projet ou dans un fichier source à l'aide de directives de préprocesseur.