Exercice - Explorer le cast et la conversion de types de données

30 minutes

Il existe plusieurs techniques pour effectuer une conversion de type de données. La technique que vous choisissez dépend de votre réponse à deux questions importantes :

Est-il possible, en fonction de la valeur, qu’une tentative de changement du type de données de la valeur lève une exception au moment de l’exécution ?
Est-il possible, en fonction de la valeur, qu’une tentative de changement du type de données de la valeur entraîne une perte d’informations ?

Dans cet exercice, vous allez vous pencher sur ces questions, sur ce qu’impliquent leurs réponses et sur la technique à utiliser quand vous avez besoin de changer de type de données.

Préparer votre environnement de programmation

Ce module comprend des activités pratiques qui vous guident tout au long du processus de création et d’exécution du code de démonstration. Nous vous encourageons à effectuer ces activités à l’aide de Visual Studio Code comme environnement de développement. L’utilisation de Visual Studio Code pour ces activités vous permet d’être plus à l’aise dans l’écriture et l’exécution de code dans un environnement de développement qui est utilisé par les professionnels du monde entier.

Notes

Si vous avez suivi d’autres modules Microsoft Learn dans cette série C#, vous avez peut-être déjà créé un dossier de projet pour les exemples de code. Le cas échéant, vous pouvez ignorer la série d’étapes suivante et supprimer le code dans le fichier Program.cs qui a été utilisé dans un exercice précédent.

Notes

Les exemples de code de cet exercice sont conçus en fonction des paramètres culturels américains et l’utilisation du point (.) sert de séparateur décimal. La création et l’exécution du code avec un paramètre culturel qui utilise un séparateur décimal différent (par exemple une virgule ,) peuvent entraîner des résultats ou des erreurs inattendus. Pour résoudre ce problème, remplacez les points séparateurs de décimale dans les exemples de code par votre séparateur décimal local (, par exemple). Sinon, pour exécuter un programme à l’aide du paramètre culturel américain, ajoutez le code suivant en haut de votre programme using System.Globalization; et, après toute autre instruction using, ajoutez CultureInfo.CurrentCulture = new CultureInfo("en-US");.

Ouvrez Visual Studio Code.

Vous pouvez utiliser le menu Démarrer de Windows (ou une ressource équivalente pour un autre système d’exploitation) pour ouvrir Visual Studio Code.
Dans Visual Studio Code, dans le menu Fichier, sélectionnez Ouvrir un dossier.
Dans la boîte de dialogue Ouvrir un dossier, accédez au dossier Bureau Windows.

Si vous avez un autre emplacement de dossier où vous conservez des projets de code, vous pouvez utiliser cet emplacement de dossier à la place. Pour cette formation, l’important est d’avoir un emplacement facile à localiser et à mémoriser.
Dans la boîte de dialogue Ouvrir un dossier, sélectionnez Sélectionner un dossier.

Si une boîte de dialogue de sécurité vous demande si vous faites confiance aux auteurs, sélectionnez Oui.
Dans le menu Terminal de Visual Studio Code, sélectionnez Nouveau Terminal.

Notez qu’une invite de commandes dans le panneau Terminal affiche le chemin du dossier actif. Par exemple :
```
C:\Users\someuser\Desktop>
```
Pour créer une application console dans un dossier spécifié, à l’invite de commandes du Terminal, tapez dotnet new console -o ./CsharpProjects/TestProject, puis appuyez sur Entrée.

Cette commande CLI .NET utilise un modèle de programme .NET pour créer un projet d’application console C# à l’emplacement du dossier spécifié. La commande crée les dossiers CsharpProjects et TestProject pour vous, et utilise TestProject comme nom du fichier .csproj.
Dans le panneau EXPLORATEUR, développez le dossier CsharpProjects.

Vous devriez voir le dossier TestProject et deux fichiers, un fichier programme C# nommé Program.cs et un fichier projet C# nommé TestProject.csproj.
Dans le panneau EXPLORATEUR, pour voir votre fichier de code dans le panneau de l’Éditeur, sélectionnez Program.cs.
Supprimez les lignes de code existantes.

