System.Exception has four constructors:

Exception¹ is the default constructor. The Exception² constructor has a string parameter, which sets the user-friendly message of the exception. The Exception³ constructor sets the user-friendly message and the inner exception, which is the originating exception. Exception⁴ deserializes an exception raised remotely.

The Exception class has several other helpful methods. Table 12-1 lists the important methods of the class.

The following code calls GetBaseException and outputs the error message of the initial exception. If the current exception is the first exception in a chain of exceptions, GetBaseException returns null. Alternatively, you can walk InnerException properties back to the first exception:

using System;

namespace Donis.CSharpBook {
    public class Starter {
        public static void Main() {
            try {
                MethodA();
            }
            catch(Exception except) {
                Exception original = except.GetBaseException();
                Console.WriteLine(original.Message);
            }
        }

        public static void MethodA() {
            try {
                MethodB();
            }
            catch(Exception except) {
                throw new ApplicationException("Inner Exception", except);
            }
        }

        public static void MethodB() {
            throw new ApplicationException("Innermost Exception");
        }
    }
}

System.Exception has a full complement of properties providing information on the exception. Table 12-2 describes the properties of the Exception class.

The Message and InnerException properties are settable in constructors of the Exception class.

The following code uses some of the properties of the Exception class. In Main, MethodA is called, and an exception is raised. The exception is then caught and handled in Main. In the catch statement block, leveraging the TargetSite property, MethodA is then called again successfully. The TargetSite property returns a reference to an object of MethodBase type, which can be used to invoke the method where the exception occurred. At that time, the method is invoked anew with a fresh state. MethodBase.Invoke is explained fully in Chapter 10.

using System;
using System.Reflection;

namespace Donis.CSharpBook {
    public class Starter {
        public static bool bException = true;
        public static void Main() {
            try {
                MethodA();
            }
            catch(Exception except) {
                 Console.WriteLine(except.Message);
                 bException = false;
                 except.TargetSite.Invoke(null, null);
            }
        }

        public static void MethodA() {
            if (bException) {
                throw new ApplicationException("exception message");
            }
        }
    }
}

Application exceptions are custom exceptions and are thrown by the application, not by the CLR. Application exceptions are derived from System.ApplicationException or System.Exception. System.ApplicationException adds nothing to System.Exception. While System.SystemException is a marker for system exceptions, System.ApplicationException brands application exceptions. A custom exception derived from System.Exception can also be used to brand a group of custom exceptions; when several custom exceptions are planned, create a custom base exception class to categorize the exceptions. For convenience and maintainability, deploy application exceptions as a group in a separate assembly.

Do not accidentally create an application exception for an existing exception. Research the available system exceptions to avoid replicating an existing exception.

These are the steps for creating an application exception:

To raise an application exception, use the throw statement. You can also throw system exceptions. Thrown exceptions are considered software exceptions. The CLR reacts to software exceptions in the same way it does to standard exceptions. Here are some examples of throw syntax:

throw exceptioninstance;

throw;

The second syntax is specialized: It is available in a catch statement block but nowhere else. This version of the throw statement rethrows an exception caught in the catch statement block. However, the best policy is to add additional context to an exception before propagating the exception object. Propagating exceptions was reviewed earlier in this chapter.

Application exceptions are typically prompted by an exceptional event. What is an exceptional event? A strict definition for this term does not exist. Basically, you define the basis of an event. Remember that raising an exception simply for transfer of control or for a nonexceptional event is bad practice. In an application, the following could be considered exceptional events for which throwing an application exception is warranted:

ConstructorException is an application exception. In the following sample code, this exception is thrown when a constructor fails. It refines the System.Exception base class by adding a name and time property. In addition, the Message property is assigned an appropriate message. This is the code for the ConstructorException class:

using System;

namespace Donis.CSharpBook {

    public class ConstructorException: Exception {

        public ConstructorException(object origin)
                : this(origin, null) {
        }

        public ConstructorException(object origin, Exception innerException)
                : base("Exception in constructor", innerException) {
            prop_Typename = origin.GetType().Name;
            prop_Time = DateTime.Now.ToLongDateString() + " " +
                DateTime.Now.ToShortTimeString();
        }

   protected string prop_Typename=null;
        public string Typename {
            get {
                return prop_Typename;
            }
        }

        protected string prop_Time = null;
        public string Time {
            get {
                return prop_Time;
            }
        }
    }
}

This code uses the ConstructorException class:

using System;

