जवाबों:
जावा में, आपको या तो एक अपवाद को संभालना चाहिए या उस विधि को चिह्नित करना चाहिए जो throwsकीवर्ड का उपयोग करके इसे फेंक सकती है ।
C # में यह कीवर्ड या समतुल्य एक नहीं है, जैसा कि C # में है, यदि आप एक अपवाद को हैंडल नहीं करते हैं, तो यह बबल जाएगा, जब तक पकड़ा नहीं जाता है या यदि पकड़ा नहीं जाता है तो यह प्रोग्राम को समाप्त कर देगा।
यदि आप इसे संभालना चाहते हैं तो फिर से फेंक सकते हैं, आप निम्न कार्य कर सकते हैं:
try
{
// code that throws an exception
}
catch(ArgumentNullException ex)
{
// code that handles the exception
throw;
}
ऑप्शन जावा के throwsक्लॉज के C # समतुल्य के बारे में पूछ रहा है - throwकीवर्ड नहीं । यह जावा में विधि हस्ताक्षरों में उपयोग किया जाता है ताकि यह इंगित किया जा सके कि एक अपवाद को फेंक दिया जा सकता है।
C # में, जावा जाँच अपवाद का कोई सीधा समकक्ष नहीं है। C # में कोई समान विधि हस्ताक्षर खंड नहीं है।
// Java - need to have throws clause if IOException not handled
public void readFile() throws java.io.IOException {
...not explicitly handling java.io.IOException...
}
में अनुवाद करता है
// C# - no equivalent of throws clause exceptions are unchecked
public void ReadFile()
{
...not explicitly handling System.IO.IOException...
}
हां, यह एक पुराना धागा है, हालांकि मुझे अक्सर पुराने धागे मिलते हैं जब मैं जवाब दे रहा होता हूं तो मुझे लगता है कि मुझे कुछ उपयोगी मिल जाएगा जो मैंने पाया है।
यदि आप विजुअल स्टूडियो 2012 का उपयोग कर रहे हैं तो एक बिल्ट इन टूल है जिसका उपयोग आईडीई स्तर "थ्रो" के समकक्ष करने के लिए किया जा सकता है।
यदि आप ऊपर बताए अनुसार XML डॉक्यूमेंटेशन कमेंट्स का उपयोग करते हैं , तो आप विधि या वर्ग द्वारा फेंके गए अपवाद के प्रकार के साथ-साथ यह कब या क्यों फेंका गया है, यह बताने के लिए <अपवाद> टैग का उपयोग कर सकते हैं ।
उदाहरण:
/// <summary>This method throws an exception.</summary>
/// <param name="myPath">A path to a directory that will be zipped.</param>
/// <exception cref="IOException">This exception is thrown if the archive already exists</exception>
public void FooThrowsAnException (string myPath)
{
// This will throw an IO exception
ZipFile.CreateFromDirectory(myPath);
}
throwsडेवलपर के लिए जानकारीपूर्ण होने से अलग, जेएवीए की संभावना का कोई मतलब नहीं है। इसी तरह, @mvanella ने यहां जो बताया, वह ठीक उसी तरह करने का C # तरीका है। मुझे लगता है कि आप पहले से ही जानते हैं कि इस "xml प्रलेखन" का अधिक महत्वपूर्ण उद्देश्य है। मुझे पता है कि यह धागा पुराना है।
throwsखंड में निर्दिष्ट या throwकमांड द्वारा फेंका न जाए । इसका मतलब है कि अगर एक RunTimeException होती है और इसे उसी विधि से नियंत्रित नहीं किया जाता है जहां यह होता है, तो निष्पादन वहीं रुक जाएगा।
यहाँ एक ऐसे ही प्रश्न का उत्तर दिया गया है जो मुझे अभी-अभी बाइट्स.कॉम पर मिला है :
संक्षिप्त जवाब नहीं है। C # में कोई अपवाद नहीं हैं। भाषा के डिजाइनर इस साक्षात्कार में इस निर्णय पर चर्चा करते हैं:
http://www.artima.com/intv/handcuffs.html
निकटतम आप अपने XML दस्तावेज़ों में टैग का उपयोग कर सकते हैं, और अपने कोड / असेंबली के साथ NDoc जनरेट किए गए डॉक्स वितरित कर सकते हैं ताकि अन्य लोग यह देख सकें कि आपके द्वारा फेंके गए अपवाद (MS MS प्रलेखन में वास्तव में MS क्या करते हैं)। आप संकलक पर भरोसा नहीं कर सकते हैं कि आप बिना किसी अपवाद के बता सकते हैं, हालांकि, जैसे कि आपको जावा में इस्तेमाल किया जा सकता है।
यहाँ अधिकांश उत्तरों से गुजरने के बाद, मैं कुछ विचार जोड़ना चाहूँगा।
XML दस्तावेज़ीकरण टिप्पणियों पर भरोसा करना और दूसरों पर भरोसा करने की उम्मीद करना एक खराब विकल्प है। अधिकांश C # कोड जो मैं आया हूं, XML डॉक्यूमेंटेशन टिप्पणियों के साथ पूरी तरह से और लगातार दस्तावेज़ों का दस्तावेजीकरण नहीं करता है। और फिर वहाँ बड़ा मुद्दा है कि बिना C # में जाँच किए अपवाद है, आप अपने API उपयोगकर्ता के उद्देश्य से उन सभी अपवादों को कैसे दस्तावेज़ित कर सकते हैं, यह जानने के लिए कि उन सभी को व्यक्तिगत रूप से कैसे प्रबंधित किया जाए? याद रखें, आप केवल उन लोगों के बारे में जानते हैं जिन्हें आप अपने कार्यान्वयन में फेंक कीवर्ड के साथ फेंकते हैं। आपके द्वारा अपने पद्धति कार्यान्वयन के अंदर उपयोग किए जा रहे एपीआई भी अपवादों को फेंक सकते हैं, जिनके बारे में आप नहीं जानते हैं क्योंकि वे दस्तावेज नहीं हो सकते हैं और आप उन्हें अपने कार्यान्वयन में नहीं संभाल रहे हैं, इसलिए वे आपके फोन करने वाले के चेहरे को उड़ा देंगे। तरीका। दूसरे शब्दों में,
एंड्रियास हेजेल्सबर्ग के साथ एक साक्षात्कार को यहां के जवाबों में सी # डिजाइन टीम द्वारा जाँच किए गए अपवादों के खिलाफ निर्णय लेने के कारण से जोड़ा गया। मूल प्रश्न का अंतिम उत्तर उस साक्षात्कार में छिपा है:
प्रोग्रामर अंत में हर जगह कोशिश करके अपने कोड की रक्षा करते हैं, इसलिए यदि कोई अपवाद होता है, तो वे सही ढंग से वापस करेंगे, लेकिन वे वास्तव में अपवादों को संभालने में रुचि नहीं रखते हैं।
दूसरे शब्दों में, किसी को भी इस बात में दिलचस्पी नहीं होनी चाहिए कि किसी विशेष एपीआई के लिए किस तरह के अपवाद की उम्मीद की जा सकती है क्योंकि आप हमेशा उन सभी को हर जगह पकड़ने जा रहे हैं। और यदि आप वास्तव में विशेष अपवादों के बारे में परवाह करना चाहते हैं, तो उन्हें कैसे संभालना है आप पर निर्भर है और किसी ने जावा थ्रू कीवर्ड जैसी किसी चीज़ के साथ एक विधि हस्ताक्षर को परिभाषित नहीं किया है, एक एपीआई उपयोगकर्ता पर विशेष अपवाद को संभालने के लिए मजबूर करता है।
-
व्यक्तिगत रूप से, मैं यहाँ फटा हूँ। मैं एंडर्स के साथ सहमत हूं कि नए अपवादों को अलग किए बिना समस्या की जाँच नहीं होती है। XML दस्तावेज़ टिप्पणियों के साथ की तरह, मैं शायद ही कभी C # कोड को अंत में ब्लॉक में लिपटे सब कुछ के साथ देखता हूं। यह मुझे लगता है, हालांकि यह वास्तव में आपका एकमात्र विकल्प है और कुछ ऐसा है जो एक अच्छा अभ्यास है।
वास्तव में C # में अपवादों की जाँच नहीं करना अच्छी या बुरी बात मानी जा सकती है।
मैं स्वयं इसे एक अच्छा उपाय मानता हूँ क्योंकि जाँच की गई अपवाद आपको निम्नलिखित समस्याएं प्रदान करते हैं:
क्योंकि सबसे बड़े अनुप्रयोगों में आप निम्न पैटर्न देखेंगे जब जाँच अपवाद होते हैं:
try {
// Some Code
} catch(SomeException ex){
throw new RuntimeException(ex);
}
जो अनिवार्य रूप से सी # /। नेट का अनुकरण करने का अर्थ है सभी अपवादों को संभालता है।
आप इस बारे में पूछ रहे हैं:
एक अपवाद को फिर से फेंकना
public void Method()
{
try
{
int x = 0;
int sum = 100/x;
}
catch(DivideByZeroException e)
{
throw;
}
}
या
static void Main()
{
string s = null;
if (s == null)
{
throw new ArgumentNullException();
}
Console.Write("The string s is null"); // not executed
}
throw। इसका उपयोग करके, स्टैक ट्रेस खो नहीं जाएगा।
.नेट कोडकॉन्ट्रैक्ट EnsuresOnThrow<>और जावा throwsडिस्क्रिप्टर के बीच कुछ क्षणभंगुर समानताएं हैं , जिसमें दोनों कॉलर को अपवाद के प्रकार के रूप में संकेत दे सकते हैं जो किसी फ़ंक्शन या विधि से उठाया जा सकता है, हालांकि 2 के बीच भी बड़े अंतर हैं
EnsuresOnThrow<>केवल यह बताते हुए कि अपवाद को फेंका जा सकता है, लेकिन उन शर्तों को भी निर्धारित करता है जिनके तहत उन्हें फेंके जाने की गारंटी दी जाती है - यह कॉल विधि में काफी महत्वपूर्ण कोड हो सकता है यदि अपवाद स्थिति की पहचान करने के लिए तुच्छ नहीं है। जावा throwsएक संकेत प्रदान करता है कि किन अपवादों को फेंका जा सकता है (यानी आईएमओ में फोकस .Net उस विधि के अंदर है जो साबित करने के लिए अनुबंध करता है throw, जबकि जावा में फोकस अपवाद की संभावना को स्वीकार करने के लिए कॉल करने वाले को स्थानांतरित कर देता है)।"असाधारण अपवादों का उपयोग केवल उन अपवादों के लिए करें जो एक कॉलर को एपीआई के हिस्से के रूप में उम्मीद करनी चाहिए"
throwsअपने इंटरफ़ेस पर समान अपवाद के लिए जोड़ता हो ।यदि c # विधि का उद्देश्य केवल एक अपवाद को फेंकना है (जैसे js रिटर्न प्रकार कहता है) तो मैं उस अपवाद को वापस करने की सलाह दूंगा। उदाहरण देखें bellow:
public EntityNotFoundException GetEntityNotFoundException(Type entityType, object id)
{
return new EntityNotFoundException($"The object '{entityType.Name}' with given id '{id}' not found.");
}
public TEntity GetEntity<TEntity>(string id)
{
var entity = session.Get<TEntity>(id);
if (entity == null)
throw GetEntityNotFoundException(typeof(TEntity), id);
return entity;
}
आश्चर्य करने वालों के लिए, आपको यह परिभाषित करने की आवश्यकता नहीं है कि आप इसे अगली विधि में पास करने के लिए क्या पकड़ते हैं। यदि आप चाहते हैं कि आपकी सभी त्रुटि एक मुख्य थ्रेड में हो तो आप बस सब कुछ पकड़ सकते हैं और इसे इस तरह से पास कर सकते हैं:
try {
//your code here
}
catch {
//this will throw any exceptions caught by this try/catch
throw;
}