Error Handling Basics with Try-Catch

When learning programming, one of the most important skills you’ll acquire is error handling basics. Understanding how to gracefully catch and respond to errors makes your applications more stable, user-friendly, and professional.

In this guide, we’ll walk you through the fundamentals of error handling basics using the try-catch statement. With simple examples and clear language, you’ll be able to understand and implement safe coding practices.

What Is an Exception?

An exception is an error that occurs during the execution of a program. It could be due to dividing by zero, trying to access a null object, or attempting to open a file that doesn’t exist.

Without error handling basics, your program may crash unexpectedly when such problems occur.

The Try-Catch Structure

The try-catch structure lets you test blocks of code for errors and respond if something goes wrong:

try
{
    // Code that might throw an error
    int result = 10 / 0;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("You cannot divide by zero.");
}

Here, the program doesn’t crash. Instead, it prints a friendly message. That’s the power of error handling basics.

Why Use Try-Catch?

Prevent program crashes
Provide user-friendly error messages
Log detailed information for developers
Maintain application flow without interruption

Mastering error handling basics early will save you countless hours debugging your code.

Catching Multiple Exceptions

You can catch different types of exceptions separately:

try
{
    string text = File.ReadAllText("file.txt");
}
catch (FileNotFoundException ex)
{
    Console.WriteLine("File not found.");
}
catch (IOException ex)
{
    Console.WriteLine("A general IO error occurred.");
}

This lets you respond differently based on the exact issue — a key benefit of understanding error handling basics.

Using Finally

The finally block always executes, whether an exception occurred or not. Use it to release resources like file handles or database connections:

try
{
    // Open and read a file
}
catch (Exception ex)
{
    Console.WriteLine("Something went wrong.");
}
finally
{
    Console.WriteLine("Cleaning up resources.");
}

Avoiding Empty Catch Blocks

Avoid writing empty catch blocks. Swallowing errors silently makes debugging hard and hides problems from users and developers.

❌ Bad:

catch (Exception) { }

✅ Better:

catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}

Good error handling basics always involve useful feedback.

Best Practices

Don’t overuse try-catch — use it only where errors are likely
Handle specific exceptions first, then more general ones
Avoid catching Exception unless absolutely necessary
Keep try blocks small and focused

Real-World Example

Imagine a login form where a user enters their credentials:

try
{
    Authenticate(userInput);
}
catch (UnauthorizedAccessException)
{
    Console.WriteLine("Invalid login.");
}

Proper error handling basics ensure the application doesn’t crash even if the login fails.

Logging Errors

Logging helps track issues without disturbing the user experience:

catch (Exception ex)
{
    File.WriteAllText("log.txt", ex.ToString());
}

This is useful in production where debugging is not possible directly.

Null Handling with Try-Catch

Instead of checking for nulls manually everywhere, you can use try-catch for risky operations, especially when dealing with unknown data sources.

Learn More

Techlixy