namespace Donis.CSharpBook {
    public class Starter {
        public static void Main() {
            try {
                ZClass obj = new ZClass();
            }
            catch(ConstructorException except) {
                Console.WriteLine(except.Message);
                Console.WriteLine("Typename: " + except.Typename);
                Console.WriteLine("Occurred: " + except.Time);
            }
        }
    }

    class ZClass {
        public ZClass() {
            // initialization fails
            throw new ConstructorException(this);
        }
    }
}

In some circumstances, the CLR catches an exception and rethrows a different exception. The inner exception of the new exception contains the original exception. Check documentation in the Framework Class Library (FCL) to confirm when exception translation occurs. For example, invoking a method dynamically using reflection is one such circumstance. Exceptions raised in methods invoked by MethodInfo.Invoke are automatically trapped and converted to TargetInvocationException. The following code produces an example of exception translation:

using System;
using System.Reflection;

namespace Donis.CSharpBook {

    public class ZClass {
        public static void MethodA() {
            Console.WriteLine("ZClass.MethodA");
            throw new Exception("MethodA exception");
        }
    }

    public class Starter {
        public static void Main() {
            try {
                Type zType = typeof(ZClass);
                MethodInfo method = zType.GetMethod("MethodA");
                method.Invoke(null, null);
            }
            catch(Exception except) {
                Console.WriteLine(except.Message);
                Console.WriteLine("original: " +
                    except.InnerException.Message);
            }
        }
    }
}

.NET applications often host COM components or expose managed components to COM clients. These applications must be prepared to handle and possibly throw COM exceptions, respectively. The prevalence of COM components makes COM interoperability an important consideration for managed applications into the foreseeable future.

// ComponentZ.cpp : Implementation of CComponentZ

#include "stdafx.h"
#include "ComponentZ.h"
#include ".componentz.h"

// CComponentZ

STDMETHODIMP CComponentZ::MethodA(void) {
    // TODO: Add your implementation code here

    HRESULT hResult = MAKE_HRESULT( 1, FACILITY_NULL, 12 );

    MessageBox(NULL, "COM component", "Hello from", MB_OK);
    return AtlReportError (GetObjectCLSID(), "My error message", 5,
        "http://error.asp",GUID_NULL, hResult);
}

using System;
using System.Runtime.InteropServices;

namespace COMClient {
    class Program {
        static void Main(string[] args) {
            try {
                 COMLib.CComponentZClass com_object =
                     new COMLib.CComponentZClass();
                 com_object.MethodA();
            }
            catch (COMException except) {
                 Console.WriteLine(except.ErrorCode);
                 Console.WriteLine(except.HelpLink);
                 Console.WriteLine(except.Message);
            }
            catch (Exception) {

            }
        }
    }
}

using System;

namespace Donis.CSharpBook {

    public class TypeException: Exception {

        public TypeException()
                : base("object type wrong") {
            HResult = unchecked((int) 0x80004001); // E_NOTIMPL
        }

        public TypeException(Type objectType)
                : base("Argument type wrong: " + objectType.Name +
                    " required") {
            prop_RequiredType=objectType.Name;
            HResult = unchecked((int) 0x80004001); // E_NOTIMPL
        }

        private string prop_RequiredType;
        public string RequiredType {
            get {
                return prop_RequiredType;
            }
        }
    }
}

using System;

namespace Donis.CSharpBook {
    interface ZInterface {
        void MethodA();
    }

    public class Delegator {
        public Delegator(object obj) {
            externalobject = obj;
        }

        public void MethodA() {
            if (externalobject is ZInterface) {
                ((ZInterface)externalobject).MethodA();
            }
            else {
                throw new TypeException(
                    typeof(ZInterface));
            }
        }

        private object externalobject;
    }
}

using System;
using System.Runtime.InteropServices;
using Donis.CSharpBook;

class ZClass {
}

[ClassInterface(ClassInterfaceType.AutoDual)]
public class YClass {
    public void UseDelegator() {
        ZClass obj = new ZClass();
        Delegator del = new Delegator(obj);
        del.MethodA();
    }
}

#import "..yclass.tlb" no_namespace, raw_interfaces_only, named_guids

#include "objbase.h"

void main() {
    CoInitialize(NULL);
    _YClassPtr obj(CLSID_YClass);
    HRESULT hResult = obj->UseDelegator();
    if (hResult == E_NOTIMPL) {
       MessageBox(NULL,"Required interface not implemented",
           "In Managed Component", MB_OK);
    }
    else {
        MessageBox(NULL, "Managed Component", "No error",
            MB_OK);
    }
}