C# : Interview questions (26-30)

 

  Questions :

• What is the "throw" keyword used for?
• Explain the difference between "finally", "catch", and "throw" in exception handling.
• What is the purpose of the "try" block?
• How do you create a custom exception in C#?
• What is the purpose of the "checked" and "unchecked" keywords?

C# : Interview questions (21-25)

Answers :

"throw" Keyword:

The "throw" keyword in C# is used to manually throw an exception. It is typically used when a specific error condition occurs in your code that cannot be handled locally and needs to be propagated up the call stack for handling by higher-level code.

if (age < 0) 
{
    throw new ArgumentException("Age cannot be negative.");
}

In this example, if the age is negative, an ArgumentException is thrown with a custom error message.

Difference between "finally", "catch", and "throw" in Exception Handling:

• try: The "try" block encloses the code that might throw an exception. It is followed by one or more "catch" blocks to handle specific exceptions.
• catch: The "catch" block catches and handles exceptions that are thrown within the "try" block. It specifies the type of exception to catch and provides code to handle the exception.
• finally: The "finally" block contains code that is always executed, regardless of whether an exception occurs in the "try" block or not. It is typically used to release resources or perform cleanup operations.
• throw: The "throw" keyword is used to manually throw an exception from within the "try" block. It allows you to propagate custom exceptions or rethrow exceptions caught in "catch" blocks.

Purpose of the "try" Block:

The "try" block in C# is used to enclose code that might throw an exception. It allows you to handle exceptions gracefully by catching and handling them using "catch" blocks or performing cleanup operations using "finally" blocks.

try 
{
    // Code that might throw an exception
}
catch (Exception ex) 
{
    // Handle the exception
}
finally 
{
    // Cleanup code
}

In this example, the "try" block encloses code that might throw an exception, and the "catch" block handles any exceptions that occur. The "finally" block contains cleanup code that is always executed, regardless of whether an exception occurs or not.

Creating a Custom Exception in C#:

To create a custom exception in C#, you need to create a new class that inherits from the Exception class or one of its derived classes. You can then add custom properties or methods to the class to provide additional information about the exception.

class MyCustomException : Exception 
{
    public MyCustomException(string message) : base(message) 
    {
        // Constructor
    }
}

In this example, the MyCustomException class inherits from the Exception class and provides a custom constructor to initialize the exception with a custom message.

Purpose of the "checked" and "unchecked" Keywords:

• checked: The "checked" keyword in C# is used to explicitly enable overflow checking for arithmetic operations, ensuring that arithmetic overflow exceptions are thrown if an overflow occurs.
• unchecked: The "unchecked" keyword is used to explicitly disable overflow checking for arithmetic operations, allowing arithmetic overflow to occur without throwing exceptions.

int x = int.MaxValue;
int y = 1;
int z = checked(x + y); // Throws OverflowException if overflow occurs

int a = int.MaxValue;
int b = 1;
int c = unchecked(a + b); // No exception thrown for overflow

In summary, the "checked" and "unchecked" keywords provide control over how arithmetic overflow is handled in C#, allowing you to choose between throwing exceptions or allowing overflow to occur silently.

C# : Interview questions (31-35)