Parse() vs TryParse() vs Convert Class Methods in C#

Introduction

In C#, Parse(), TryParse(), and Convert methods are used to convert **strings** into other data types such as integers, decimals, and dates. Each method handles **invalid input differently**, and choosing the right one depends on the use case.

Parse() Method

The Parse() method **converts** a string into a specific data type but **throws an exception** if the conversion fails. It is best used when **you are certain** that the input is valid.

Example: Using Parse()

string numberString = "123";
int number = int.Parse(numberString);

Console.WriteLine(number);  // Output: 123
        

In this example, Parse() converts the string "123" into an integer. However, if the input is invalid (e.g., "ABC"), it will throw a FormatException.

TryParse() Method

The TryParse() method attempts to **convert a string** and returns **true** if successful, **false** otherwise. This method **does not throw an exception**, making it ideal for handling potentially invalid input gracefully.

Example: Using TryParse()

string numberString = "123";
bool success = int.TryParse(numberString, out int number);

if (success)
{
    Console.WriteLine(number);  // Output: 123
}
else
{
    Console.WriteLine("Invalid input");
}
        

In this example, TryParse() returns **true** and stores the converted value in number. If the input is invalid, it returns **false** and avoids exceptions.

Convert Class Methods

The Convert class provides methods to **convert values to a specific type**. It **handles null** values by returning the **default value** (e.g., 0 for integers) instead of throwing an exception.

Example: Using Convert.ToInt32()

string numberString = null;
int number = Convert.ToInt32(numberString);

Console.WriteLine(number);  // Output: 0
        

Unlike Parse(), Convert.ToInt32() **returns 0** when the input is null instead of throwing an exception. However, if the input is **not a valid number**, it will throw a FormatException.

Real-World Example: Processing User Input

Suppose you're accepting **user input** for age in a registration form. Using TryParse() ensures that invalid input does not crash the program.

Example: Handling User Input Safely

Console.Write("Enter your age: ");
string input = Console.ReadLine();

if (int.TryParse(input, out int age))
{
    Console.WriteLine($"Your age is: {age}");
}
else
{
    Console.WriteLine("Invalid input. Please enter a number.");
}
        

Here, TryParse() prevents the program from crashing if the user enters an invalid value (e.g., "twenty").

Performance Considerations

• Parse(): Faster but **throws exceptions**, so only use it if you're confident the input is valid.
• TryParse(): Safer and recommended when working with **user input or external data**.
• Convert: Handles **null values** but still **throws exceptions** on invalid input.

Comparison Table: Parse() vs TryParse() vs Convert