C#
  Home arrow C# arrow Exception Handling in C#
Dev Articles Forums 
ADO.NET  
Apache  
ASP  
ASP.NET  
C#  
C++  
ColdFusion  
COM/COM+  
Delphi-Kylix  
Design Usability  
Development Cycles  
DHTML  
Embedded Tools  
Flash  
Graphic Design  
HTML  
IIS  
Interviews  
Java  
JavaScript  
MySQL  
Oracle  
Photoshop  
PHP  
Reviews  
Ruby-on-Rails  
SQL  
SQL Server  
Style Sheets  
VB.Net  
Visual Basic  
Web Authoring  
Web Services  
Web Standards  
XML  
Mobile Linux 
App Generation ROI 
IBM® developerWorks 
Weekly Newsletter
 
Developer Updates  
Free Website Content 
 RSS  Articles
 RSS  Forums
 RSS  All Feeds
Write For Us Get Paid 
Request Media Kit
Contact Us 
Site Map 
Privacy Policy 
Support 
 USERNAME
 
 PASSWORD
 
 
  >>> SIGN UP!  
  Lost Password? 
C#

Exception Handling in C#
By: Rajesh V S
  • Search For More Articles!
  • Disclaimer
  • Author Terms
  • Rating: 4 stars4 stars4 stars4 stars4 stars / 19
    2003-04-23

    Table of Contents:

    Rate this Article: Poor Best 
      ADD THIS ARTICLE TO:
      Del.ici.ous Digg
      Blink Simpy
      Google Spurl
      Y! MyWeb Furl
    Email Me Similar Content When Posted
    Add Developer Shed Article Feed To Your Site
    Email Article To Friend
    Print Version Of Article
    PDF Version Of Article
     
     
    ADVERTISEMENT


    As we all know, exception handling becomes a very handy tool for debugging an application. Rajesh will now explein how one should use Exceptions in C#.

    Exception handling is an in built mechanism in .NET framework to detect and handle run time errors. The .NET framework contains lots of standard exceptions. The exceptions are anomalies that occur during the execution of a program. They can be because of user, logic or system errors. If a user (programmer) do not provide a mechanism to handle these anomalies, the .NET run time environment provide a default mechanism, which terminates the program execution. 

    C# provides three keywords try, catch and finally to do exception handling. The try encloses the statements that might throw an exception whereas catch handles an exception if one exists. The finally can be used for doing any clean up process.

    The general form try-catch-finally in C# is shown below 

    try
    {
    // Statement which can cause an exception.
    }
    catch(Type x)
    {
    // Statements for handling the exception
    }
    finally
    {
    //Any cleanup code
    }

    If any exception occurs inside the try block, the control transfers to the appropriate catch block and later to the finally block.  

    But in C#, both catch and finally blocks are optional. The try block can exist either with one or more catch blocks or a finally block or with both catch and finally blocks. 

    If there is no exception occurred inside the try block, the control directly transfers to finally block. We can say that the statements inside the finally block is executed always. Note that it is an error to transfer control out of a finally block by using break, continue, return or goto. 

    In C#, exceptions are nothing but objects of the type Exception. The Exception is the ultimate base class for any exceptions in C#. The C# itself provides couple of standard exceptions. Or even the user can create their own exception classes, provided that this should inherit from either Exception class or one of the standard derived classes of Exception class like DivideByZeroExcpetion ot ArgumentException etc. 

    Uncaught Exceptions
     
    The following program will compile but will show an error during execution. The division by zero is a runtime anomaly and program terminates with an error message. Any uncaught exceptions in the current context propagate to a higher context and looks for an appropriate catch block to handle it. If it can’t find any suitable catch blocks, the default mechanism of the .NET runtime will terminate the execution of the entire program. 

    //C#: Exception Handling
    //Author:
    rajeshvs@msn.com
        
    using System;
    class MyClient
    {
                public static void Main()
                {
                            int x = 0;
                            int div = 100/x;
                            Console.WriteLine(div);
                }
    }

    The modified form of the above program with exception handling mechanism is as follows. Here we are using the object of the standard exception class DivideByZeroException to handle the exception caused by division by zero. 

    //C#: Exception Handling
    //Author:
    rajeshvs@msn.com
    using System;
    class MyClient
    {
                public static void Main()
                {
                            int x = 0;
                            int div = 0;
                            try
                            {
                                        div = 100/x;
                                        Console.WriteLine(“This line in not executed”);
                            }
                            catch(DivideByZeroException de)
                            {
                                        Console.WriteLine("Exception occured");
                                       
                           }
                            Console.WriteLine("Result is {0}",div);
                }
    }

    In the above case the program do not terminate unexpectedly. Instead the program control passes from the point where exception occurred inside the try block to the catch blocks. If it finds any suitable catch block, executes the statements inside that catch and continues with the normal execution of the program statements.

    If a finally block is present, the code inside the finally block will get also be executed.  

    //C#: Exception Handling
    //Author:
    rajeshvs@msn.com
      using System;
    class MyClient
    {
                public static void Main()
                {
                            int x = 0;
                            int div = 0;
                            try
                            {
                                        div = 100/x;
                                        Console.WriteLine("Not executed line");
                            }
                            catch(DivideByZeroException de)
                            {
                                        Console.WriteLine("Exception occured");
                            }
                            finally
                            {
                                        Console.WriteLine("Finally Block");
                            }
                            Console.WriteLine("Result is {0}",div);
                }
    }

    Remember that in C#, the catch block is optional. The following program is perfectly legal in C#.

    //C#: Exception Handling
    //Author:
    rajeshvs@msn.com
     using System;
    class MyClient
    {
                public static void Main()
                {
                            int x = 0;
                            int div = 0;
                            try
                            {
                                        div = 100/x;
                                        Console.WriteLine("Not executed line");
                            }
                            finally
                            {
                                        Console.WriteLine("Finally Block");
                            }
                            Console.WriteLine("Result is {0}",div);
                }
    }
     

    But in this case, since there is no exception handling catch block, the execution will get terminated. But before the termination of the program statements inside the finally block will get executed. In C#, a try block must be followed by either a catch or finally block 

    Multiple Catch Blocks
     
    A try block can throw multiple exceptions, which can handle by using multiple catch blocks. Remember that more specialized catch block should come before a generalized one. Otherwise the compiler will show a compilation error. 

    //C#: Exception Handling: Multiple catch
    //Author:
    rajeshvs@msn.com
    using System;
    class MyClient
    {
                public static void Main()
                {
                            int x = 0;
                            int div = 0;
                            try
                            {
                                        div = 100/x;
                                        Console.WriteLine("Not executed line");
                            }
                            catch(DivideByZeroException de)
                            {
                                        Console.WriteLine("DivideByZeroException" );
                            }
                            catch(Exception ee)
                            {
                                        Console.WriteLine("Exception" );
                            }
                            finally
                            {
                                        Console.WriteLine("Finally Block");
                            }
                            Console.WriteLine("Result is {0}",div);
                }
    }
     

    Catching all Exceptions
     
    By providing a catch block without a brackets or arguments, we can catch all exceptions occurred inside a try block. Even we can use a catch block with an Exception type parameter to catch all exceptions happened inside the try block since in C#, all exceptions are directly or indirectly inherited from the Exception class.  

    //C#: Exception Handling: Handling all exceptions
    //Author:
    rajeshvs@msn.com
     using System;
    class MyClient
    {
                public static void Main()
                {
                            int x = 0;
                            int div = 0;
                            try
                            {
                                        div = 100/x;
                                        Console.WriteLine("Not executed line");
                            }
                            catch
                            {
                                        Console.WriteLine("oException" );
                            }
                            Console.WriteLine("Result is {0}",div);
                }
    }
     

    The following program handles all exception with Exception object.

    //C#: Exception Handling: Handling all exceptions
    //Author:
    rajeshvs@msn.com
    using System;
    class MyClient
    {
                public static void Main()
                {
                            int x = 0;
                            int div = 0;
                            try
                            {
                                        div = 100/x;
                                        Console.WriteLine("Not executed line");
                            }
                            catch(Exception e)
                            {
                                        Console.WriteLine("oException" );
                            }
                            Console.WriteLine("Result is {0}",div);
                }
    }

    Throwing an Exception
     
    In C#, it is possible to throw an exception programmatically. The ‘throw’ keyword is used for this purpose. The general form of throwing an exception is as follows.

    throw exception_obj; 

    For example the following statement throw an ArgumentException explicitly.

    throw new ArgumentException(“Exception”); 

    //C#: Exception Handling:
     //Author:
    rajeshvs@msn.com
    using System;
    class MyClient
    {
                public static void Main()
                {
                            try
                            {
                                        throw new DivideByZeroException("Invalid Division");
                            }
                            catch(DivideByZeroException e)
                            {
                                        Console.WriteLine("Exception" );
                            }
                            Console.WriteLine("LAST STATEMENT");
                }
    }
     

    Re-throwing an Exception

    The exceptions, which we caught inside a catch block, can re-throw to a higher context by using the keyword throw inside the catch block. The following program shows how to do this.  

    //C#: Exception Handling: Handling all exceptions
    //Author:
    rajeshvs@msn.com
    using System;
    class MyClass
    {
                public void Method()
                {
                            try
                            {
                                        int x = 0;
                                        int sum = 100/x;
                            }
                            catch(DivideByZeroException e)
                            {
                                        throw;
                            }
                }
    }
    class MyClient
    {
                public static void Main()
                {
                            MyClass mc = new MyClass();
                            try
                            {
                                        mc.Method();
                            }
                            catch(Exception e)
                            {
                                        Console.WriteLine("Exception caught here" );
                            }
                            Console.WriteLine("LAST STATEMENT");
                }
    }
     

    Standard Exceptions
     
    There are two types of exceptions: exceptions generated by an executing program and exceptions generated by the common language runtime. System.Exception is the base class for all exceptions in C#. Several exception classes inherit from this class including ApplicationException and SystemException. These two classes form the basis for most other runtime exceptions. Other exceptions that derive directly from System.Exception include IOException, WebException etc. 

    The common language runtime throws SystemException. The ApplicationException is thrown by a user program rather than the runtime. The SystemException includes the ExecutionEngineException, StaclOverFlowException etc. It is not recommended that we catch SystemExceptions nor is it good programming practice to throw SystemExceptions in our applications.

    System.OutOfMemoryException

    System.NullReferenceException

    System.InvalidCastException

    System.ArrayTypeMismatchException

    System.IndexOutOfRangeException        

    System.ArithmeticException

    System.DevideByZeroException

    System.OverFlowException

    User-defined Exceptions
     
    In C#, it is possible to create our own exception class. But Exception must be the ultimate base class for all exceptions in C#. So the user-defined exception classes must inherit from either Exception class or one of its standard derived classes.

    //C#: Exception Handling: User defined exceptions
    //Author:
    rajeshvs@msn.com
    using System;
    class MyException : Exception
    {
                public MyException(string str)
                {
                            Console.WriteLine("User defined exception");
                }
    }
    class MyClient
    {
                public static void Main()
                {
                            try
                            {
                                        throw new MyException("RAJESH");
                            }
                            catch(Exception e)
                            {
                                        Console.WriteLine("Exception caught here" + e.ToString());
                            }
                            Console.WriteLine("LAST STATEMENT");
                }
    }

    Design Guidelines

    Exceptions should be used to communicate exceptional conditions. Don’t use them to communicate events that are expected, such as reaching the end of a file. If there’s a good predefined exception in the System namespace that describes the exception condition-one that will make sense to the users of the class-use that one rather than defining a new exception class, and put specific information in the message.

    Finally, if code catches an exception that it isn’t going to handle, consider whether it should wrap that exception with additional information before re-throwing it.


    DISCLAIMER: The content provided in this article is not warranted or guaranteed by Developer Shed, Inc. The content provided is intended for entertainment and/or educational purposes in order to introduce to the reader key ideas, concepts, and/or product reviews. As such it is incumbent upon the reader to employ real-world tactics for security and implementation of best practices. We are not liable for any negative consequences that may result from implementing any information covered in our articles or tutorials. If this is a hardware review, it is not recommended to open and/or modify your hardware.

    More C# Articles
    More By Rajesh V S

     

    IBM® developerWorks developerWorks - FREE Tools!


    NEW! Build Web services with transport-level security using Rational Application Developer V7, Part 1: Build Web services and Web services clients

    Build secure Web services with transport-level security using IBM Rational Application Developer V7 and IBM WebSphere Application Server V6.1. Follow this three-part series for step-by-step instructions about how to develop Web services and clients, configure HTTP basic authentication, and configure HTTP over SSL (HTTPS). This first part of the series walks you through building a Web service for a simple calculator application. You generate and test two different types of Web services clients: a Java Platform, Enterprise Edition (Java EE) client and a stand-alone Java client. You also handle user-defined exceptions in Web services.
    FREE! Go There Now!


    NEW! Download DB2 Express-C 9.5

    Visit IBM developerWorks to download IBM DB2 Express-C 9.5, a no-charge version of DB2 Express 9 database server. DB2 Express-C offers the same core data server base features as other DB2 Express editions and provides a solid base to build and deploy applications developed using C/C++, Java, .NET, PHP, and other programming languages.
    FREE! Go There Now!


    NEW! Download IBM WebSphere Portal V6.1 beta code

    Download the IBM WebSphere Portal V6.1 beta code and learn more about the rich features and enhancements in IBM WebSphere Portal V6.1. WebSphere Portal provides a composite application or business mashup framework and the advanced tooling needed to build flexible, SOA-based solutions, and scalability to meet the needs of any size organization.
    FREE! Go There Now!


    NEW! Evaluate Rational Business Developer V7.1

    Visit IBM developerWorks to download a free trial version of IBM Rational Business Developer V7.1. Rational Business Developer offers rapid and simplified development of business applications and services through Enterprise Generation Language (EGL) tools, generating Java or mainframe solutions while shielding developers from technical complexities.
    FREE! Go There Now!


    NEW! IBM Rational AppScan Standard Edition V7.7

    Secure your Web applications with IBM Rational AppScan Standard Edition V7.7, previously known as Watchfire AppScan. This Web application security testing tool automates vulnerability assessments and scans and tests for common Web application vulnerabilities. Visit IBM developerWorks to download a free trial of IBM Rational AppScan Standard Edition V7.7.
    FREE! Go There Now!


    NEW! Improve your build process with IBM Rational Build Forge, Part 2: Automate builds for a real-world Tomcat project

    Learn how Rational Build Forge can extend a simple compile and package build process by adding customization and deployment capability. Go from a manual method to automating: checking for code changes; getting the latest source; compiling and packaging; customizing; copying to and restarting a deployment server; and sending e-mail notification that a new version is available.
    FREE! Go There Now!


    NEW! Rational Modeling Extension for Microsoft.Net

    Rational Modeling Extension for Microsoft .NET enhances usability for code generation supporting a more intelligent refactoring. The latest enhancements enable organizations with Java and .NET systems and software development maintain architectural integrity across heterogeneous platforms.
    FREE! Go There Now!


    NEW! The dirty dozen: preventing common application-level hack attacks

    As organizations have grown increasingly dependent on online software, the risk of malicious attacks has also become far more serious. Fortunately, well-governed organizations can protect their Web applications by injecting vulnerability assessments and ethical hacks into their software development and delivery processes. This paper describes 12 of the most common hacker attacks and provides basic rules that you can follow to help create more hack-resistant Web applications.
    FREE! Go There Now!


    NEW! The role of integrated requirements management in software delivery

    This paper is about the critical role that a discipline called integrated require­ments management can play in helping to ensure that your business goals and IT investments are continuously aligned—whether you are sourcing, integrat­ing, building or maintaining software. It also looks at ways that automated IBM Rational® products can work together to help you use requirements in the very best way.
    FREE! Go There Now!


    NEW! Try the IBM SOA Sandbox for Process

    Visit IBM developerWorks to try the IBM SOA Sandbox for process. The SOA Sandbox for process focuses on providing a trial environment with the necessary tooling and components required to gain a better understanding of business processes and how to best improve existing business processes to derive value quickly.
    FREE! Go There Now!



    All FREE IBM® developerWorks Tools!

    C# ARTICLES

    - Introduction to Objects and Classes in C#, P...
    - Visual C#.NET, Part 1: Introduction to Progr...
    - C# - An Introduction
    - Hotmail Exposed: Access Hotmail using C#
    - Razor Sharp C#
    - Introduction to Objects and Classes in C#
    - Making Your Code CLS Compliant
    - Programming with MySQL and .NET Technologies
    - Socket Programming in C# - Part II
    - Socket Programming in C# - Part I
    - Creational Patterns in C#
    - Type Conversions
    - Creating Custom Delegates and Events in C#
    - Inheritance and Polymorphism
    - Understanding Properties in C#







    © 2003-2010 by Developer Shed. All rights reserved. DS Cluster 2 Hosted by Hostway
    For more Enterprise Application Development news, visit eWeek