Vous pouvez utiliser ce projet de console C# pour créer, générer et exécuter des exemples de code au cours de ce module.
Fermez le panneau du Terminal.

Question : Est-il possible qu’une tentative de changement du type de données de la valeur lève une exception au moment de l’exécution ?

Le compilateur C# essaie de s’adapter à votre code, mais il ne compile pas les opérations susceptibles de lever une exception. Quand vous comprenez la principale préoccupation du compilateur C#, vous comprendrez plus facilement son mode de fonctionnement.

Écrire du code qui tente d’additionner un `int` et un `string` avant d’enregistrer le résultat dans un `int`

Vérifiez que Visual Studio Code est ouvert et que Program.cs est affiché dans le panneau Éditeur.

Notes

Program.cs doit être vide. Si ce n’est pas le cas, sélectionnez toutes les lignes de code et supprimez-les.
Tapez le code suivant dans l’Éditeur Visual Studio Code :
```
int first = 2;
string second = "4";
int result = first + second;
Console.WriteLine(result);
```
Ici, vous essayez d’additionner les valeurs 2 et 4. La valeur 4 est de type string. Cela va-t-il fonctionner ?
Dans le menu Fichier de Visual Studio Code, sélectionnez Enregistrer.

Vous devez enregistrer le fichier Program.cs avant de générer ou d’exécuter le code.
Dans le panneau EXPLORATEUR, pour ouvrir un Terminal à l’emplacement de votre dossier TestProject, cliquez avec le bouton droit sur TestProject, puis sélectionnez Ouvrir dans le Terminal intégré.

Un panneau Terminal doit s’ouvrir et inclure une invite de commandes indiquant que le Terminal est ouvert à l’emplacement de votre dossier TestProject.
À l’invite de commandes Terminal, pour exécuter votre code, tapez dotnet run, puis appuyez sur Entrée.

Vous devriez voir la sortie approximative suivante.
```
C:\Users\someuser\Desktop\csharpprojects\TestProject\Program.cs(3,14): error CS0029: Cannot implicitly convert type 'string' to 'int'
```
Notes

Si vous voyez un message indiquant « Impossible de trouver un projet à exécuter », vérifiez que l’invite de commandes Terminal affiche l’emplacement attendu du dossier TestProject. Par exemple : C:\Users\someuser\Desktop\csharpprojects\TestProject>
Prenez quelques instants pour réfléchir à la raison pour laquelle le compilateur n’a pas pu exécuter le premier exemple de code.

La partie importante du message d’erreur, (3,14): error CS0029: Cannot implicitly convert type 'string' to 'int', vous indique que le problème est lié à l’utilisation du type de données string.

Mais pourquoi le compilateur C# ne peut-il pas simplement gérer l’erreur ? Après tout, vous pouvez faire l’inverse pour concaténer un nombre en string, puis l’enregistrer dans une variable de chaîne. Ici, vous changez le type de données result de la variable int en string.

Mettez à jour votre code dans l’Éditeur Visual Studio Code comme suit :

int first = 2;
string second = "4";
string result = first + second;
Console.WriteLine(result);

Enregistrez votre fichier de code, puis utilisez Visual Studio Code pour exécuter votre code.

Vous devriez observer la sortie suivante :
```
24
```
La sortie est mathématiquement incorrecte, mais se termine en combinant les valeurs en tant que caractères « 2 » et « 4 ».
Examinez, une fois de plus, le premier exemple de code où la variable result est de type int. Le code avec le message d’erreur.
```
int first = 2;
string second = "4";
int result = first + second;
Console.WriteLine(result);
```
Pourquoi le compilateur C# ne peut-il pas comprendre que vous voulez traiter la variable second contenant 4 comme un nombre et pas comme un type string ?

Les compilateurs effectuent des conversions sécurisées

Le compilateur C# détecte un problème potentiel dans la construction. La variable second est de type string, donc elle risque d’être définie avec une autre valeur comme "hello". Si le compilateur C# tente de convertir "hello" en nombre, une exception est levée au moment de l’exécution. Pour éviter cette éventualité, le compilateur C# n’effectue pas implicitement la conversion de string en int à votre place.

