Aller au contenu

Fiche: Conversions de types

Cette fiche résume les conversions implicites/explicites, l’usage de Convert, Parse/TryParse.

Dans nos programmes, nous allons très souvent avoir besoin de manipuler des données entre elles alors qu'elles ne sont pas forcément du même type.
Lorsque cela sera possible, nous aurons besoin de convertir un type de données en un autre.
Etant donné que C # est typé statiquement au moment de la compilation, une fois qu'une variable est déclarée, elle ne peut pas être déclarée à nouveau ou assignée à une valeur d'un autre type à moins que ce type ne soit implicitement convertible en type de variable.

Panorama rapide

  • Conversion implicite : sûre, aucune perte d'information (ex. int → long).
  • Conversion explicite (cast) : nécessaire quand il y a risque de perte (ex. double → int).
  • Convert : méthodes utilitaires pour changer de type avec des règles précises (null-handling, arrondis…).
  • Parse/TryParse : convertir depuis une chaîne vers un type (ex. "42" → int).

1) Conversions implicites (sans cast)

En C#, une conversion de type implicite se produit lorsque le compilateur effectue automatiquement la conversion d'un type de données à un autre sans nécessiter une intervention explicite du programmeur.
Cette conversion est effectuée lorsque le type source peut être converti de manière sûre et sans perte de données au type de destination.

En d'autres termes, le compilateur reconnaît que la conversion est sûre et la réalise automatiquement. Cependant, il est important de noter que toutes les conversions implicites ne sont pas toujours possibles.

Si une conversion peut entraîner une perte de données ou si elle n'est pas sûre, une conversion explicite (aussi appelée "casting") doit être effectuée par le programmeur.

Les conversions numériques élargissantes sont implicites :

  • byte → short → int → long → float → double
  • char → int (→ long → …)
  • decimal n’accepte pas d’implicite depuis float/double (il faut un cast explicite).
Image title
Conversion Implicite
int i = 42;
long L = i;          // implicite : OK
double d = L;        // implicite : OK

Bon à savoir

Les conversions implicites existent aussi entre types personnalisés si vous déclarez des opérateurs implicit (opérateurs spéciaux en C# que tu peux définir dans tes propres classes ou structs - pas abordé dans ce module !)

2) Conversions explicites (cast)

En C#, une conversion de type explicite, également appelée "casting", se produit lorsque le programmeur indique explicitement au compilateur qu'il souhaite convertir une valeur d'un type à un autre, même si cette conversion pourrait entraîner une perte de données.

Nécessaires quand il peut y avoir perte d’info ou erreur d’exécution (overflow, format, etc.).

Cela se fait simplement en utilisant le mot-clé (type) pour entourer la valeur que vous souhaitez convertir.

double d = 3.9;
int i = (int)d;          // i = 3 (troncature)

long big = 3_000_000_000;
int small = (int)big;    // ⚠️ possible overflow : valeur imprévisible si non contrôlée

Perte de précision

  • Cast de double vers int tronque (ne fait pas d’arrondi).
  • Cast vers un type entier plus petit peut déborder. Utilisez checked pour détecter.

Un autre un exemple 

double nombreDecimal = 10.5;

// Conversion explicite (casting) d'un double vers un int
int nombreEntier = (int)nombreDecimal;
Dans cet exemple, la valeur de nombreDecimal est un nombre à virgule flottante (de type double), mais le programmeur souhaite la convertir en un nombre entier (de type int). Le (int) devant nombreDecimal indique au compilateur que le programmeur est conscient de la perte de la partie décimale lors de la conversion et qu'il souhaite quand même effectuer cette conversion. Il est important de noter que les conversions explicites doivent être utilisées avec prudence, car elles peuvent entraîner la perte de données. Par exemple, dans le cas de la conversion d'un nombre à virgule flottante vers un entier, la partie décimale est tronquée, ce qui peut entraîner une perte d'informations. nombreEntier vaudra donc10 !!!

