How Can We Convert String to Int in C#

Why Convert String to Int in C#?

Converting a string to int in C# is a common requirement in many applications. Whether it is user input, file data, or API responses, knowing the best ways to convert strings to integers ensures your program works efficiently and safely. This guide covers all major methods with practical examples and best practices for beginners and intermediate developers.

Converting strings to integers is necessary in various scenarios:

• Processing numerical input from users in console or GUI applications.
• Parsing numerical data from text files, CSVs, or APIs.
• Performing calculations and logical operations.
• Validating data before storing it in databases.

Primary Methods to Convert String to Int in C#

There are several methods to convert a string to int in C#. The most widely used are int.Parse(), int.TryParse(), and Convert.ToInt32().

1. Using int.Parse()

The int.Parse() method converts a numeric string to an integer but throws an exception if the input is invalid.

📄

string numberString = "123";
int number = int.Parse(numberString);
Console.WriteLine(number); // Output: 123
    

• Works only with valid numeric strings.
• Throws exceptions for null or invalid strings.
• Use when input is guaranteed to be numeric.

2. Using int.TryParse()

The int.TryParse() method is safer. It returns a boolean indicating whether the conversion succeeded without throwing an exception.

📄

string input = "456";
int result;

bool isConverted = int.TryParse(input, out result);
if (isConverted)
{
    Console.WriteLine(result); // Output: 456
}
else
{
    Console.WriteLine("Conversion failed!");
}
    

Ideal for handling unpredictable input, such as user data or API responses.

3. Using Convert.ToInt32()

The Convert.ToInt32() method converts a string to int and returns 0 for null values instead of throwing an exception.

📄

string input = "789";
int number = Convert.ToInt32(input);
Console.WriteLine(number); // Output: 789
    

Handling Invalid Conversions in C#

Always handle cases where the string may not represent a valid number:

• Use int.TryParse() for safe conversion.
• Validate numeric patterns with Regex if necessary.
• Use try-catch blocks with int.Parse() or Convert.ToInt32() when input reliability is uncertain.

Examples and Use Cases

Example 1: Reading User Input

📄

Console.WriteLine("Enter your age:");
string ageInput = Console.ReadLine();
int age;

if(int.TryParse(ageInput, out age))
{
    Console.WriteLine("Your age is " + age);
}
else
{
    Console.WriteLine("Invalid input, please enter a number!");
}
    

Parsing Numerical Data from Text Files, CSVs, or APIs in C#

In real-world C# applications, you often need to extract numeric data from different sources like text files, CSVs, or APIs. Proper parsing ensures that data can be safely converted from string to int for calculations, reporting, or database storage.

1. Parsing Data from Text Files

Text files often contain numbers as strings. You can read the file line by line and use int.TryParse() or int.Parse() to convert the data.

📄

using System;
using System.IO;

class Program
{
    static void Main()
    {
        string[] lines = File.ReadAllLines("numbers.txt");

        foreach (string line in lines)
        {
            int number;
            if (int.TryParse(line, out number))
            {
                Console.WriteLine("Parsed number: " + number);
            }
            else
            {
                Console.WriteLine("Invalid number in file: " + line);
            }
        }
    }
}

2. Parsing Data from CSV Files

CSV files are commonly used to store tabular data. You can split each line by commas and convert the numeric fields to integers.

📄

using System;

class Program
{
    static void Main()
    {
        string csvData = "101,202,303";
        string[] values = csvData.Split(',');

        foreach (string value in values)
        {
            int number;
            if (int.TryParse(value, out number))
            {
                Console.WriteLine("Parsed number: " + number);
            }
            else
            {
                Console.WriteLine("Invalid number: " + value);
            }
        }
    }
}

3. Parsing Numerical Data from APIs

When working with APIs, numeric values are often returned as strings in JSON responses. You can deserialize the JSON and convert the strings to integers.

📄

using System;
using System.Text.Json;

class Program
{
    class ApiResponse
    {
        public string Id { get; set; }
        public string Quantity { get; set; }
    }

    static void Main()
    {
        string json = "{\"Id\":\"A101\",\"Quantity\":\"50\"}";
        ApiResponse response = JsonSerializer.Deserialize(json);

        int quantity;
        if (int.TryParse(response.Quantity, out quantity))
        {
            Console.WriteLine("Quantity: " + quantity);
        }
        else
        {
            Console.WriteLine("Invalid quantity from API");
        }
    }
}

Best Practices for Parsing Numerical Data

• Always validate strings before conversion to avoid exceptions.
• Use int.TryParse() for safe parsing of unknown or user-supplied data.
• Handle empty or null values carefully, especially from APIs or files.
• Log invalid data for debugging or reporting purposes.
• Consider culture-specific formats if dealing with decimals or thousands separators.

Example 2: Parsing Data from CSV

📄

string csvData = "101,202,303";
string[] values = csvData.Split(',');

foreach(string value in values)
{
    int number;
    if(int.TryParse(value, out number))
    {
        Console.WriteLine("Parsed Number: " + number);
    }
}
    

Comparison Table: int.Parse() vs int.TryParse() vs Convert.ToInt32()

Method	Throws Exception	Handles Null	Recommended Use
int.Parse()	Yes	No	When input is guaranteed numeric
int.TryParse()	No	No	For user input or unknown data
Convert.ToInt32()	Yes (for invalid strings)	Yes (returns 0)	When null values may occur

 Converting Strings to Int in C#

• Validate input before conversion.
• Use TryParse for unpredictable data.
• Handle exceptions with try-catch when needed.
• Document input expectations and constraints.
• Consider localization for numeric formats.

Converting a string to int in C# is essential for processing numerical data. Knowing the differences between int.Parse(), int.TryParse(), and Convert.ToInt32() allows you to write robust and error-free code. Always handle edge cases and follow best practices to ensure smooth application behavior.

FAQs 

1. What is the safest way to convert a string to int in C#?

Using int.TryParse() is the safest because it prevents exceptions and lets you handle invalid input gracefully.

2. Can int.Parse() handle null values?

No, int.Parse() throws an ArgumentNullException if the input is null. Use Convert.ToInt32() for null-safe conversion.

3. What happens if a string contains non-numeric characters?

int.Parse() and Convert.ToInt32() throw a FormatException. int.TryParse() returns false, indicating failure without exceptions.

4. How to convert strings with decimal numbers to int?

Parse the string as double or float first, then cast or round to int. Direct int.Parse() will fail.

5. Is there a performance difference between Parse and TryParse?

int.Parse() is slightly faster for guaranteed valid input, but TryParse is safer for real-world applications with unpredictable data.