Pour le compilateur C#, l’opération la plus sûre consiste à convertir int en string, puis à effectuer plutôt une concaténation.

Si vous avez l’intention d’effectuer une addition avec une chaîne, le compilateur C# vous oblige à contrôler plus explicitement le processus de conversion des données. En d’autres termes, il vous oblige à vous impliquer davantage afin de mettre en place les précautions appropriées pour gérer l’éventualité d’une levée d’exception par la conversion.

Si vous avez besoin de changer le type de données d’une valeur et que le changement risque de lever une exception au moment de l’exécution, vous devez effectuer une conversion de données.

Pour effectuer une conversion de données, vous pouvez utiliser l’une des différentes techniques suivantes :

Utiliser une méthode d’assistance sur le type de données
Utiliser une méthode d’assistance sur la variable
Utiliser les méthodes de la classe Convert

Vous examinerez quelques exemples de ces techniques de conversion des données plus loin dans cette unité.

Question : Est-il possible qu’une tentative de changement du type de données de la valeur entraîne une perte d’informations ?

Supprimez ou utilisez l’opérateur de commentaire de ligne // pour commenter le code de l’étape précédente de l’exercice, puis ajoutez le code suivant :
```
int myInt = 3;
Console.WriteLine($"int: {myInt}");

decimal myDecimal = myInt;
Console.WriteLine($"decimal: {myDecimal}");
```
Enregistrez votre fichier de code, puis utilisez Visual Studio Code pour exécuter votre code.

Vous devez normalement voir la sortie suivante :
```
int: 3
decimal: 3
```
La ligne de code qui nous intéresse dans cet exemple est la suivante :
```
decimal myDecimal = myInt;
```
Étant donné qu’une valeur int peut facilement tenir dans un decimal, le compilateur effectue la conversion.

Le terme conversion étendue signifie que vous tentez de convertir une valeur depuis un type de données qui peut contenir moins d’informations vers un type de données qui peut en contenir plus. Dans ce cas, une valeur stockée dans une variable de type int convertie en variable de type decimal ne perd pas d’informations.

Quand vous savez que vous effectuez une conversion étendue, vous pouvez vous fier à une conversion implicite. Le compilateur gère les conversions implicites.

Effectuer un cast

Supprimez ou utilisez l’opérateur de commentaire de ligne // pour commenter le code de l’étape précédente de l’exercice, puis ajoutez le code suivant :
```
decimal myDecimal = 3.14m;
Console.WriteLine($"decimal: {myDecimal}");

int myInt = (int)myDecimal;
Console.WriteLine($"int: {myInt}");
```
Pour effectuer un cast, vous utilisez l’opérateur de cast () pour entourer un type de données, puis vous le placez en regard de la variable à convertir. Par exemple : (int)myDecimal. Vous effectuez une conversion explicite vers le type de données de cast défini (int).
Enregistrez votre fichier de code, puis utilisez Visual Studio Code pour exécuter votre code.

Vous devez normalement voir la sortie suivante :
```
decimal: 3.14
int: 3
```
La ligne de code qui nous intéresse dans cet exemple est la suivante :
```
int myInt = (int)myDecimal;
```
La variable myDecimal contient une valeur avec une précision après la virgule. En ajoutant l’instruction de cast (int), vous indiquez au compilateur C# que vous comprenez qu’il est possible que vous perdiez cette précision, et que dans ce cas, ce n’est pas grave. Vous indiquez au compilateur que vous effectuez une conversion intentionnelle, c’est-à-dire une conversion explicite.

Déterminer si votre conversion est une « conversion étendue » ou une « conversion restrictive »

Le terme conversion restrictive signifie que vous tentez de convertir une valeur à partir d’un type de données qui peut contenir plus d’informations vers un type de données qui peut en contenir moins. Dans ce cas, vous risquez de perdre des informations comme la précision (autrement dit, le nombre de valeurs après la virgule décimale). Un exemple est la conversion d’une valeur stockée dans une variable de type decimal en variable de type int. Si vous affichez les deux valeurs, vous remarquerez peut-être la perte d’informations.

