Tasks studies - laboratory
Exceptions are issues that arise during program execution. In C#, an exception is the response to exceptional circumstances occurring during program operation, such as attempting to divide by zero.
Exceptions allow transferring control from one part of the program to another. Exception handling in C# revolves around four keywords: try, catch, finally, and throw.
try: The try block identifies a block of code for which particular exceptions will be activated. It is followed by one or more catch blocks.catch: It catches an exception using an exception handling routine at the place in the program where you want to handle the problem. The catch keyword denotes catching an exception.
finally: The finally block is used to execute a set of statements, regardless of whether an exception is thrown or not. For example, after opening a file, it should be closed regardless of whether an exception is raised.
throw: It throws an exception when a problem occurs. This is done using the throw keyword.Assuming a block raises an exception, the method catches the exception using a combination of try and catch keywords. The try/catch block surrounds code that may generate an exception. The syntax for using try/catch looks like this:
try
{
// statements causing exception
}
catch (ExceptionName e1)
{
// error handling code
}
catch (ExceptionName e2)
{
// error handling code
}
finally
{
// statements to be executed
}
Multiple catch statements can be written to catch different types of exceptions in case the try block generates more than one exception in different situations.
class ExceptionTestClass
{
public static void Main()
{
int x = 0;
try
{
int y = 100 / x;
}
catch (ArithmeticException e)
{
Console.WriteLine($"ArithmeticException Handler: {e}");
}
catch (Exception e)
{
Console.WriteLine($"Generic Exception Handler: {e}");
}
}
}
Exceptions in C# are represented by classes. Exception classes in C# mainly derive directly or indirectly from the System.Exception class. Some exception classes derived from System.Exception include System.ApplicationException and System.SystemException. System.ApplicationException handles exceptions generated by applications, so custom exceptions should derive from this class. System.SystemException is the base class for all predefined system exceptions. The table below lists some predefined exception classes derived from System.SystemException:
| No. | Exception Class | Description |
|---|---|---|
| 1 | System.IO.IOException | Handles I/O errors. |
| 2 | System.IndexOutOfRangeException | Handles errors generated when a method refers to an array index out of range. |
| 3 | System.ArrayTypeMismatchException | Handles errors generated when the type is mismatched with the array type. |
| 4 | System.NullReferenceException | Handles errors generated from referencing a null object. |
| 5 | System.DivideByZeroException | Handles errors generated from dividing a dividend with zero. |
| 6 | System.InvalidCastException | Handles errors generated during upcasting. |
| 7 | System.OutOfMemoryException | Handles errors generated from insufficient free memory. |
| 8 | System.StackOverflowException | Handles errors generated from stack overflow. |
Applications in C# can throw system or user-defined exceptions. User-defined exceptions should minimally include four constructors:
For example:
public class InvalidNumberException : System.Exception
{
public InvalidNumberException() : base() { }
public InvalidNumberException(string message) : base(message) { }
public InvalidNumberException(string message, System.Exception inner) : base(message, inner) { }
}
// Usage
int DivideBy4(int a, int b)
{
if (b != 4)
throw new InvalidNumberException("Number b is not equal to 4");
return a / b;
}
System.Exception, System.SystemException, System.NullReferenceException, and System.IndexOutOfRangeException.Implement a method that takes a string parameter and prints its length to standard output.
null to this method and observe the exception thrown.try-catch block, catch the exception, and print the stack trace (StackTrace) to standard output immediately after printing it again.Implement three new exceptions and a method that randomly throws one of them on each call.
try-catch statement containing one catch block for each exception type. Have each catch block print which exception it caught.Write a program to check if exceptions thrown in catch blocks can be handled by the same block or one of the other blocks in the same try-catch statement.
In the example below, the try block has five statements. Each of them can throw the same exception. Propose a solution in the exception handling code to determine in which statement it occurred.
public class SomeClass
{
public void CanThrowException()
{
if (new Random().Next(5) == 0)
throw new Exception();
}
}
class Program
{
static void Main(string[] args)
{
SomeClass someClassObj = new SomeClass();
try
{
someClassObj.CanThrowException();
someClassObj.CanThrowException();
someClassObj.CanThrowException();
someClassObj.CanThrowException();
someClassObj.CanThrowException();
}
catch (Exception e)
{
// Handle the exception here
}
}
}
Implement a method to copy an object (copy each variable of the object, not just the reference). If no parameter is provided (e.g., null parameter), throw an appropriate exception with a relevant message. (You can use classes programmed in previous exercises).
Modify the previous task by creating your own data type. Then implement the IClonable interface and perform the first task again. Check the operation of the MemberwiseClone() method.
These tasks will help you understand exception handling and its nuances in C#.