How to convert a string to a number (C# Programming Guide)
You convert a string to a number by calling the Parse or TryParse method found on numeric types (int, long, double, and so on), or by using methods in the System.Convert class.
It's slightly more efficient and straightforward to call a TryParse method (for example, int.TryParse("11", out number)) or Parse method (for example, var number = int.Parse("11")). Using a Convert method is more useful for general objects that implement IConvertible.
You use Parse or TryParse methods on the numeric type you expect the string contains, such as the System.Int32 type. The Convert.ToInt32 method uses Parse internally. The Parse method returns the converted number; the TryParse method returns a boolean value that indicates whether the conversion succeeded, and returns the converted number in an out parameter. If the string isn't in a valid format, Parse throws an exception, but TryParse returns false. When calling a Parse method, you should always use exception handling to catch a FormatException when the parse operation fails.
Call Parse or TryParse methods
The Parse and TryParse methods ignore white space at the beginning and at the end of the string, but all other characters must be characters that form the appropriate numeric type (int, long, ulong, float, decimal, and so on). Any white space within the string that forms the number causes an error. For example, you can use decimal.TryParse to parse "10", "10.3", or " 10 ", but you can't use this method to parse 10 from "10X", "1 0" (note the embedded space), "10 .3" (note the embedded space), "10e1" (float.TryParse works here), and so on. A string whose value is null or String.Empty fails to parse successfully. You can check for a null or empty string before attempting to parse it by calling the String.IsNullOrEmpty method.
The following example demonstrates both successful and unsuccessful calls to Parse and TryParse.
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.
}
}
The following example illustrates one approach to parsing a string expected to include leading numeric characters (including hexadecimal characters) and trailing non-numeric characters. It assigns valid characters from the beginning of a string to a new string before calling the TryParse method. Because the strings to be parsed contain a few characters, the example calls the String.Concat method to assign valid characters to a new string. For a larger string, the StringBuilder class can be used instead.
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
}
}
Call Convert methods
The following table lists some of the methods from the Convert class that you can use to convert a string to a number.
| Numeric type | Method |
|---|---|
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) |
The following example calls the Convert.ToInt32(String) method to convert an input string to an int. The example catches the two most common exceptions thrown by this method: FormatException and OverflowException. If the resulting number can be incremented without exceeding Int32.MaxValue, the example adds 1 to the result and displays the output.
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
Use GitHub Copilot to convert a string to a number
You can use GitHub Copilot in your IDE to generate code to convert a string to a number in C#.
If you're using Visual Studio 2022 version 17.8 or later, you can try the AI-driven GitHub Copilot in Visual Studio to generate code to convert a string to a number. Submit your question as a prompt in the Copilot chat window, as in the following example. You can also submit prompts using inline chat in the editor window itself.
Note
GitHub Copilot is powered by AI, so surprises and mistakes are possible. Make sure to verify any generated code or suggestions. For more information about the general use of GitHub Copilot, product impact, human oversight, and privacy, see GitHub Copilot FAQs.
The following text shows an example prompt for Copilot Chat:
Generate C# code to convert the string "123" to a number using TryParse. Provide example output.
You can customize the prompt to use a string per your requirements.
You can use chat features, such as slash commands, references to files, methods, or classes, and threads, to set intent and get better answers with scoped context. For an existing file that's open in the IDE, you can prompt GitHub Copilot using inline chat with /generate code to convert the string string1 in #Filename to a number.
The following output shows an example Copilot Chat response:
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
When Copilot returns a code block, the response includes options to copy the code, insert the code into a new file, or preview the code output.
Note
Your results might be different from what's shown in the example responses. AI models are non-deterministic, which means that they can return different responses when asked the same question. This might be due to additional learning and adaption over time, language variation, changes in context, such as your chat history, and more.
For more information, see:
