DivideByZeroException बहुत धीमी गति से

Question

यह बेहद धीमी गति से है:

if (y > 0) x = k/y; 

किसी को भी मुझे बता सकते हैं क्यों:

try 
{ 
    x = k/y; 
} 
catch (DivideByZeroException) { } 

इस बारे में 5x तेज है?

Answer 1

केवल 5 गुना तेजी से? तुम मुझे आश्चर्यचकित करते हो संभवतः इसका मतलब है कि आपके नमूना डेटा में इसमें कई शून्य नहीं हैं।

अपवाद सरल तुलना से अधिक महंगा हैं। जब सही तरीके से उपयोग किया जाता है (यानी असाधारण परिस्थितियों के लिए) वे प्रदर्शन को बाधित नहीं करते हैं - क्योंकि यदि आप बड़े प्रभाव के लिए पर्याप्त अपवाद फेंक रहे हैं, तो संभावना है कि आपकी सेवा पहले से ही हो चुकी है। यह समस्या का कारण बनता है जब आप उन स्थितियों को अनदेखा करने का प्रयास करने के लिए अपवादों का उपयोग करते हैं जिन्हें आप आसानी से शुरू करने के लिए परीक्षण कर सकते हैं - इस तरह।

अपवादों की लागत के बारे में ध्यान देने योग्य एक बात: डीबगर के बिना चलने के दौरान डीबगर में उन्हें बहुत अधिक लागत होती है; विशेष रूप से संसाधनों का एक गुच्छा लोड करने के लिए पहले अपवाद को माइक्रो/मिलीसेकंड के बजाय सेकंड ले सकते हैं। यदि आप बेंचमार्क कोड पर जा रहे हैं, तो यह महत्वपूर्ण है कि आप इसे डीबगर में न करें - यह सामान्य रूप से सच है, लेकिन विशेष रूप से अपवादों के लिए।

Answer 2

क्योंकि अपवाद महंगे हैं।

जब कोई अपवाद फेंक दिया जाता है, तो रनटाइम को बहुत सारी जानकारी (उदाहरण के लिए स्टैक निशान) चुनने और उन्हें बबल करने की आवश्यकता होती है। इसमें समय और संसाधन लगते हैं, जब तुलना में 0 मान का परीक्षण बहुत सस्ता है।

this SO question देखें कि अधिक जानकारी के लिए कितने महंगे अपवाद हैं।

Answer 3

एर, क्योंकि अपवाद जांचने से धीमे हैं। अपवादों में आमतौर पर उनके चारों ओर बहुत सारे बुनियादी ढांचे होते हैं जो एक साधारण if कथन नहीं है।

वे समकक्ष संचालन नहीं हैं क्योंकि आपके पास अपवाद में बहुत सारी जानकारी दी गई है, भले ही आप इस मामले में का उपयोग न करना चुनते हैं।

Answer 4

अपवाद धीमे क्यों हैं?

क्योंकि जब कोई अपवाद फेंक दिया जाता है और पकड़ा जाता है तो बहुत सी चीजें होती हैं। विवरण के लिए Chris Brumme's post about the managed exception model और this post about the underlying Win32 SEH model देखें।

एक सरल परीक्षण तेजी से क्यों है?

क्योंकि यह दो पूर्णांक की तुलना के परिणाम के आधार पर कूदने के लिए केवल एक निर्देश निष्पादित करता है जो अपवाद से बहुत कम काम करता है।

क्या इसका मतलब है कि मुझे हमेशा अपवादों से बचने की कोशिश करनी चाहिए?

नहीं, यह अर्थशास्त्र पर निर्भर करता है। यदि शून्य से विभाजित करना वास्तव में एक अपवाद मामला है जिसे आप होने की उम्मीद नहीं करते हैं, और आपका प्रोग्राम उचित रूप से संभाल नहीं सकता है, तो अपवाद होने और अपने प्रोग्राम को क्रैश करने दें।यदि, हालांकि, यह एक अपेक्षित मामला है और आप इसे उचित तरीके से संभाल सकते हैं तो अपवाद से बचने के लिए उचित लगेगा।

Answer 5

इस लेख पर एक नज़र डालें:

• The True Cost of .NET Exceptions -- Solution
• Exceptions and Performance in .NET

Answer 6

अपवाद हैं बेहद धीमी गति से - यही कारण है कि नेट ढांचे TryParse तरीकों है:

// This is much quicker... 
double result; 
if (!double.TryParse("Twelve", out result)) 
{ 
    result = -1; 
} 
return result; 

// Than this... 
try 
{ 
    return double.Parse("Twelve"); 
} 
catch 
{ 
    return -1; 
} 

आपको हमेशा अपवादों से बचने और उनसे बचने चाहिए (असाधारण परिस्थितियों में छोड़कर - हाहा ...)