Guide pratique pour convertir une chaîne en nombre (Guide de programmation C#)
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
Utiliser GitHub Copilot pour convertir une chaîne en nombre
Vous pouvez utiliser GitHub Copilot dans votre IDE pour générer du code pour convertir une chaîne en nombre en C#.
Si vous utilisez Visual Studio 2022 version 17.8 ou ultérieure, vous pouvez essayer GitHub Copilot basé sur l’IA dans Visual Studio pour générer du code pour convertir une chaîne en nombre. Soumettez votre question sous forme de requête dans la fenêtre de discussion de Copilot, comme dans l’exemple suivant. Vous pouvez également soumettre des requêtes en utilisant le chat en ligne dans la fenêtre de l’éditeur elle-même.
Remarque
GitHub Copilot est alimenté par l’IA, donc des surprises et des erreurs sont possibles. Assurez-vous de vérifier tout code ou suggestion généré. Pour plus d’informations sur l’utilisation générale de GitHub Copilot, l’impact du produit, la supervision humaine et la confidentialité, veuillez consulter FAQ GitHub Copilot.
Le texte suivant montre un exemple d’invite pour le chat Copilot :
Générez du code C# pour convertir la chaîne « 123 » en nombre à l’aide de TryParse. Fournir un exemple de sortie.
Vous pouvez personnaliser l’invite pour utiliser une chaîne selon vos besoins.
Vous pouvez utiliser les fonctionnalités du chat, telles que les commandes à barres obliques, les références à des fichiers, des méthodes ou des classes, et les threads, pour définir l’intention et obtenir de meilleures réponses avec un contexte élargi. Pour un fichier existant ouvert dans l’IDE, vous pouvez inviter GitHub Copilot à utiliser la conversation inline avec /generate code to convert the string string1 in #Filename to a number.
Voici un exemple de réponse du chat Copilot :
Here is a C# code snippet to convert the string "123" to a number using TryParse:
using System;
class Program
{
static void Main()
{
string numberString = "123";
int number;
bool success = int.TryParse(numberString, out number);
if (success)
{
// Example output
Console.WriteLine("The converted number is: " + number);
}
else
{
Console.WriteLine("Conversion failed.");
}
}
}
When you run this code, the output will be:
The converted number is: 123
Lorsque Copilot retourne un bloc de code, la réponse inclut des options pour copier le code, insérer le code dans un nouveau fichier, ou prévisualiser la sortie du code.
Remarque
Vos résultats peuvent être différents de ce qui est montré dans les réponses d’exemple. Les modèles IA sont non déterministes, ce qui signifie qu’ils peuvent renvoyer des réponses différentes lorsqu’on leur pose la même question. Cela peut être dû à un apprentissage et à une adaptation supplémentaires au fil du temps, à une variation de la langue, à des changements de contexte, tels que l’historique de votre chat, et plus encore.
Pour plus d’informations, consultez l’article suivant :