Quand vous savez que vous effectuez une conversion restrictive, vous devez effectuer un cast. Un cast est une instruction adressée au compilateur C# qui lui indique que vous savez une perte de précision possible, mais que vous l’acceptez.

Si vous ne savez pas si vous perdez des données lors de la conversion, écrivez du code pour effectuer une conversion de deux manières différentes et observez les changements. Les développeurs écrivent fréquemment de petits tests pour mieux comprendre les comportements, comme le montre l’exemple suivant.

Supprimez ou utilisez l’opérateur de commentaire de ligne // pour commenter le code de l’étape précédente de l’exercice, puis ajoutez le code suivant :
```
decimal myDecimal = 1.23456789m;
float myFloat = (float)myDecimal;

Console.WriteLine($"Decimal: {myDecimal}");
Console.WriteLine($"Float  : {myFloat}");
```
Enregistrez votre fichier de code, puis utilisez Visual Studio Code pour exécuter votre code.

La sortie doit ressembler à celle-ci :
```
Decimal: 1.23456789
Float  : 1.2345679
```
Si vous examinez la sortie, vous pouvez voir que le cast d’un decimal en float est une conversion restrictive car vous perdez en précision.

Réalisation de conversions de données

Nous avons vu précédemment que le fait de changer le type de données d’une valeur pouvait entraîner une exception au moment de l’exécution et qu’il était préférable d’effectuer une conversion de données. Vous avez le choix entre trois techniques de conversion de données :

Utiliser une méthode d’assistance sur la variable
Utiliser une méthode d’assistance sur le type de données
Utiliser les méthodes de la classe Convert

Utiliser `ToString()` pour convertir un nombre en `string`

Chaque variable de type de données a une méthode ToString(). Ce que fait la méthode ToString() dépend de la façon dont elle est implémentée sur un type donné. Toutefois, sur la plupart des primitives, elle effectue une conversion étendue. Bien que cela ne soit pas strictement nécessaire (puisque vous pouvez vous fier à une conversion implicite dans la plupart des cas), cette méthode peut communiquer à d’autres développeurs que vous comprenez ce que vous faites et qu’elle est délibérée.

Voici un exemple rapide d’utilisation de la méthode ToString() pour convertir explicitement des valeurs int en string.

Supprimez ou utilisez l’opérateur de commentaire de ligne // pour commenter le code de l’étape précédente de l’exercice, puis ajoutez le code suivant :
```
int first = 5;
int second = 7;
string message = first.ToString() + second.ToString();
Console.WriteLine(message);
```
Enregistrez votre fichier de code, puis utilisez Visual Studio Code pour exécuter votre code. Quand vous exécutez le code, le résultat doit afficher une concaténation des deux valeurs :
```
57
```

Convertir un `string` en `int` en utilisant la méthode d’assistance `Parse()`

La plupart des types de données numériques ont une méthode Parse() qui convertit une chaîne en valeur du type de données choisi. Dans ce cas, vous utilisez la méthode Parse() pour convertir deux chaînes en valeurs int, puis vous les additionnez.

Supprimez ou utilisez l’opérateur de commentaire de ligne // pour commenter le code de l’étape précédente de l’exercice, puis ajoutez le code suivant :
```
string first = "5";
string second = "7";
int sum = int.Parse(first) + int.Parse(second);
Console.WriteLine(sum);
```
Enregistrez votre fichier de code, puis utilisez Visual Studio Code pour exécuter votre code. Quand vous exécutez le code, le résultat doit afficher une somme des deux valeurs :
```
12
```
Prenez quelques instants pour essayer de repérer le problème potentiel dans l’exemple de code précédent. Que se passe-t-il si l’une des variables first ou second a une valeur qui ne peut pas être convertie en int ? Une exception est levée au moment de l’exécution. Le compilateur et le runtime C# s’attendent à ce que vous vous organisiez à l’avance et que vous empêchiez les conversions « illégales ». Vous pouvez atténuer l’exception du runtime de plusieurs façons.

