{"id":126,"date":"2011-11-24T14:25:27","date_gmt":"2011-11-24T06:25:27","guid":{"rendered":"https:\/\/www.techcoil.com\/blog\/?p=126"},"modified":"2018-09-03T21:19:05","modified_gmt":"2018-09-03T13:19:05","slug":"some-information-about-exceptions-in-software-systems","status":"publish","type":"post","link":"https:\/\/www.techcoil.com\/blog\/some-information-about-exceptions-in-software-systems\/","title":{"rendered":"Some information about exceptions in software systems"},"content":{"rendered":"

Throughout my software development exposures, defining and handling exceptions has always constituted a fair amount of my programming considerations. This post collates information about exceptions that I had came across. <\/p>\n

The need for handling errors in your codes<\/h3>\n

Handling errors in your codes is intuitive - you are writing codes that people will use and people make mistakes. A good read of 100 things every designer needs to know about people<\/a> by Susan Weinschenk will give you great insights on that. <\/p>\n

Preventing people from making mistakes<\/h4>\n

Perhaps it may be better to prevent people from making mistakes while using a program feature, but there are times when it is beyond our control or technically challenging. A batch processing job that receives work input from the HTML file upload dialog box can be given a file type that is not expected. Even if we implement restriction on the file type, there is still no way to stop mischievous users from uploading files with invalid data format.<\/p>\n

Unavoidable mistakes<\/h4>\n

The people part is one part of the story; components that you use in your code may fail too. Insufficient storage, invalid permissions, server does not like your request and what not. For example, making a WSDL<\/a> call via C# codes generated from wsdl.exe<\/a> may result in <\/p>\n

    \n
  1. Server code encountering errors in processing the wsdl call.<\/li>\n
  2. Server process could not find the code to handle the wsdl call.<\/li>\n
  3. Server refusing the client request.<\/li>\n
  4. Client cannot connect to the server at the network layer.<\/li>\n
  5. Client does not have network connection.<\/li>\n
  6. And many unexpected ones like Microsoft fly-by compiler attempts to create a temporary file but the operating system doesn't have a temporary folder.<\/li>\n<\/ol>\n

    What are exceptions?<\/h3>\n

    Exceptions are programming constructs that encapsulate error information. In an object oriented environment, they are usually defined with a generic exception construct and thrown around when unwanted conditions occurs. <\/p>\n

    Suppose that we want to define an exception that is thrown when our program cannot initialise itself due to missing prerequisites. One way to do so in C# is as follows:<\/p>\n

    \r\npublic class MissingPrerequisitesException\r\n: ApplicationException\r\n{\r\n    \/\/ Declare an enum that provides a set of\r\n    \/\/ reasons for callers\r\n    public enum ExceptionReason\r\n    {\r\n        MissingComponents,\r\n        MissingConfigurationFile,\r\n        MissingConfigurations,\r\n    };\r\n\r\n    \/\/ Take note of the reason\r\n    private ExceptionReason _reason;\r\n\r\n    public ExceptionReason Reason\r\n    {\r\n        get\r\n        {\r\n            return this._reason;\r\n        }\r\n\r\n        private set\r\n        {\r\n            this._reason = value;\r\n        }\r\n    } \r\n \r\n    public MissingPrerequisitesException(\r\n        ExceptionReason reason,\r\n        string message)\r\n        : base(message)\r\n    {\r\n        this.Reason = reason;\r\n    }\r\n\r\n    public MissingPrerequisitesException(\r\n        ExceptionReason reason,\r\n        string message,\r\n        Exception inner)\r\n        : base(message, inner)\r\n    {\r\n        this.Reason = reason;\r\n    }\r\n\r\n} \/\/ end public class MissingPrerequisitesException\r\n<\/pre>\n
    And when our program detects a missing configuration file, it can throw an instance of the exception class with the throw<\/code> keyword:<\/p>\n
    \r\npublic void LoadConfigurations()\r\n{\r\n    if (!File.Exists("config-file.txt"))\r\n    {\r\n        throw new MissingPrerequisitesException(\r\n            MissingPrerequisitesException.ExceptionReason.MissingConfigurations,\r\n            "Configuration file does not exists!");\r\n    } \/\/ end if\r\n\r\n    \/\/ Read configurations from the file\r\n    \/\/ ...\r\n\r\n} \/\/ end public void LoadConfigurations()\r\n<\/pre>\n
    Why exceptions?<\/h3>\n
    Exceptions contain rich information about an error that happened<\/h4>\n
    Implicitly, exceptions contain information for developers to know how and what error had happened. <\/p>\n
    For instance, the caller of LoadConfigurations<\/code> can enclose the call in a try-catch block and print the exception stack trace:<\/p>\n
    \r\nprivate void Init()\r\n{\r\n    try\r\n    {\r\n        LoadConfigurations();\r\n        \/\/ Configure other components\r\n        \/\/ ...\r\n    }\r\n    catch (MissingPrerequisitesException mpe)\r\n    {\r\n        \/\/ The error that occurred is due to\r\n        \/\/ missing prerequisites\r\n        Console.WriteLine("Missing prerequisites!");\r\n        \/\/ Print the message\r\n        Console.WriteLine(mpe.);\r\n        \/\/ Print the stack trace\r\n        Console.WriteLine(mpe.StackTrace);\r\n\r\n    }\r\n} \/\/ end private void init()\r\n<\/pre>\n
    And when the config-file.txt file cannot be found by the program, the program will output something like this:<\/p>\n
    \r\nMissing prerequisites!\r\nConfiguration file does not exists!\r\n   at Program.LoadConfigurations() in d:\\poc\\exceptions\\Program.cs:line 47\r\n   at Program.Init() in d:\\poc\\exceptions\\Program.cs:line 27\r\n<\/pre>\n
    The 3rd line is the stack trace. Reading from the bottom up (from the 4th line), a developer can know that there is a Program.cs file and the error happens in the following sequence: <\/p>\n
      \n
    1. \nThe Init<\/code> method is called<\/li>\n
    2. In the Init() method, the LoadConfigurations<\/code> method is called.<\/li>\n<\/ol>\n
      And because the LoadConfigurations<\/code> method is at the top of the stack trace, it is the method that reports a missing configuration file.  <\/p>\n
      Those are standard items that our MissingPrequisitesException class inherits from its parent class. We can also introduce more information within our custom defined exceptions to aid the exception handling code in reacting to the exception. For instance, with the Reason<\/code> property that was introduced in the MissingPrequisitesException class, the exception handling code can react to different cases of missing prerequisites with a switch<\/code> statement:<\/p>\n
      \r\nswitch(mpe.Reason) \r\n{\r\n    case MissingPrerequisitesException.ExceptionReason.MissingComponents:\r\n        Console.WriteLine("Missing components, please check your installation.");\r\n        break;\r\n    case MissingPrerequisitesException.ExceptionReason.MissingConfigurationFile:\r\n        Console.WriteLine("Missing configuration file, make sure that config-file.txt is in the same directory as the running program.");\r\n        break;\r\n    case MissingPrerequisitesException.ExceptionReason.MissingConfigurations:\r\n        Console.WriteLine("Missing configurations, make sure that all needed configurations are supplied via config-file.txt.");\r\n        break;\r\n} \/\/ end switch(mpe.Reason)\r\n<\/pre>\n
      Some articles which helped me gained great insights to the area of exceptions<\/h3>\n