Séparateurs numériques _ (C# 7+)

Depuis C# 7.0, on peut utiliser le caractère _ comme séparateur visuel dans les littéraux numériques.
Cela n’affecte pas la valeur, c’est juste pour la lisibilité.

int unMillion = 1_000_000;
long big = 3_000_000_000;
double pi = 3.1415_9265_3589;

int binaire = 0b1010_1101;
int hexa = 0xFF_A0_1B;

✅ Autorisé : - entre les chiffres (1_234_567)
- après le préfixe binaire/hex (0xFF_FF, 0b1010_1010)
- dans la partie fractionnaire/exponentielle (1.23_45e+10)

❌ Interdit : - au début ou à la fin du nombre
- juste avant/après un . décimal ou un e/E

Exemple pratique :

long carteBancaire = 1234_5678_9012_3456;

3) Convert : conversions « de haut niveau »

La classe Convert fournit un ensemble de méthodes statiques pour effectuer une conversion explicite entre différents types de données.

System.Convert propose donc des méthodes statiques (ToInt32, ToDouble, ToString, etc.).

Exemples courants

using System;

string s = "123";
int a = Convert.ToInt32(s);          // 123
double x = Convert.ToDouble("3,14"); // ⚠️ dépend de la culture actuelle (séparateur décimal)

// Null-handling
string maybeNull = null;
int zero = Convert.ToInt32(maybeNull);  // 0 (Convert renvoie 0 pour null numériques)

// Booléens et dates
bool b = Convert.ToBoolean("true");     // true (si la chaîne est "True"/"true")
string hex = Convert.ToString(255, 16); // "ff"

Arrondi et culture

  • Convert.ToInt32(double) arrondit (règle « banker’s rounding », .NET) contrairement au cast qui tronque.
  • Les conversions depuis chaîne (ex. ToDouble) utilisent la culture actuelle à moins de passer une culture explicitement ailleurs (préférez Parse/TryParse avec CultureInfo).

4) Parse / TryParse (depuis une chaîne)

Les méthodes de conversion de type sécurisé sont conçues pour gérer les erreurs de conversion de manière élégante sans générer d'exceptions.
Il existe deux méthodes courantes pour la conversion de type sécurisé : TryParse et TryConvert. Je vous montre ici la plus courante soit le TryParse. La TryParse méthode est disponible pour de nombreux types de données et tente d'analyser une chaîne dans un type spécifié.

Si la conversion réussit, il renvoie true et affecte la valeur convertie à un paramètre de sortie. Si la conversion échoue, elle renvoie false et attribue la valeur par défaut au paramètre de sortie.

Pour vérifier si l’utilisateur entre bien un nombre on peut donc utiliser la méthode d’analyse TryParse()

Exemple pour la conversion en int (int32) 

int number=0;
bool success = int.TryParse(value, out number);
Convertit la représentation sous forme de chaîne d'un nombre (value) en son équivalent entier signé 32 bits (number). Une valeur de retour (success) indique si la conversion a réussi.

Remarque

value doit être une chaine de caractères (string) ! Si ce n’est pas le cas, on peut convertir ex : value.ToString() bool success = int.TryParse(value.ToString(), out number);

if (int.TryParse(chaineAge, out numMatricule))
{
   conversion effectuée, stockée dans numMatricule
}
else
{
   conversion ratée, mais application pas plantée !
}
Il est possible ainsi de convertir avec tous les principaux types comme :

Quand choisir quoi ?

  • TryParse : quand l’entrée peut être invalide (user input).
  • Parse : quand vous êtes sûr du format, sinon exception.
  • Convert : pratique pour gérer null et certains raccourcis, mais moins fin sur la culture/format.

5) Résumé des choix

Situation Recommandation
Numérique élargissant (ex. int → long) Implicite
Numérique rétrécissant (ex. double → int) Cast explicite (+ checked si risque d’overflow)
Chaîne → type numérique/Date/Enum TryParse (avec culture/format)
Gestion de null simple Convert (souvent pratique)
Règles d’arrondi spécifiques Math / Round / éviter le cast ; attention à Convert.ToInt32(double) qui arrondit

6) Pièges fréquents

  • Culture : double.Parse("3,14") dépend de la culture. Utilisez InvariantCulture pour un format stable (. décimal).
  • Arrondi vs troncature : cast tronque, Convert.ToInt32(double) arrondit (midpoint to even).
  • null : Convert.ToInt32(null) → 0, mais int.Parse(null) → exception.
  • Enum : préférez Enum.TryParse avec ignoreCase:true.
  • decimal : exige souvent un suffixe m dans les littéraux (12.3m).

À retenir

Implicite si c’est sûr, cast si rétrécit, TryParse pour les chaînes, Convert pour le confort (null/arrondis).

Pour aller plus loin