C# Exception Types

System-Level Exceptions (System.SystemException)

.NET Base Class Library में बहुत सारी ऐसी Classes को Define किया गया है, जो कि System.Exception Class से Inherited हैं। उदाहरण के लिए System Namespace में ArgumentOutOfRangeException, IndexOutOfRangeException, StackOverflowException जैसे Core Exception Objects को Define किया गया है।

इसी तरह से System.Drawing.Printing Namespace में Printing Related Exceptions को, System.IO Namespace में Input/Output Based Exceptions को, System.Data Namespace में Database Related Exceptions को Define किया गया है और इसी तरह से अन्‍य Namespaces में उनके Behavior के अनुसार विभिन्न प्रकार के अन्‍य Exception Classes को Define किया गया है।

वे Exceptions, जिन्हें किसी Error को Represent करने के लिए .NET Platform द्वारा Throw किया जाता है, System Exceptions कहलाते हैं। ये ऐसे Exception को Represent करते हैं, जो कि सामान्‍यत: Non-Recoverable यानी Fatal Errors होते है।

System Exceptions Directly System.SystemException Class से Derive होते हैं, जो कि स्वयं System.Exception से Derived है और System.Exception स्वयं System.Object से Derived है।

System.SystemException Class में दो Constructor के अलावा अन्‍य कोई Extra Functionality Add नहीं की गई है। लेकिन इस Class द्वारा हम इस बात को Identify कर पाते हैं, कि .NET Platform ने जो Exception Trigger किया है, वह एक System Level Exception है, Application Level नहीं। यानी Generate होने वाली Error, .NET Framework के किसी Code द्वारा Generate हुई है, Application Code द्वारा नहीं। (C# Exception Types)

Application-Level Exceptions (System.ApplicationException)

सभी .NET Exceptions Class Type होते हैं, इसलिए हम इन्हें Derive करके हमारे स्वयं के Application Specific Exception Type भी Create कर सकते हैं।

System.SystemException Base Class हमेंशा CLR द्वारा Return होने वाले Exceptions को Represent करता है, इसलिए System.Exception Type को Derive करके हम हमारे स्वयं के Custom Exception Type Define कर सकते हैं।

लेकिन हमें ऐसा नहीं करना चाहिए, बल्कि यदि हम हमारे स्वयं के Exception Type Define करना चाहते हैं, तो हमें हमेंशा System.ApplicationException Class को Derive करना चाहिए, ताकि हम हमारे Program में जब चाहें तब इस बात का पता लगा सकें, कि Generate होने वाला Exception System Level है या Application Level है।

System.SystemException की तरह ही System.ApplicationException Class में भी केवल दो Constructors ही Define किए गए हैं। क्योंकि Functionally इस Class का केवल इतना ही उद्देश्‍य है कि हम इस बात की जानकारी प्राप्त कर सकें कि Generate होने वाला Exception एक Application Exception है या नहीं।

Defining Custom C# Exception Types

चूंकि System.Exception .NET Framework की सभी तरह की Runtime Errors को Represent करने के बनाई गई Base Class है, इसलिए यदि हम चाहें तो इस Type के Object को किसी भी प्रकार के Exception को Handle करने के लिए Use कर सकते हैं।

लेकिन हर Application Unique होता है और हर Application द्वारा Application Level पर Generate होने वाली Errors भी Unique होती हैं, इसलिए सामान्‍यत: अपने Application Level की Errors को बेहतर तरीके से Manage करने के लिए हम हमारे स्वयं के Custom Exception Types Define कर सकते हैं।

जब हम Custom Exception Types Define करते हैं, तब ये जरूरी होता है कि हम हमारे सभी Exception Types को public Modifier के साथ Define करें, ताकि पूरे Application के Cross-Assembly Execution दौरान उस Exception Type को कहीं पर भी Throw व Catch कर सकें।

नया Exception Type Create करने के लिए हम System.SystemException या System.ApplicationException को Derive कर सकते हैं अथवा System.Exception नाम की Top Level Exception Class को भी Derive कर सकते हैं।

हालांकि हमें हमेंशा अपने Application Level Exceptions को Define करने के लिए System.ApplicationException Class को ही Derive करना चाहिए, क्योंकि Conceptually इस Class को Application Level Exceptions को Represent करने वाले नए Exception Types को Define करने के लिए ही बनाया गया है। जैसे:

File Name: ManualExceptionObjectMessage.cs
using System;

namespace CSharpClass
{
    public class WatchException : ApplicationException {
        private string messageDetails = String.Empty;
        public DateTime ErrorTimeStamp { get; set; }
        public string CauseOfError { get; set; }

        public WatchException() { }
        public WatchException(string msg, string cause, DateTime time) {
            messageDetails = msg;
            CauseOfError = cause;
            ErrorTimeStamp = time;
        }

        // Override the Exception.Message property.
        public override string Message {
            get {
                return string.Format("Watch Error Message: {0}", messageDetails);
            }
        }
    }

    class Watch {
        public byte hour { set; get; }
        public byte minute { set; get; }

        public Watch() {
            hour = 12;
            minute = 0;
        }

        public void SetTime(byte h, byte m) {
            try {
                if (h > 23) {
                    WatchException exp = new WatchException(
                        string.Format("Invalid Time Specified."),
                        string.Format("Hour is {0}, which can't be more then 23", h),
                        DateTime.Now
                    );
                    exp.HelpLink = "https://www.bccfalna.com/";
                    throw exp;
                }
                else {
                    hour = h;
                    minute = m;
                }
            }
            catch (WatchException exp) {
                Console.WriteLine("Error Description: " + exp.Message);
                Console.WriteLine("Cause of Error: " + exp.CauseOfError);
                Console.WriteLine("Time of Error: " + exp.ErrorTimeStamp);
            }
        }

        public void DisplayTime() {
            Console.WriteLine(hour + ":" + minute);
        }
    }

    class UsingWatchException {
        static void Main(String[] arg) {
            Watch hmt = new Watch();
            hmt.SetTime(30, 10);
            Console.Write("Time of the HMT Watch is: ");
            hmt.DisplayTime();
        }
    }
}

// Output:
Error Description: Watch Error Message: Invalid Time Specified.
Cause of Error: Hour is 30, which can't be more then 23
Time of Error: 7/2/2013 12:20:38 PM
	Time of the HMT Watch is: 12:0

इस Program में हमने सबसे पहले निम्नानुसार Code द्वारा WatchException नाम का एक नया Exception Type Define किया है:

    public class WatchException : ApplicationException {
        private string messageDetails = String.Empty;
        public DateTime ErrorTimeStamp { get; set; }
        public string CauseOfError { get; set; }

        public WatchException() { }
        public WatchException(string msg, string cause, DateTime time) {
            messageDetails = msg;
            CauseOfError = cause;
            ErrorTimeStamp = time;
        }

        // Override the Exception.Message property.
        public override string Message {
            get {
                return string.Format("Watch Error Message: {0}", messageDetails);
            }
        }
    }

इस Code में हमने ApplicationException Type को Derive करके एक नया WatchException Type Define किया है, जिसमें messageDetails नाम की एक Private Property व ErrorTimeStamp तथा CauseOfError नाम की दो Public Properties हैं, जो कि क्रमश: Error का Description, Error का कारण व Error Generate होने के Time को Store करते हैं।

चूंकि, इस बार हम हमारे Program द्वारा एक Application Exception Throw करना चाहते हैं, जिसे हमने स्वयं अपनी जरूरत के अनुसार ApplicationException Class को Derive करके Define किया है, इसलिए इस Exception को Throw करने के लिए हमने इसे SetTime() Method में Specify किया है।

जब हम Main() Method में Watch Type का एक नया Object Create करके उसे Time Set करते हैं, तो SetTime() Method Object के Time को Set करने से पहले निम्न Conditional Code Execute करता है:

            try {
                if (h > 23) {
                    WatchException exp = new WatchException(
                        string.Format("Invalid Time Specified."),
                        string.Format("Hour is {0}, which can't be more then 23", h),
                        DateTime.Now
                    );
                    exp.HelpLink = "https://www.bccfalna.com/";
                    throw exp;
                }
                else {
                    hour = h;
                    minute = m;
                }
            }
            catch (WatchException exp) {
                Console.WriteLine("Error Description: " + exp.Message);
                Console.WriteLine("Cause of Error: " + exp.CauseOfError);
                Console.WriteLine("Time of Error: " + exp.ErrorTimeStamp);
            }

चूंकि हमने Main() Method में निम्न Statement द्वारा hmt नाम के Object के Time को Set किया है, जिसके First Parameter का मान 30 है:

hmt.SetTime(30, 10);

इसलिए जब SetTime() Method Call होता है, तो try Block से exp नाम का एक नया WatchException Type Object WatchException() Constructor में हम Error के Description, Error के Cause व Error के Time को Specify करके Create करते हैं तथा Exception से सम्बंधित Help के लिए HelpLink Property को Set करके Throw कर देते हैं।

परिणामस्वरूप Throw होने वाला WatchException Type का Object आगे Specified catch Block में Catch किया जाता है और जो Parameters हमने WatchException Type exp Object Create करते समय WatchException() Constructor में Specify किए थे, उन सभी Parameters के मानों को इस Catch Block में Display कर दिया जाता है।

इस तरह से हम समझ सकते हैं कि हम हमारे Application की Requirements से सम्बंधित Errors को Represent करने के लिए किस तरह से .NET Framework के ApplicationException Type को Derive करके अपने Program में Use कर सकते हैं।

हालांकि हम हमारे Application Related Exceptions को Handle करने के लिए अपने स्वयं के Exception Types Define कर सकते हैं। लेकिन सामान्‍यत: जिन Errors के लिए पहले से Types Defined हैं, उन्हीं को Manage करने के लिए हमें फिर से एक नया Custom Type Define नहीं करना चाहिए।

बल्कि जब हम कोई Class Define करते हैं, तो उस Class से सम्बंधित विभिन्न प्रकार के Issues से सम्बंधित Exceptions को Handle करने के लिए ही हमें Custom Exception Type Define करना चाहिए।

उदाहरण के लिए यदि हम कोई File Related विभिन्न प्रकार के Tasks को पूरा करने के लिए कोई Class Define करते हैं, तो उस Class द्वारा Generate होने वाले File Related विभिन्न Exceptions को Handle करने के लिए हम नया Exception Type Define कर सकते हैं।

पिछले उदाहरण में हमने हमारे Custom Message को Display करने के लिए ApplicationException Class की Message Property को निम्नानुसार Code के माध्‍यम से Override किया था:

        public override string Message {
            get {
                return string.Format("Watch Error Message: {0}", messageDetails);
            }
        }

क्योंकि यदि हम इसे Override नहीं करते, तो Throw होने वाले WatchException Type के Object में हमारा Custom Message नहीं होताए बल्कि .NET Framework द्वारा Specified Default Message ही होता।

लेकिन क्योंकि System.Exception Class में Message नाम की Property को public Define किया गया है, इसलिए इस Property को हम हमारी Derived Class के Constructor के माध्‍यम से भी Set कर सकते हैं। यानी हम हमारे पिछले Program के WatchException Class को निम्नानुसार तरीके से Modify कर सकते हैं:

// File Name: ManualExceptionObjectMessage.cs
public class WatchException : ApplicationException
{
    private string messageDetails = String.Empty;
    public DateTime ErrorTimeStamp { get; set; }
    public string CauseOfError { get; set; }

    public WatchException() { }
    public WatchException(string msg, string cause, DateTime time) : base(msg)
    {
        messageDetails = msg;
        CauseOfError = cause;
        ErrorTimeStamp = time;
    }
}

चूंकि .NET Framework एक बहुत बडा Framework है, जिसमें सैकडों Namespace में हजारों Predefined Types हैं। इसलिए कौनसा Type कौन-कौन से Exceptions Trigger कर सकता है, इस बात को याद रखना असम्भव है। लेकिन यदि हम Visual Studio Use करते हैं, तो हमें इस बात को याद रखने की जरूरत भी नहीं होती है। क्योंकि जैसे ही हम .NET Framework की किसी Method को Specify करते हैं, हमारे सामने एक Popup Display होता है, जिसमें उस Method() द्वारा Generate किए जा सकने वाले विभिन्न Exceptions की भी जानकारी होती है। जैसे:

जैसाकि इस चित्र द्वारा हम समझ सकते हैं कि जब हम Console.Read() Method Use करते हैं, तो साथ ही हमें इस बात की भी जानकारी प्राप्त हो जाती है कि ये Method System.IO.IOException Type का Exception भी Generate कर सकता है। (C# Exception Types)