Custom exception classes in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Custom exception classes

Define class inheriting Exception

↓

Add constructors or properties

↓

Throw custom exception

↓

Catch custom exception

↓

Handle or display error message

↓

End

Create a new exception type by inheriting from Exception, then throw and catch it like built-in exceptions.

Execution Sample

C Sharp (C#)

class MyException : Exception {
  public MyException(string message) : base(message) {}
}

throw new MyException("Oops!");

Defines a custom exception class and throws it with a message.

Execution Table

Step	Action	Evaluation	Result
1	Define class MyException inheriting Exception	Class created	MyException ready to use
2	Create new MyException with message "Oops!"	Calls constructor	Exception object with message "Oops!"
3	Throw MyException	Exception thrown	Program looks for catch block
4	Catch MyException	Catch block matches type	Exception caught and handled
5	Display exception message	Access Message property	Output: "Oops!"

💡 Exception caught and handled, program continues or ends gracefully

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
exceptionInstance	null	MyException("Oops!")	Thrown	Caught and message accessed

Key Moments - 3 Insights

Why do we inherit from Exception to create a custom exception?

Because inheriting Exception lets our class behave like a real exception, so it can be thrown and caught as shown in execution_table step 1 and 3.

What happens if we throw the custom exception but don't catch it?

The program will crash or stop with an error because no catch block handles it, unlike step 4 where the exception is caught.

How do we pass a message to the custom exception?

We pass the message string to the constructor when creating the exception instance, as in step 2, which stores it for later use.

Visual Quiz - 3 Questions

Look at the execution_table, what is the result after step 2?

A Exception thrown

B Exception object with message "Oops!"

C Class created

D Exception caught and handled

💡 Hint

Check the 'Result' column for step 2 in execution_table

At which step does the program catch the custom exception?

A Step 4

B Step 1

C Step 3

D Step 5

💡 Hint

Look for the 'Catch MyException' action in execution_table

If we do not inherit from Exception, what would happen when throwing the custom class?

A It would throw normally

B It would not be caught by catch blocks for Exception

C It would cause a compile error

D It would print the message automatically

💡 Hint

Custom exceptions must inherit Exception to be caught as exceptions (see concept_flow)

Concept Snapshot

Create a custom exception by inheriting Exception class.
Add constructors to pass messages.
Throw with 'throw new YourException()'.
Catch with 'catch (YourException e){}'.
Use Message property to show error info.

Full Transcript

This example shows how to create a custom exception class in C# by inheriting from the Exception base class. First, we define the class with a constructor that accepts a message string. Then, we create an instance of this custom exception and throw it. The program looks for a matching catch block to handle the exception. When caught, we can access the message property to display the error. This process allows us to create meaningful, specific errors for our programs that behave like built-in exceptions.