Exception Handling in C#

Exception Handling in c#

Exception handling is a fundamental concept in C# programming that enables developers to manage unexpected or exceptional events during the execution of their code. These events, known as exceptions, can be caused by a variety of factors, including invalid input, resource unavailability, or other unforeseen circumstances. Effectively handling exceptions is crucial for building robust and reliable applications.

1. try-catch Blocks: The try block contains the code that might raise an exception. The catch block is used to handle the exception if one occurs.

Syntax:

2. finally block: The finally block contains code that is guaranteed to execute, whether an exception occurred or not. It is used for cleanup tasks and releasing resources.

Syntax:

3. throw statement: The throw statement is used to manually raise an exception. It is followed by an exception object that provides information about the error.

Syntax:

Example

Let's consider an example scenario to better understand exception handling in C#. We'll create a simple program that divides two numbers and handle potential exceptions that may arise during the division process.

Output:

In the above code, the user is prompted to enter a numerator and a denominator. The DivideNumbers() method is called to perform the division.Then the try block contains the main code that might raise exceptions. If the user enters non-numeric values, a FormatException is caught and an error message is displayed. If the user enters a denominator of zero, a DivideByZeroException is caught and an appropriate error message is displayed. If any other exception occurs, a generic Exception catch block handles it and displays the error message.

Exception Classes in C#

In C#, exception classes are an essential part of the language's robust error handling mechanism. These classes provide a structured way to represent various types of errors and exceptional situations that can occur during program execution.Here are some important exception classes in C#:

1. System.Exception: The base class for all exceptions in C#. Represents errors that occur during application execution.
2. System.SystemException: The base class for predefined system exceptions. Includes exceptions like InvalidOperationException, NotSupportedException, and NullReferenceException.
3. System.ApplicationException: The base class for custom application-specific exceptions. Developers can derive their own custom exception classes from this base class to handle application-specific errors.
4. System.ArgumentException: Thrown when an argument to a method is not valid. Indicates that an argument provided to a method is outside the allowable range or does not meet other criteria.
5. System.NullReferenceException: Thrown when an attempt is made to access a member of a null object. Indicates that an object reference is not initialized, and an attempt is made to access its members.
6. System.DivideByZeroException: Thrown when an attempt is made to divide an integer or decimal value by zero. Indicates that a division operation resulted in a mathematical error.
7. System.IndexOutOfRangeException: Thrown when an attempt is made to access an array or collection with an index that is outside the valid range. Indicates that an index used to access an element in a collection is not within the bounds of the collection.
8. System.IO.IOException: Represents errors that occur during input/output operations, such as file or network operations. Indicates that an input or output operation failed or was interrupted.
9. System.FormatException: Thrown when a format of an argument is invalid. Indicates that a format conversion cannot be performed due to an invalid format specification.
10. System.OutOfMemoryException: Thrown when there is not enough memory to continue program execution. Indicates that the application has exhausted available memory resources.

Using Try Catch Block for Exception Handling in C#

Exception handling in C# is achieved through the use of the try-catch block. The try block encloses the code that might raise an exception, while the catch block catches and handles the exception if one occurs. The basic syntax looks like this:

Example:

Output:

The integer array created in the program contains 3 elements only so the array indexes upto [2] only. Hence, array[6] is certainly out of bound.

Using Multiple Try Catch Blocks for Exception Handling in C#

In some situations of Exception handling in C#, there might be a need to handle different types of exceptions differently. Excepyion Handling in C# allows the use of multiple catch blocks to address this scenario. The catch blocks are evaluated in sequence, and the first matching block is executed.

Output:

The first number '8' is normally divided by'2'. While the second number '17' cannot be divided by'0'. Hence, there is an exception of division by '0', so the first catch block takes care of it. In the third iteration, the divisor array goes out of bound, so the second catch takes care of it.

What are User Defined Exceptions?

User-defined exceptions, also known as custom exceptions, are exception classes that developers create to handle specific error scenarios in their applications. While C# provides a range of built-in exception classes to handle common error situations, there are times when these predefined exceptions might not precisely capture the nature of a particular error in a specific application.

User-defined exceptions allow developers to:

• Create meaningful and descriptive error classes tailored to their application's requirements.
• Provide additional context, properties, and methods for more informative error handling.
• Differentiate between various error scenarios that may arise within the application.

User-defined exceptions enhance code readability and maintainability, as they communicate the nature of errors more effectively. They also allow developers to centralize error-handling logic and provide a consistent approach to dealing with application-specific error scenarios. By utilizing user-defined exceptions, developers can build more reliable and user-friendly applications that gracefully handle errors and exceptions.

Here's a step-by-step guide on how to create and use user-defined exceptions in C#:

Create a Custom Exception Class:

To create a user-defined exception, you need to create a new class that inherits from the System.Exception class or one of its derived classes.

Output:

Explanation:

• We define a simple custom exception class CustomException that inherits from Exception and has a single constructor accepting a message.
• In the Main method, we intentionally throw the CustomException using the throw statement, passing a message.
• The first catch block catches the CustomException and displays its message.
• The second catch block catches any other exceptions and displays a general exception message.

Customize the Exception:

You can add properties, constructors, and methods to your custom exception class to provide additional information about the error.

Output

Explanation

• We define a custom exception class CustomException that inherits from the base Exception class.
• The class has a single constructor that takes a message parameter and passes it to the base constructor using base(message).
• We define a method named ThrowCustomException that intentionally throws our custom exception using the throw statement. In the Main method, we call the ThrowCustomException method, which throws our custom exception.
• The first catch block catches the CustomException and displays its message using the ex.Message property.

Catch and Handle the Custom Exception:

When you use your custom exception, you can catch and handle it just like any other exception.

Output

Explanation

• We define the CustomException class with a constructor that accepts both a message and an additionalInfo parameter. It sets the message using base(message) and initializes the AdditionalInfo property.
• The SomeMethod method is defined to intentionally throw a CustomException with a specific message and additional information.
• In the Main method: We call SomeMethod within a try block. The first catch block catches a CustomException and displays its message and additional information using the properties of the caught exception (ex.Message and ex.AdditionalInfo).
• The second catch block catches any other exceptions (general exceptions) and displays their messages.