Convertir une string en int en C# : cast, Parse, TryParse et Convert

C# ne convertit jamais de lui-même entre des types sans rapport. Une chaîne qui contient des chiffres reste une chaîne, et un double ne devient pas discrètement un int. Vous convertissez explicitement, et l'outil à utiliser dépend de ce que vous convertissez : du texte en nombre (analyse ou parsing), un type numérique en un autre (cast), ou un objet en un type plus précis (as, is).

String en int : Parse, TryParse et Convert

Il existe trois façons standard de transformer du texte en int :

using System;

class Program
{
    static void Main()
    {
        string text = "1250";

        int a = int.Parse(text);
        int b = Convert.ToInt32(text);
        Console.WriteLine(a + b);

        if (int.TryParse(text, out int c))
        {
            Console.WriteLine($"TryParse ok: {c}");
        }

        if (!int.TryParse("12 apples", out int d))
        {
            Console.WriteLine($"TryParse failed, d = {d}");
        }

        Console.WriteLine(int.Parse("  42 "));   // surrounding spaces are allowed
        Console.WriteLine(int.Parse("-17"));
    }
}

Sortie :

2500
TryParse ok: 1250
TryParse failed, d = 0
42
-17

int.TryParse renvoie un bool et écrit le résultat dans une variable out, qui vaut 0 en cas d'échec. Comme une saisie invalide est normale pour tout ce que tape un utilisateur, TryParse est le choix par défaut pour les saisies, les fichiers et les query strings. Les mêmes méthodes existent sur chaque type numérique : long.TryParse, double.TryParse, decimal.Parse, etc.

Ce que fait chacune avec une saisie invalide

Les trois méthodes ne diffèrent que par leur manière d'échouer :

using System;

class Program
{
    static void Try(string label, Func<int> parse)
    {
        try
        {
            Console.WriteLine($"{label} = {parse()}");
        }
        catch (Exception e)
        {
            Console.WriteLine($"{label} throws {e.GetType().Name}");
        }
    }

    static void Main()
    {
        string empty = null;
        Try("int.Parse(null)", () => int.Parse(empty));
        Try("Convert.ToInt32(null)", () => Convert.ToInt32(empty));
        Try("int.Parse(\"abc\")", () => int.Parse("abc"));
        Try("int.Parse(\"12.5\")", () => int.Parse("12.5"));
        Try("int.Parse(\"1,000\")", () => int.Parse("1,000"));
        Try("int.Parse(\"9999999999\")", () => int.Parse("9999999999"));
        Try("int.Parse(\"\")", () => int.Parse(""));
    }
}

Sortie :

int.Parse(null) throws ArgumentNullException
Convert.ToInt32(null) = 0
int.Parse("abc") throws FormatException
int.Parse("12.5") throws FormatException
int.Parse("1,000") throws FormatException
int.Parse("9999999999") throws OverflowException
int.Parse("") throws FormatException

Une FormatException porte le message bien connu « Input string was not in a correct format » (depuis .NET 8, « The input string '12.5' was not in a correct format », avec le texte cité), et c'est l'une des erreurs d'exécution C# les plus courantes : "12.5" n'est pas un int, pas plus que "1,000". Pour les accepter, analysez-les comme decimal, ou indiquez à l'analyseur quels styles sont autorisés :

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        var inv = CultureInfo.InvariantCulture;

        int withCommas = int.Parse("1,000", NumberStyles.AllowThousands, inv);
        int fromHex = int.Parse("FF", NumberStyles.HexNumber);
        decimal price = decimal.Parse("12.5", inv);
        int rounded = (int)Math.Round(price, MidpointRounding.AwayFromZero);

        Console.WriteLine(withCommas);
        Console.WriteLine(fromHex);
        Console.WriteLine(rounded);
        Console.WriteLine(Convert.ToInt32("1010", 2));  // from binary
    }
}

Sortie :

1000
255
13
10

La culture : pourquoi "1.5" peut devenir 15

L'analyse utilise par défaut la culture courante, et les cultures ne s'accordent pas sur les séparateurs. En allemand et dans plusieurs autres cultures européennes, le séparateur décimal est une virgule et le point groupe les milliers. La même chaîne donne des nombres différents :

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        var german = new CultureInfo("de-DE");
        var inv = CultureInfo.InvariantCulture;

        decimal a = decimal.Parse("1.5", inv);
        decimal b = decimal.Parse("1.5", german);   // "." is a group separator here
        decimal c = decimal.Parse("1,5", german);

        Console.WriteLine(a.ToString(inv));
        Console.WriteLine(b.ToString(inv));
        Console.WriteLine(c.ToString(inv));
    }
}

Sortie :

1.5
15
1.5

Le code qui lit des fichiers de données, du JSON, de la configuration ou tout contenu généré par une machine doit toujours passer CultureInfo.InvariantCulture, à l'analyse comme au formatage. Sinon, le même programme fonctionne sur la machine d'un développeur et lit mal chaque nombre sur un serveur réglé dans une autre langue. N'utilisez la culture courante que pour le texte qu'une personne a tapé ou lira.

Conversions numériques implicites et explicites

Les conversions élargissantes se font implicitement : int vers long, int vers double, float vers double, int vers decimal. Une conversion qui peut perdre l'ordre de grandeur de la valeur ou sa partie fractionnaire exige un cast explicite (type)value. Une exception à retenir : int ou long vers float, et long vers double, sont implicites alors qu'elles peuvent perdre de la précision : float f = 16_777_217; compile et stocke 16777216.

using System;