Le moyen le plus simple d’atténuer cette situation consiste à utiliser TryParse(), qui est une meilleure version de la méthode Parse().

Convertir un type `string` en `int` en utilisant la classe `Convert`

La classe Convert comporte de nombreuses méthodes d’assistance pour convertir une valeur d’un type vers un autre. Dans l’exemple de code suivant, vous convertissez deux chaînes en valeurs de type int.

Supprimez ou utilisez l’opérateur de commentaire de ligne // pour commenter le code de l’étape précédente de l’exercice, puis ajoutez le code suivant :
```
string value1 = "5";
string value2 = "7";
int result = Convert.ToInt32(value1) * Convert.ToInt32(value2);
Console.WriteLine(result);
```
Enregistrez votre fichier de code, puis utilisez Visual Studio Code pour exécuter votre code.

Vous devez normalement voir la sortie suivante :
```
35
```
Notes

Pourquoi le nom de la méthode est-il ToInt32() ? Pourquoi n’est-il pas ToInt() ? System.Int32 est le nom du type de données sous-jacent dans la bibliothèque de classes .NET que le langage de programmation C# mappe au mot clé int. Étant donné que la classe Convert fait aussi partie de la bibliothèque de classes .NET, elle est appelée par son nom complet, et non par son nom C#. En définissant les types de données dans le cadre de la bibliothèque de classes .NET, plusieurs langages .NET comme Visual Basic, F#, IronPython parmi d’autres peuvent partager les mêmes types de données et les mêmes classes dans la bibliothèque de classes .NET.

La méthode ToInt32() a 19 versions surchargées, ce qui lui permet d’accepter pratiquement tous les types de données.

Ici, vous avez utilisé la méthode Convert.ToInt32() avec une chaîne, mais songez à utiliser TryParse() dans la mesure du possible.

Alors, quand devez-vous utiliser la classe Convert ? La classe Convert convient parfaitement pour convertir des nombres fractionnaires en nombres entiers (int), car elle arrondit comme vous le voulez.

Comparer le cast et la conversion d’un type `decimal` en `int`

L’exemple suivant montre ce qui se passe quand vous tentez de caster un decimal en int (conversion restrictive) par rapport à ce qui se passe quand vous utilisez la méthode Convert.ToInt32() pour convertir le même decimal en int.

Supprimez ou utilisez l’opérateur de commentaire de ligne // pour commenter le code de l’étape précédente de l’exercice, puis ajoutez le code suivant :
```
int value = (int)1.5m; // casting truncates
Console.WriteLine(value);

int value2 = Convert.ToInt32(1.5m); // converting rounds up
Console.WriteLine(value2);
```
Enregistrez votre fichier de code, puis utilisez Visual Studio Code pour exécuter votre code.

Vous devez normalement voir la sortie suivante :
```
1
2
```

Les casts tronquent et les conversions arrondissent

Quand vous castez int value = (int)1.5m;, la valeur du flottant est tronquée de sorte que le résultat est 1, ce qui signifie que la valeur après la décimale est complètement ignorée. Vous pouvez changer le flottant littéral en 1.999m : le résultat du cast serait le même.

Lors de la conversion avec Convert.ToInt32(), la valeur du flottant littéral est correctement arrondie au chiffre supérieur 2. Si vous remplacez la valeur du littéral par 1.499m, elle est arrondie au chiffre inférieur 1.

Récapitulatif

Vous avez abordé plusieurs concepts importants liés à la conversion et au cast de données :

Empêcher une erreur d’exécution lors d’une conversion de données
Effectuer un cast explicite pour indiquer au compilateur que vous comprenez le risque de perte de données
Se fier au compilateur pour effectuer un cast implicite lors d’une conversion étendue
Utiliser l’opérateur de cast () et le type de données pour effectuer un cast (par exemple, (int)myDecimal)
Utiliser la classe Convert quand vous voulez effectuer une conversion restrictive, mais avec un arrondi, et non une troncation des informations

Commentaires

Est-ce que cette page vous a été utile?

Exercice - Explorer le cast et la conversion de types de données

Vérifiez vos connaissances

Commentaires