#870 – Where Execution Continues when an Exception Is Caught

When an exception is thrown that you catch in a catch block, the code in the catch block will execute.  Once all of the code in the catch block executes, execution will continue with the first line following the try-catch statement.  (Assuming that your catch block does not itself throw an exception).

            try
            {
                DoSomething();
                Console.WriteLine("In try block, before call that throws exception");
                DoSomethingThatThrowsAnException();
                Console.WriteLine("In try block, after call that throws exception");
                DoSomethingElse();
            }
            catch (FileNotFoundException noFileExc)
            {
                Console.WriteLine("FileNotFoundException");
            }
            catch (ArgumentOutOfRangeException argExc)
            {
                Console.WriteLine("ArgumentOutOfRangeException");
            }
            catch (Exception exc)
            {
                Console.WriteLine("Some other Exception");
            }

            Console.WriteLine("Now I'm continuing after the try-catch statement");

When this code runs, the statements in the try block begin executing.  The second method that we call results an exception, which is caught in the ArgumentOutOfRangeException catch block.  Once that block finishes executing, we continue with the code after the last catch block.

#869 – Example of Catching an Exception Thrown by the .NET Framework

Below is a complete example that shows how we might catch an exception thrown by the .NET Framework.

Our Dog class builds a list of all dogs created and allows you to retrieve a dog by index.

    public class Dog
    {
        private static List<Dog> _allDogs = new List<Dog>();

        public string Name { get; set; }
        public int Age { get; set; }

        // Standard constructor
        public Dog(string name, int age)
        {
            Name = name;
            Age = age;
            _allDogs.Add(this);
        }

        public static Dog DogByIndex(int index)
        {
            return _allDogs[index];
        }
    }

We can protect code that calls the DogByIndex method with a try-catch statement.

            try
            {
                Dog d1 = new Dog("Kirby", 15);
                Dog d2 = new Dog("Ruby", 3);

                // Later, get dog by index
                Dog someDog = Dog.DogByIndex(2);  // Oops--index of 2 is wrong!
            }
            catch (ArgumentOutOfRangeException exc)
            {
                Console.WriteLine("The dog index you used is out of range!");
                Console.WriteLine(exc.Message);
            }

#868 – List Most Specific Exception Types First

When you include more than one catch blocks as part of a try-catch statement, you must list the most specific exception types first.  When an exception occurs, the type of the exception object is compared with the type of each catch block in order, starting with the first.  When the type exception parameter in the catch block matches or is a parent type of the type of the exception, that catch block will “catch” the exception and later blocks will not be examined.

The compiler will enforce listing the most derived exception types first.  In the example below,  FileNotFoundException derives (indirectly) from Exception.  A handler for Exception cannot precede a handler for FileNotFoundException because the Exception handler will catch exceptions of both types.  The code below results in a compiler error.

                try
                {
                    DoSomething();
                }
                catch (Exception exc)
                {
                    Console.WriteLine("Exception");
                }
                catch (FileNotFoundException noFileExc)
                {
                    Console.WriteLine("FileNotFoundException");
                }