class Program
{
    static void Main()
    {
        int items = 7;
        long bigItems = items;       // implicit: always fits
        double ratio = items;        // implicit
        decimal money = items;       // implicit

        double price = 9.99;
        int whole = (int)price;      // explicit: truncates toward zero
        int negative = (int)-9.99;
        Console.WriteLine($"{whole} {negative}");

        Console.WriteLine(Convert.ToInt32(9.99));   // rounds
        Console.WriteLine(Convert.ToInt32(2.5));    // halves go to even: 2
        Console.WriteLine(Convert.ToInt32(3.5));    // 4

        long large = 5_000_000_000;
        int wrapped = (int)large;    // keeps the low 32 bits
        Console.WriteLine(wrapped);

        decimal amount = (decimal)price;  // double to decimal: explicit
        Console.WriteLine(amount);
        Console.WriteLine($"{bigItems} {ratio:F1} {money}");
    }
}

Sortie :

9 -9
10
2
4
705032704
9.99
7 7.0 7

Trois choses à retenir. Un cast d'un nombre à virgule flottante vers un entier tronque ; il n'arrondit pas. Convert.ToInt32(double) arrondit, avec l'arrondi bancaire (les demis vont vers le voisin pair). Et un cast entier qui ne tient pas boucle silencieusement, sauf dans un contexte checked, où il lève OverflowException (voir types de données).

int x = 3.7; est une erreur de compilation (CS0266: cannot implicitly convert type 'double' to 'int', an explicit conversion exists) : le compilateur vous demande de choisir entre un cast et une méthode d'arrondi.

Nombres et autres types vers string

Chaque type a ToString(), et les types numériques acceptent une chaîne de format. L'interpolation de chaînes appelle le même formatage :

using System;
using System.Globalization;

class Program
{
    static void Main()
    {
        int orderId = 42;
        decimal total = 1234.5m;
        var us = new CultureInfo("en-US");

        Console.WriteLine(orderId.ToString());
        Console.WriteLine(orderId.ToString("D6"));        // 000042
        Console.WriteLine(total.ToString("F2"));          // 1234.50
        Console.WriteLine(total.ToString("N2", us));      // 1,234.50
        Console.WriteLine(total.ToString("C", us));       // $1,234.50
        Console.WriteLine(255.ToString("X"));             // FF
        Console.WriteLine(Convert.ToString(10, 2));       // 1010
        Console.WriteLine(true.ToString());
        Console.WriteLine($"Order {orderId:D6}: {total:F2}");
    }
}

Sortie :

42
000042
1234.50
1,234.50
$1,234.50
FF
1010
True
Order 000042: 1234.50

Les codes de format (D, F, N, C, X, P, E) et les modèles personnalisés comme "0.00" sont traités dans interpolation de chaînes.

Caractères et booléens

using System;

class Program
{
    static void Main()
    {
        char digit = '7';
        Console.WriteLine(digit);            // the character
        Console.WriteLine((int)digit);       // its code: 55
        Console.WriteLine(digit - '0');      // its value: 7
        Console.WriteLine(char.GetNumericValue(digit));
        Console.WriteLine((char)65);         // A

        Console.WriteLine(bool.Parse("True"));
        Console.WriteLine(bool.Parse("false"));
        Console.WriteLine(Convert.ToInt32(true));
        Console.WriteLine(Convert.ToBoolean(0));
    }
}

Sortie :

7
55
7
7
A
True
False
1
False

(int)'7' vaut 55, le code du caractère, pas 7. Cela piège quiconque additionne les chiffres d'un nombre ; soustrayez '0' ou utilisez char.GetNumericValue. bool.Parse accepte "true" et "false" quelle que soit la casse, et rien d'autre ("yes" et "1" lèvent une exception).

Conversions de références : casts, as et is

Pour les types classe, un cast vérifie le type réel de l'objet à l'exécution. La conversion vers une classe de base (upcast) est implicite. La conversion vers une classe dérivée (downcast) exige un cast explicite, qui lève InvalidCastException quand l'objet est d'un autre type :

using System;

class Payment { public decimal Amount = 50m; }
class CardPayment : Payment { public string Last4 = "4242"; }
class CashPayment : Payment { }

class Program
{
    static void Main()
    {
        Payment p = new CardPayment();       // upcast: implicit

        CardPayment card = (CardPayment)p;   // downcast: works, it is a card
        Console.WriteLine(card.Last4);

        Payment cash = new CashPayment();
        CardPayment maybe = cash as CardPayment;  // as: null instead of an exception
        Console.WriteLine(maybe == null);

        if (p is CardPayment c)              // is pattern (C# 7): test and convert
        {
            Console.WriteLine($"Card ending {c.Last4}, {c.Amount:F2}");
        }

        try
        {
            var wrong = (CardPayment)cash;
        }
        catch (InvalidCastException)
        {
            Console.WriteLine("InvalidCastException");
        }

        object boxed = 5;                    // an int boxed as object
        int unboxed = (int)boxed;            // fine
        Console.WriteLine(unboxed);
        try
        {
            long wrongUnbox = (long)boxed;   // must unbox to the exact type
        }
        catch (InvalidCastException)
        {
            Console.WriteLine("cannot unbox int as long");
        }
    }
}

Sortie :

4242
True
Card ending 4242, 50.00
InvalidCastException
5
cannot unbox int as long

Préférez is avec une variable quand vous devez choisir une branche selon le type : c'est un seul test, il ne peut pas lever d'exception, et la nouvelle variable n'est visible que là où le test a réussi. Utilisez un cast simple quand un autre type serait un bug qui doit échouer bruyamment. Le cas de l'int boxé piège ceux qui lisent des nombres depuis des collections d'object ou des cellules de DataRow : faites d'abord l'unboxing vers le type exact ((long)(int)boxed), ou utilisez Convert.ToInt64(boxed), qui gère n'importe quel type numérique.