Guide pratique pour convertir une chaîne en nombre (Guide de programmation C#)

  • Article

Vous convertissez une string en nombre en appelant la méthode Parse ou TryParse trouvée sur les types numériques ( int, long, double etc.) ou en utilisant des méthodes de la classe System.Convert.

Il est légèrement plus efficace et direct d’appeler une méthode TryParse (par exemple int.TryParse("11", out number)) ou une méthode Parse (par exemple, var number = int.Parse("11")). L'utilisation d'une méthode Convert s'avère plus utile pour les objets généraux qui implémentent IConvertible.

Vous pouvez utiliser les méthodes Parse ou TryParse sur le type numérique que doit contenir la chaîne, notamment le type System.Int32. La méthode Convert.ToInt32 utilise Parse en interne. La méthode Parse retourne le nombre converti ; la méthode TryParse retourne une valeur qui indique si la conversion a réussi et retourne le nombre converti dans un paramètre out. Si la chaîne n’est pas dans un format valide, Parse lève une exception, mais TryParse retourne false. Lorsque vous appelez une méthode Parse, vous devez toujours utiliser la gestion des exceptions pour intercepter une FormatException lorsque l’opération d’analyse échoue.

Appeler des méthodes Parse ou TryParse

Les méthodes Parse et TryParse ignorent l’espace blanc au début et à la fin de la chaîne, mais tous les autres caractères doivent être des caractères qui forment le type numérique approprié (int, long, ulong, float, decimal etc.). La présence d’un espace blanc dans la chaîne qui forme le nombre génère une erreur. Par exemple, vous pouvez utiliser decimal.TryParse pour analyser « 10 », « 10.3 » ou « 10 », mais vous ne pouvez pas utiliser cette méthode pour analyser 10 à partir de « 10X », « 1 0 » (notez l’espace incorporé), « 10 .3 » (notez l’espace incorporé), « 10e1 » (float.TryParse fonctionne ici) et ainsi de suite. Par ailleurs, une chaîne dont la valeur est null ou String.Empty échoue à l’analyse. Vous pouvez rechercher une chaîne Null ou vide avant de tenter de l’analyser en appelant la méthode String.IsNullOrEmpty.

L’exemple suivant illustre des appels à Parse et à TryParse qui ont réussi ou échoué.

using System;

public static class StringConversion
{
    public static void Main()
    {
        string input = String.Empty;
        try
        {
            int result = Int32.Parse(input);
            Console.WriteLine(result);
        }
        catch (FormatException)
        {
            Console.WriteLine($"Unable to parse '{input}'");
        }
        // Output: Unable to parse ''

        try
        {
            int numVal = Int32.Parse("-105");
            Console.WriteLine(numVal);
        }
        catch (FormatException e)
        {
            Console.WriteLine(e.Message);
        }
        // Output: -105

        if (Int32.TryParse("-105", out int j))
        {
            Console.WriteLine(j);
        }
        else
        {
            Console.WriteLine("String could not be parsed.");
        }
        // Output: -105

        try
        {
            int m = Int32.Parse("abc");
        }
        catch (FormatException e)
        {
            Console.WriteLine(e.Message);
        }
        // Output: Input string was not in a correct format.

        const string inputString = "abc";
        if (Int32.TryParse(inputString, out int numValue))
        {
            Console.WriteLine(numValue);
        }
        else
        {
            Console.WriteLine($"Int32.TryParse could not parse '{inputString}' to an int.");
        }
        // Output: Int32.TryParse could not parse 'abc' to an int.
    }
}

L’exemple suivant illustre une approche de l’analyse d’une chaîne prévoyant d’inclure des caractères numériques de début (y compris des caractères hexadécimaux) et des caractères non numériques de fin. Il attribue dès le début des caractères valides à une nouvelle chaîne avant d’appeler la méthode TryParse. Étant donné que les chaînes à analyser contiennent peu de caractères, l’exemple appelle la méthode String.Concat pour attribuer des caractères valides à une nouvelle chaîne. Pour une chaîne plus grande, la classe StringBuilder peut être utilisée à la place.

using System;

public static class StringConversion
{
    public static void Main()
    {
        var str = "  10FFxxx";
        string numericString = string.Empty;
        foreach (var c in str)
        {
            // Check for numeric characters (hex in this case) or leading or trailing spaces.
            if ((c >= '0' && c <= '9') || (char.ToUpperInvariant(c) >= 'A' && char.ToUpperInvariant(c) <= 'F') || c == ' ')
            {
                numericString = string.Concat(numericString, c.ToString());
            }
            else
            {
                break;
            }
        }

        if (int.TryParse(numericString, System.Globalization.NumberStyles.HexNumber, null, out int i))
        {
            Console.WriteLine($"'{str}' --> '{numericString}' --> {i}");
        }
        // Output: '  10FFxxx' --> '  10FF' --> 4351

        str = "   -10FFXXX";
        numericString = "";
        foreach (char c in str)
        {
            // Check for numeric characters (0-9), a negative sign, or leading or trailing spaces.
            if ((c >= '0' && c <= '9') || c == ' ' || c == '-')
            {
                numericString = string.Concat(numericString, c);
            }
            else
            {
                break;
            }
        }

        if (int.TryParse(numericString, out int j))
        {
            Console.WriteLine($"'{str}' --> '{numericString}' --> {j}");
        }
        // Output: '   -10FFXXX' --> '   -10' --> -10
    }
}

Appeler des méthodes Convert

Le tableau suivant répertorie quelques unes des méthodes de la classe Convert que vous pouvez utiliser pour convertir une chaîne en nombre.

Type numérique Méthode
decimal ToDecimal(String)
float ToSingle(String)
double ToDouble(String)
short ToInt16(String)
int ToInt32(String)
long ToInt64(String)
ushort ToUInt16(String)
uint ToUInt32(String)
ulong ToUInt64(String)

L’exemple suivant appelle la méthode Convert.ToInt32(String) pour convertir une entrée de type chaîne en int. L’exemple intercepte les deux exceptions les plus courantes levées par cette méthode : FormatException et OverflowException. Si le nombre obtenu peut être incrémenté sans dépasser Int32.MaxValue, l’exemple ajoute 1 au résultat et affiche la sortie.

using System;

public class ConvertStringExample1
{
    static void Main(string[] args)
    {
        int numVal = -1;
        bool repeat = true;

        while (repeat)
        {
            Console.Write("Enter a number between −2,147,483,648 and +2,147,483,647 (inclusive): ");

            string? input = Console.ReadLine();

            // ToInt32 can throw FormatException or OverflowException.
            try
            {
                numVal = Convert.ToInt32(input);
                if (numVal < Int32.MaxValue)
                {
                    Console.WriteLine("The new value is {0}", ++numVal);
                }
                else
                {
                    Console.WriteLine("numVal cannot be incremented beyond its current value");
                }
           }
            catch (FormatException)
            {
                Console.WriteLine("Input string is not a sequence of digits.");
            }
            catch (OverflowException)
            {
                Console.WriteLine("The number cannot fit in an Int32.");
            }

            Console.Write("Go again? Y/N: ");
            string? go = Console.ReadLine();
            if (go?.ToUpper() != "Y")
            {
                repeat = false;
            }
        }
    }
}
// Sample Output:
//   Enter a number between -2,147,483,648 and +2,147,483,647 (inclusive): 473
//   The new value is 474
//   Go again? Y/N: y
//   Enter a number between -2,147,483,648 and +2,147,483,647 (inclusive): 2147483647
//   numVal cannot be incremented beyond its current value
//   Go again? Y/N: y
//   Enter a number between -2,147,483,648 and +2,147,483,647 (inclusive): -1000
//   The new value is -999
//   Go again? Y/N: n