C# अकादमी · पाठ

try/catch/finally, throw new बनाम rethrow

पूर्वानुमेय error handling के लिए try/catch/finally का उपयोग करें; throw new और rethrow का अंतर समझें; उदाहरणों को छोटा और केंद्रित रखें।

पाठ 1, कुल 3 में से8 चरण

try/catch/finally, throw new बनाम rethrow, CoddyKit पर C# अकादमी का एक निःशुल्क पाठ है। यह 3 में से 1वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह C# अकादमी सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। C# अकादमी पाठ्यक्रम में कुल 3 पाठ शामिल हैं।

अपवादों का परिचय

लक्ष्य: त्रुटियों को सुरक्षित रूप से संभालना और आगे भेजना।

  • try/catch: विशिष्ट अपवादों को संभालें
  • finally: सफ़ाई के लिए हमेशा चलता है
  • नया throw बनाम पुनः-फेंकना
  • हैंडलर छोटे रखें; बग छिपाएँ नहीं

विशिष्ट catch

जिस सबसे विशिष्ट अपवाद की आप अपेक्षा करते हैं, उसे पकड़ें; हैंडलर को छोटा और स्पष्ट रखें।

using System;

public class Program
{
  public static void Main(string[] args)
  {
    Console.WriteLine("Start");
    try
    {
      int x = 10;
      int y = 0; // will cause DivideByZeroException
      Console.WriteLine(x / y);
    }
    catch (DivideByZeroException ex)
    {
      Console.WriteLine("Cannot divide by zero: " + ex.GetType().Name);
    }
    Console.WriteLine("Continue");
  }
}

catch का क्रम

क्रम महत्वपूर्ण है: पहले विशिष्ट catch रखें और सुरक्षा-जाल के रूप में सामान्य Exception catch को अंत में रखें।

using System;

public class Program
{
  static int ParseAndDivide(string text, int divisor)
  {
    // Throws FormatException or DivideByZeroException
    int value = int.Parse(text);
    return value / divisor;
  }

  public static void Main(string[] args)
  {
    try
    {
      Console.WriteLine(ParseAndDivide("not-a-number", 2));
    }
    catch (FormatException)
    {
      Console.WriteLine("Bad number format");
    }
    catch (Exception ex)
    {
      // Fallback last
      Console.WriteLine("Other error: " + ex.GetType().Name);
    }
  }
}

सफ़ाई के लिए finally

सफ़ाई का काम finally में रखें। यह अपवाद आने या न आने, दोनों स्थितियों में चलता है।

using System;

public class Program
{
  static bool opened = false;

  static void UseFakeResource()
  {
    try
    {
      opened = true;
      Console.WriteLine("Open");
      throw new InvalidOperationException("boom");
    }
    catch (InvalidOperationException)
    {
      Console.WriteLine("Handled");
    }
    finally
    {
      opened = false; // cleanup path
      Console.WriteLine("Close");
    }
  }

  public static void Main(string[] args)
  {
    UseFakeResource();
    Console.WriteLine("Opened? " + opened);
  }
}

सही तरीके से पुनः-फेंकना

पुनः-फेंकने और मूल स्टैक बनाए रखने के लिए throw; इस्तेमाल करें। throw ex; उसे रीसेट कर देता है। नया संदर्भ जोड़ने पर ही नए अपवाद में लपेटें।

using System;

public class Program
{
  static void BadRethrow()
  {
    try
    {
      Fail();
    }
    catch (Exception ex)
    {
      // Resets stack trace:
      throw ex; // BAD rethrow
    }
  }

  static void GoodRethrow()
  {
    try
    {
      Fail();
    }
    catch
    {
      // Preserves original stack trace:
      throw; // GOOD rethrow
    }
  }

  static void Fail()
  {
    throw new InvalidOperationException("fail");
  }

  public static void Main(string[] args)
  {
    try { BadRethrow(); }
    catch (Exception ex)
    {
      Console.WriteLine("Bad: " + (ex.StackTrace == null ? "no stack" : "stack reset likely"));
    }

    try { GoodRethrow(); }
    catch (Exception ex)
    {
      Console.WriteLine("Good: preserves original stack");
    }
  }
}

हैंडलिंग के दिशानिर्देश

दिशानिर्देश:

  • तभी पकड़ें जब आप उसे संभाल सकते हों या संदर्भ जोड़ सकते हों।
  • अन्यथा, उसे ऊपर जाने दें।
  • हैंडलर छोटे रखें; अपवादों को चुपचाप निगलने से बचें।
  • सफ़ाई के लिए finally इस्तेमाल करें; संसाधन-मुक्ति अगला पाठ है।

पुनः-फेंकने का नियम

त्वरित जाँच: मूल स्टैक ट्रेस को बनाए रखते हुए वर्तमान अपवाद को सही तरीके से कौन-सा कथन पुनः-फेंकता है?

पुनरावृत्ति

पुनरावृत्ति: विशिष्ट त्रुटियों के लिए try/catch, सफ़ाई के लिए finally इस्तेमाल करें और पुनः-फेंकते समय मूल स्टैक बनाए रखने के लिए throw; को प्राथमिकता दें।

शुरुआत निःशुल्क

एआई शिक्षक के साथ C# सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम
93
पाठ
346

अक्सर पूछे जाने वाले प्रश्न

क्या “try/catch/finally, throw new बनाम rethrow” पाठ निःशुल्क है?

हाँ—“try/catch/finally, throw new बनाम rethrow” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और C# अकादमी पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। C# अकादमी पाठ्यक्रम में कुल 3 पाठ शामिल हैं।

“try/catch/finally, throw new बनाम rethrow” में मैं क्या सीखूँगा?

पूर्वानुमेय error handling के लिए try/catch/finally का उपयोग करें; throw new और rethrow का अंतर समझें; उदाहरणों को छोटा और केंद्रित रखें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ C# अकादमी का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या C# अकादमी शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर C# अकादमी शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 3 में से 1वाँ पाठ है।

“try/catch/finally, throw new बनाम rethrow” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस C# अकादमी पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर C# अकादमी पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

  1. try/catch/finally, throw new बनाम rethrow
  2. Custom exceptions; error design
  3. IDisposable, using कथन
← C# अकादमी पर वापस जाएँ