मुझे कब डीबग.एजर्स () का उपयोग करना चाहिए?

Question

मैं अब एक साल के लिए एक पेशेवर सॉफ्टवेयर इंजीनियर रहा हूं, सीएस डिग्री के साथ स्नातक की उपाधि प्राप्त की है। मैंने C ++ और C में कुछ समय के लिए अभिकथन के बारे में जाना है, लेकिन हाल ही में जब तक वे C # और .NET में मौजूद थे, तब तक उनका कोई पता नहीं था।

हमारे उत्पादन कोड में जो भी शामिल है और मेरा प्रश्न यह है ...

क्या मुझे अपने उत्पादन कोड में एसेर्ट्स का उपयोग शुरू करना चाहिए? और यदि हां, तो इसका उपयोग सबसे उपयुक्त कब है? यह करने के लिए और अधिक समझ में आता है

Debug.Assert(val != null);

या

if ( val == null )
    throw new exception();

Comments

आपके द्वारा स्थापित डाइकोटॉमी सुराग है। यह या तो अपवाद का सवाल नहीं है, और इसके दोनों के लिए और रक्षात्मक कोड के लिए। कब क्या करना है जो आप समझ रहे हैं।

— कैस्पर लियोन नीलसन

मैंने एक बार किसी को पढ़ा कि दुर्घटना का एक अपवाद या अन्य विधि उन स्थितियों के लिए उपयुक्त है, जहां "ऐसा कोई रास्ता नहीं है जिससे मैं समझदारी से इससे उबर सकूं", और इसके अतिरिक्त एक जोरदार स्थिति उन स्थितियों के लिए उपयुक्त है जहां "यह कभी नहीं होना चाहिए, कभी भी।" लेकिन क्या यथार्थवादी परिस्थितियां पूर्व की संतुष्टि के बिना बाद की स्थितियों को संतुष्ट करती हैं? पायथन बैकग्राउंड से आने से जहां उत्पादन में बढ़त बनी हुई है, मैं उत्पादन में आपकी कुछ मान्यता को बंद करने के जावा / सी # दृष्टिकोण को कभी नहीं समझ पाया हूं। इसका एकमात्र मामला मैं वास्तव में देख सकता हूं कि क्या मान्यता महंगी है।

— मार्क ऐमी जूल 9'13

संबंधित: उत्पादन कोड में अभिकथन कब होना चाहिए?

— डेविड आरआर

निजी तौर पर मैं निजी तरीकों के लिए सार्वजनिक तरीकों और अभिकथन के अपवादों का उपयोग करता हूं।

— फ्रेड

Answer 1

में डिबगिंग Microsoft .NET 2.0 आवेदन जॉन रॉबिंस दावे पर एक बड़ा भाग है। उनके मुख्य बिंदु हैं:

1. उदारता से जोर देते हैं। आपके पास बहुत अधिक दावे नहीं हो सकते।
2. निबंध अपवादों को प्रतिस्थापित नहीं करते हैं। अपवाद उन चीज़ों को कवर करते हैं जो आपके कोड की मांग हैं; मुखरता उन चीजों को कवर करती है जो इसे मानती है।
3. एक अच्छी तरह से लिखा जोर आपको बता सकता है कि क्या नहीं हुआ और कहां (अपवाद की तरह), लेकिन क्यों।
4. एक अपवाद संदेश अक्सर गुप्त हो सकता है, आपको कोड के माध्यम से उस संदर्भ को फिर से बनाने के लिए काम करने की आवश्यकता होती है जो त्रुटि का कारण बनता है। उस समय त्रुटि होने पर एक कार्यक्रम की स्थिति को संरक्षित कर सकता है।
5. प्रलेखन के रूप में दोहराव अन्य डेवलपर्स को बताता है कि आपके कोड पर क्या अनुमान लगाया गया है।
6. जब मुखरता प्रकट होती है तो संवाद आपको डिबगर प्रक्रिया में संलग्न करने देता है, इसलिए आप स्टैक के चारों ओर प्रहार कर सकते हैं जैसे कि आपने वहां एक ब्रेकपॉइंट लगाया हो।

पुनश्च: यदि आपको कोड कम्प्लीट पसंद आया, तो मैं इस पुस्तक के साथ इसका अनुसरण करने की सलाह देता हूं। मैंने इसे WinDBG और डंप फ़ाइलों का उपयोग करने के बारे में जानने के लिए खरीदा था, लेकिन पहली छमाही में कीड़े से बचने में मदद करने के लिए युक्तियों के साथ पैक किया गया है।

Comments

संक्षिप्त और सहायक सारांश के लिए +1। बहुत सीधे तौर पर लागू। मुख्य बात यह है कि मेरे लिए गायब है, हालांकि, जब ट्रेस का उपयोग करना है। जब आप अपने उत्पादन कोड में उन्हें चाहते हैं / नहीं चाहते हैं, तो कुछ के बारे में।

— जॉन कूम्ब्स

JonCoombs "ट्रेस.एसर्स बनाम ट्रेस.एसर्स" एक टाइपो है?

— Thelem

@ विल शायद जॉन का मतलब Debug.Assertबनाम Trace.Assert। उत्तरार्द्ध को रिलीज बिल्ड के साथ-साथ डीबग बिल्ड में निष्पादित किया जाता है।

— डेविड आरआर

मैं डिबग को प्राथमिकता क्यों दूं।

— बजे Barış Akkurt

Answer 2

Debug.Assert()कोड में हर जगह रखो जहाँ आप चाहते हैं कि आक्रमणकारियों को सुनिश्चित करने के लिए पवित्रता की जाँच हो। जब आप एक रिलीज़ बिल्ड (यानी, कोई DEBUGकंपाइलर स्थिर) संकलित करते हैं , तो कॉल को Debug.Assert()हटा दिया जाएगा ताकि वे प्रदर्शन को प्रभावित न करें।

आपको कॉल करने से पहले भी अपवाद छोड़ देना चाहिए Debug.Assert()। मुखर केवल यह सुनिश्चित करता है कि जब आप अभी भी विकास कर रहे हैं तो सब कुछ अपेक्षित है।

Comments

क्या आप स्पष्ट कर सकते हैं कि यदि आप अभी भी इसे बुलाने से पहले कोई अपवाद छोड़ देते हैं तो इसे क्यों कहा जाता है? या मैंने आपके उत्तर को गलत समझा?

— रोमन स्टार्कोव

@romkyns आपको अभी भी उन्हें शामिल करना होगा क्योंकि यदि आप जारी मोड में अपनी परियोजना का निर्माण नहीं करते हैं, तो सभी सत्यापन / त्रुटि-जाँच समाप्त हो जाएंगे।

— ऑस्कर मेडेरोस

@ ऑस्कर मैंने सोचा कि पहली बार में ही मुखरता का उपयोग करने की पूरी बात थी ... ठीक है फिर, इसलिए आपने उनके सामने अपवाद रखा - तो फिर आखिर क्यों डाला?

— रोमन स्टार्कोव

@ सपरजोस: मुझे असहमत होना है: मैकलेओड के उत्तर में प्वाइंट # 2 बताता है कि आपको वास्तव में दावे और अपवादों की आवश्यकता है, लेकिन एक ही स्थान पर नहीं। NullRefEx को एक वेरिएबल पर फेंकना बेकार है और ठीक इसके बाद इस पर एक Assert करते हैं (Assert विधि इस मामले में कभी भी एक डायलॉगबॉक्स नहीं दिखाएगी, जो कि Assert का पूरा बिंदु है)। MacLeod का मतलब यह है कि कुछ जगहों पर आपको अपवाद की आवश्यकता होगी, दूसरों में एक एस्टर पर्याप्त होगा।

— डेविड

किसी और के जवाब के बारे में मेरी व्याख्या करने के लिए यह गन्दा हो सकता है :) वैसे भी मैं इन पर आपके साथ हूँ: आपको इन दोनों की आवश्यकता है, और आपको मुखर के पहले अपवाद नहीं रखना चाहिए । मैं "एक ही स्थान पर नहीं" के अर्थ के बारे में निश्चित नहीं हूं। फिर से, व्याख्या करने से इनकार करते हुए, मैं सिर्फ अपने विचारों / वरीयताओं को बताता हूं: कुछ ऑपरेशन शुरू होने से पहले, या ऑपरेशन के बाद की पोस्टकंडिशन की जांच करने के लिए एक या एक से अधिक जोर लगाने के लिए। मुखर के अलावा, और उनके बाद वैसे भी, अगर कुछ गलत हो जाता है और अपवादों को फेंकने की आवश्यकता है, तो जांचें।

— सुपरजोस

Answer 3

से कोड पूरा

8 रक्षात्मक प्रोग्रामिंग

Sert.२ जोर

एक ऐसा कोड है जो विकास के दौरान उपयोग किया जाता है- आमतौर पर एक रूटीन या मैक्रो- जो किसी प्रोग्राम को चलाने के साथ ही उसे चेक करने की अनुमति देता है। जब एक दावा सही है, तो इसका मतलब है कि सब कुछ उम्मीद के मुताबिक चल रहा है। जब यह गलत है, इसका मतलब है कि यह कोड में एक अप्रत्याशित त्रुटि का पता चला है। उदाहरण के लिए, यदि सिस्टम मानता है कि ग्राहक-सूचना फ़ाइल में कभी भी 50,000 से अधिक रिकॉर्ड नहीं होंगे, तो प्रोग्राम में यह दावा किया जा सकता है कि रिकॉर्ड की संख्या में कमी या 50,000 के बराबर है। जब तक अभिलेखों की संख्या 50,000 से कम या उसके बराबर है, तब तक दावा चुप रहेगा। यदि यह 50,000 से अधिक रिकॉर्ड का सामना करता है, हालांकि, यह जोर से "जोर" देगा कि कार्यक्रम में कोई त्रुटि है।

बड़े, जटिल कार्यक्रमों और उच्च विश्वसनीयता कार्यक्रमों में दावे विशेष रूप से उपयोगी होते हैं। वे प्रोग्रामर को और अधिक तेज़ी से बेमेल इंटरफ़ेस मान्यताओं को फ्लश करने में सक्षम करते हैं, त्रुटियों को जब कोड को संशोधित किया जाता है, और इसी तरह।

आम तौर पर एक तर्क में दो तर्क होते हैं: एक बूलियन अभिव्यक्ति जो उस धारणा का वर्णन करती है जो कि सच है और यदि ऐसा नहीं है तो प्रदर्शित करने के लिए एक संदेश।

(...)

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

Comments

तो, क्या होता है यदि उत्पादन में सामना की गई ग्राहक-सूचना फ़ाइल में 50,000 से अधिक रिकॉर्ड होते हैं? यदि अभिकथन को उत्पादन कोड से संकलित किया जाता है और इस स्थिति को अन्यथा संभाला नहीं जाता है, तो क्या यह परेशानी पैदा नहीं करता है?

— डेविडआरआर

@DavidRR हाँ वास्तव में। लेकिन जैसे ही उत्पादन एक समस्या का संकेत देता है और कुछ डेवलपर (जो कि इस कोड को अच्छी तरह से नहीं जानते हैं) समस्या को हल करता है, जोर से विफल हो जाएगा और डेवलपर तुरंत जान जाएगा कि सिस्टम का उपयोग नहीं किया गया है।

— मार्क

Answer 4

एफडब्ल्यूआईडब्ल्यू ... मुझे पता है कि मेरे सार्वजनिक तरीके if () { throw; }पैटर्न का उपयोग करने के लिए सुनिश्चित करते हैं कि विधि को सही तरीके से कहा जा रहा है। मेरी निजी विधियाँ उपयोग में हैंDebug.Assert() ।

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

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

Comments

यह एक अच्छे अभ्यास का बहुत स्पष्ट वर्णन है और यह पूछे गए प्रश्न का बहुत ही उचित उत्तर देता है।

— कैस्पर लियोन नीलसन

Answer 5

पर्यावरणीय मान्यताओं की जांच करने के लिए डेवलपर मान्यताओं और अपवादों की जांच करने के लिए जोर का प्रयोग करें।

Answer 6

अगर मैं तुम होते तो मैं:

Debug.Assert(val != null);
if ( val == null )
    throw new exception();

या बार-बार स्थिति की जाँच से बचने के लिए

if ( val == null )
{
    Debug.Assert(false,"breakpoint if val== null");
    throw new exception();
}

Comments

यह समस्या का समाधान कैसे हो रहा है? इससे debug.assert व्यर्थ हो जाता है।

— क्विबल्समैन

नहीं, यह नहीं है - यह अपवाद को फेंकने से पहले बिंदु पर कोड में टूट जाता है। यदि आपके पास अपने कोड में कहीं और कोशिश / पकड़ है, तो आप अपवाद को नोटिस भी नहीं कर सकते हैं!

— मार्क इंग्राम

+1 मुझे बहुत सी समस्याएं हुईं जहाँ लोग बस कुछ भी करने के बिना अपवादों को

— आज़माएँगे

मुझे लगता है कि ऐसे मामले हैं जहां आप ऐसा करना चाहते हैं, लेकिन आपको कभी भी सामान्य अपवाद नहीं पकड़ना चाहिए!

— केसबश

आपके उत्तर के लिए @MarkIngram -1, और +1 आपकी टिप्पणी को उचित ठहराते हुए। यह कुछ अजीबोगरीब परिस्थितियों के लिए एक अच्छी चाल है, लेकिन सभी सत्यापन के लिए सामान्य तौर पर ऐसा करना एक विचित्र बात लगती है।

— मार्क अमेरी जूल

Answer 7

यदि आप अपने उत्पादन कोड (यानी रिलीज़ बिल्ड) में ऐसर्ट चाहते हैं, तो आप Debug.Assert के बजाय Trace.Assert का उपयोग कर सकते हैं।

यह निश्चित रूप से आपके उत्पादन निष्पादन के लिए ओवरहेड जोड़ता है।

साथ ही यदि आपका एप्लिकेशन उपयोगकर्ता-इंटरफ़ेस मोड में चल रहा है, तो अभिकथन संवाद डिफ़ॉल्ट रूप से प्रदर्शित किया जाएगा, जो आपके उपयोगकर्ताओं के लिए थोड़ा सा विघटनकारी हो सकता है।

आप DefaultTraceListener को हटाकर इस व्यवहार को ओवरराइड कर सकते हैं: MSDN में Trace.Listeners के लिए दस्तावेज़ देखें।

संक्षेप में,

• डीबग बिल्ड में बग्स को पकड़ने में मदद करने के लिए उदारतापूर्वक डीबग.एजर्स का उपयोग करें।

• यदि आप उपयोगकर्ता-इंटरफ़ेस मोड में Trace.Assert का उपयोग करते हैं, तो आप संभवतया डिसऑर्डरर उपयोगकर्ताओं से बचने के लिए DefaultTraceListener को निकालना चाहते हैं।

• यदि आप जिस स्थिति का परीक्षण कर रहे हैं, वह ऐसा कुछ है जिसे आपका ऐप संभाल नहीं सकता है, तो आप संभवतः अपवाद को फेंकना बेहतर समझते हैं, ताकि निष्पादन जारी न रह सके। इस बात से अवगत रहें कि उपयोगकर्ता किसी दावे को अनदेखा करना चुन सकता है।

Comments

+1 डिबग के बीच महत्वपूर्ण अंतर को इंगित करने के लिए। शोधकर्ता और ट्रेस। एसेटर, क्योंकि ओपी ने विशेष रूप से उत्पादन कोड के बारे में पूछा था।

— जॉन Coombs

Answer 8

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

जब मुझे यकीन नहीं होता है तो मैं आम तौर पर अपवादों का समर्थन करता हूं।

Answer 9

संक्षेप में

Asserts गार्ड के लिए और अनुबंध की कमी से डिज़ाइन की जाँच के लिए उपयोग किया जाता है, अर्थात:

• Assertsडिबग और नॉन-प्रोडक्शन बिल्ड के लिए ही होना चाहिए। आम तौर पर रिलीज बिल्ड में कंपाइलर द्वारा जोर दिया जाता है।
• Asserts बग / अप्रत्याशित स्थितियों की जांच कर सकते हैं जो आपके सिस्टम के नियंत्रण में हैं
• Asserts उपयोगकर्ता इनपुट या व्यावसायिक नियमों के प्रथम-पंक्ति सत्यापन के लिए एक तंत्र नहीं हैं
• Assertsअनपेक्षित पर्यावरणीय परिस्थितियों (जो कोड के नियंत्रण से बाहर हैं) का पता लगाने के लिए उपयोग नहीं किया जाना चाहिए। उदाहरण के लिए मेमोरी, नेटवर्क विफलता, डेटाबेस विफलता आदि। हालांकि दुर्लभ, इन स्थितियों की उम्मीद की जा सकती है (और आपका ऐप कोड जैसे मुद्दों को ठीक नहीं कर सकता है) हार्डवेयर विफलता या संसाधन थकावट)। आमतौर पर, अपवादों को फेंक दिया जाएगा - आपका आवेदन फिर सुधारात्मक कार्रवाई कर सकता है (उदाहरण के लिए एक डेटाबेस या नेटवर्क ऑपरेशन को पुनः प्रयास करें, कैश्ड मेमोरी को मुक्त करने का प्रयास करें), या अपवाद को नियंत्रित नहीं किया जा सकता है तो इनायत से छोड़ दें।
• एक असफल अभिकथन आपके सिस्टम के लिए घातक होना चाहिए - यानी एक अपवाद के विपरीत, कोशिश न करें और न ही पकड़ें या संभालें विफल Asserts- आपका कोड अप्रत्याशित क्षेत्र में चल रहा है। स्टैक ट्रेस और क्रैश डंप का उपयोग यह निर्धारित करने के लिए किया जा सकता है कि क्या गलत हुआ।

कथनों में भारी लाभ है:

• उच्च स्तर के कोड में उपयोगकर्ता इनपुट, या अपस्ट्रीम बग्स के गुम सत्यापन को खोजने में सहायता करने के लिए।
• कोड आधार में प्रविष्टियाँ स्पष्ट रूप से कोड में की गई मान्यताओं को पाठक तक पहुँचाती हैं
• बिल्डरों में रनटाइम पर एस्टर की जाँच की जाएगी Debug।
• एक बार कोड को पूरी तरह से जांचने के बाद, कोड को पुन: निर्माण करने के बाद रिलीज को अनुमान को सत्यापित करने के ओवरहेड को हटा दिया जाएगा (लेकिन इस लाभ के साथ कि बाद में डिबग बिल्ड हमेशा चेक को वापस कर देगा, यदि आवश्यक हो)।

... ज्यादा जानकारी

Debug.Assertएक ऐसी स्थिति को व्यक्त करता है जिसे कार्यक्रम के नियंत्रण के भीतर कोड ब्लॉक के शेष द्वारा राज्य के बारे में मान लिया गया है। इसमें प्रदान किए गए मापदंडों की स्थिति, एक वर्ग उदाहरण के सदस्यों की स्थिति शामिल हो सकती है, या कि विधि कॉल से वापसी इसके अनुबंधित / डिज़ाइन की गई सीमा में है। आम तौर पर, मुखर सभी आवश्यक जानकारी (स्टैक ट्रेस, क्रैश डंप, आदि) के साथ थ्रेड / प्रक्रिया / कार्यक्रम को क्रैश कर देना चाहिए, क्योंकि वे बग या अनकही स्थिति की उपस्थिति का संकेत देते हैं जिसे डिजाइन नहीं किया गया है (यानी कोशिश या पकड़ या पकड़ नहीं) जब एक जोर खुद को बग से अधिक नुकसान पहुंचा सकता है (जैसे एयर ट्रैफिक कंट्रोलर्स वाईएसओडी नहीं चाहते हैं, जब एक विमान पनडुब्बी जाता है, तो यह एक संभावित अपवाद के साथ होता है), हालांकि यह एक डीबग करने के लिए तैनात किया जाना चाहिए। उत्पादन ...)

आपको कब उपयोग करना चाहिए Asserts? - किसी सिस्टम, या लाइब्रेरी एपीआई, या सेवा के किसी भी बिंदु पर, जहां किसी फ़ंक्शन या किसी वर्ग की स्थिति के इनपुट को मान्य माना जाता है (उदाहरण के लिए, जब सिस्टम के प्रेजेंटेशन टियर में उपयोगकर्ता इनपुट पर सत्यापन पहले ही हो चुका है। , व्यवसाय और डेटा स्तरीय कक्षाएं आमतौर पर मानती हैं कि इनपुट पर अशक्त जाँच, श्रेणी जाँच, स्ट्रिंग लंबाई जाँच आदि पहले ही हो चुकी हैं)। - सामान्य Assertजाँचों में शामिल होता है, जहाँ एक अवैध धारणा के कारण एक शून्य वस्तु का उल्लंघन होता है, एक शून्य विभाजक, संख्यात्मक या तिथि अंकगणितीय अतिप्रवाह, और सामान्य बैंड ऑफ / व्यवहार के लिए डिज़ाइन नहीं किया जाता है (उदाहरण के लिए यदि एक 32 बिट इंट का उपयोग मानव की उम्र के मॉडल के लिए किया गया था , यह विवेकपूर्ण होगा Assertकि वास्तव में उम्र 0 से 125 के बीच है या - -100 और 10 ^ 10 के मानों को डिज़ाइन नहीं किया गया है)।

.Net कोड कॉन्ट्रैक्ट्स
। नेट स्टैक में, कोड कॉन्ट्रैक्ट्स का उपयोग करने के विकल्प के रूप में, या के अलावा किया जा सकता है Debug.Assert। कोड अनुबंध राज्य की जाँच को और अधिक औपचारिक बना सकते हैं, और ~ संकलन समय पर मान्यताओं के उल्लंघन का पता लगाने में सहायता कर सकते हैं (या इसके तुरंत बाद, यदि एक आईडीई में पृष्ठभूमि की जाँच के रूप में चलाया जाता है)।

अनुबंध द्वारा डिजाइन (DBC) चेक उपलब्ध हैं:

• Contract.Requires - अनुबंधित शर्तें
• Contract.Ensures - अनुबंधित पदबंध
• Invariant - अपने जीवन काल में सभी बिंदुओं पर किसी वस्तु की स्थिति के बारे में एक धारणा व्यक्त करता है।
• Contract.Assumes - गैर-अनुबंधित सजाया तरीकों के लिए एक कॉल किया जाता है जब स्थैतिक चेकर pacifies।

Comments

दुर्भाग्यवश, कोड कॉन्ट्रैक्ट सभी हैं, लेकिन जब से एमएस ने इसे विकसित करना बंद कर दिया है, तब से यह मृत है।

— माइक लोनी

Answer 10

ज्यादातर मेरी किताब में कभी नहीं। अगर आप सब कुछ समझ गए हैं तो अगर आप ऐसा नहीं करना चाहते हैं, तो अधिकांश अवसरों पर।

मुझे जो नापसंद है, वह यह है कि यह डिबग बिल्ड को कार्यात्मक रूप से रिलीज़ बिल्ड के लिए अलग बनाता है। यदि कोई डीबग असॉउलर विफल हो जाता है, लेकिन कार्यक्षमता रिलीज़ में काम करती है, तो इसका कोई मतलब कैसे होता है? यह तब और बेहतर है जब मुखर ने कंपनी को लंबे समय तक छोड़ दिया है और कोई भी कोड के उस हिस्से को नहीं जानता है। फिर आपको अपना कुछ समय इस मुद्दे को देखने के लिए मारना होगा कि क्या यह वास्तव में एक समस्या है या नहीं। यदि यह एक समस्या है तो व्यक्ति को पहले स्थान पर क्यों नहीं रखा गया है?

मेरे लिए यह डिबग का उपयोग करके सुझाव देता है। यदि आप किसी और को समस्या का सामना कर रहे हैं, तो समस्या को स्वयं हल करें। अगर कुछ मामला माना जाता है और यह तब फेंक नहीं है।

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

Comments

आप जवाब देते हैं कि आप कुछ योग्यता के हकदार हैं, जैसा कि आप उनके बारे में अक्सर उठाई गई चिंता को उजागर करते हैं, तथ्य यह है कि वे डिबगिंग सत्र को बाधित करते हैं और झूठे सकारात्मक के लिए मौका। हालाँकि, आप कुछ सूक्ष्मताएँ याद कर रहे हैं और लिख रहे हैं "अनुकूलन दूर करें" - जो केवल इस सोच पर आधारित हो सकता है कि एक अपवाद को फेंकना और डीबग करना। यह एक ही है। ऐसा नहीं है, वे विभिन्न उद्देश्यों और विशेषताओं की सेवा करते हैं, जैसा कि आप कुछ उत्कीर्ण जवाबों में देख सकते हैं। ड्वा

— कैस्पर लियोन नीलसन

+1 के लिए "मुझे क्या नापसंद है तथ्य यह है कि यह डिबग बिल्ड को कार्यात्मक रूप से रिलीज़ बिल्ड के लिए अलग बनाता है। यदि कोई डीबग एस्पर विफल रहता है लेकिन कार्यक्षमता रिलीज़ में काम करती है तो इसका कोई मतलब नहीं है?" .NET में, System.Diagnostics.Trace.Assert()रिलीज़ बिल्ड के साथ-साथ डीबग बिल्ड में निष्पादित होता है।

— डेविड आरआर

Answer 11

IDesign Standard के अनुसार आपको चाहिए

हर धारणा पर जोर देते हैं। औसतन, हर पांचवीं पंक्ति एक जोर है।

using System.Diagnostics;

object GetObject()
{...}

object someObject = GetObject();
Debug.Assert(someObject != null);

अस्वीकरण के रूप में मुझे इस IRL को लागू करने के लिए व्यावहारिक नहीं मिला है, जिसका उल्लेख करना चाहिए। लेकिन यह उनका मानक है।

Comments

लगता है कि Juval Lowy खुद को उद्धृत करना पसंद करती है।

— devlord

Answer 12

केवल उन मामलों में ही उपयोग करें जहां आप चाहते हैं कि रिलीज बिल्ड के लिए चेक को हटा दिया जाए। याद रखें, यदि आप डिबग मोड में संकलन नहीं करते हैं तो आपके दावे में आग नहीं लगेगी।

आपके चेक-इन-नल उदाहरण को देखते हुए, यदि यह केवल आंतरिक API में है, तो मैं इसका उपयोग कर सकता हूं। यदि यह एक सार्वजनिक एपीआई में है, तो मैं निश्चित रूप से स्पष्ट जांच और फेंक का उपयोग करूंगा।

Comments

.NET में, कोई System.Diagnostics.Trace.Assert()एक रिलीज़ (उत्पादन) बिल्ड में दावे को निष्पादित करने के लिए उपयोग कर सकता है ।

— डेविड आरआर

कोड विश्लेषण नियम CA1062: सार्वजनिक विधियों के मान्य तर्कों के लिए एक तर्क की जाँच की आवश्यकता होती हैnull : "एक बाहरी रूप से दिखाई देने वाली विधि बिना किसी संदर्भ के अपने तर्कों में से एक को सत्यापित करती है कि क्या यह तर्क शून्य है ।" ऐसी स्थिति में, विधि या संपत्ति को फेंक देना चाहिए ArgumentNullException।

— डेविड आरआर

Answer 13

सभी एसेर्ट्स को ऐसा कोड होना चाहिए जिसे निम्नलिखित के लिए अनुकूलित किया जा सके:

Debug.Assert(true);

क्योंकि यह कुछ ऐसा जाँच रहा है जिसे आपने पहले ही मान लिया है। उदाहरण के लिए:

public static void ConsumeEnumeration<T>(this IEnumerable<T> source)
{
  if(source != null)
    using(var en = source.GetEnumerator())
      RunThroughEnumerator(en);
}
public static T GetFirstAndConsume<T>(this IEnumerable<T> source)
{
  if(source == null)
    throw new ArgumentNullException("source");
  using(var en = source.GetEnumerator())
  {
    if(!en.MoveNext())
      throw new InvalidOperationException("Empty sequence");
    T ret = en.Current;
    RunThroughEnumerator(en);
    return ret;
  }
}
private static void RunThroughEnumerator<T>(IEnumerator<T> en)
{
  Debug.Assert(en != null);
  while(en.MoveNext());
}

उपरोक्त में, अशक्त मापदंडों के लिए तीन अलग-अलग दृष्टिकोण हैं। पहला इसे स्वीकार्य के रूप में स्वीकार करता है (यह सिर्फ कुछ नहीं करता है)। दूसरा कॉलिंग कोड को संभालने के लिए एक अपवाद फेंकता है (या नहीं, जिसके परिणामस्वरूप त्रुटि संदेश होता है)। तीसरा मानता है कि यह संभवतः नहीं हो सकता है, और दावा करता है कि ऐसा है।

पहले मामले में, कोई समस्या नहीं है।

दूसरे मामले में, कॉलिंग कोड के साथ एक समस्या है - इसे GetFirstAndConsumeअशक्त के साथ नहीं बुलाया जाना चाहिए , इसलिए इसे एक अपवाद वापस मिलता है।

तीसरे मामले में, इस कोड के साथ एक समस्या है, क्योंकि यह पहले से ही जांचा जाना चाहिए en != nullथा कि इससे पहले कि यह कभी भी बुलाया गया था, ताकि यह सच न हो एक बग है। या दूसरे शब्दों में, यह कोड होना चाहिए जो सैद्धांतिक रूप से अनुकूलित किया जा सकता है Debug.Assert(true), सिस्केन en != nullहमेशा होना चाहिए true!

Comments

तो, तीसरे मामले में, en == nullउत्पादन में क्या होता है ? आप संभवतः कह रहे हैं कि en == nullकर सकते हैं कभी नहीं हुआ उत्पादन में (के बाद से कार्यक्रम को अच्छी तरह से डिबग किया गया)? यदि ऐसा है, तो Debug.Assert(en != null)कम से कम एक टिप्पणी के विकल्प के रूप में कार्य करता है। बेशक, अगर भविष्य में बदलाव किए जाते हैं, तो यह संभव प्रतिगमन का पता लगाने के लिए मूल्य भी रखता है।

— डेविड आरआर

@DavidRR, मैं वास्तव में यह दावा कर रहा हूं कि यह कभी भी अशक्त नहीं हो सकता है, और इसलिए कोड में जोर है, इसलिए नाम। मैं निश्चित रूप से गलत हो सकता हूं, या एक बदलाव से गलत हो सकता है, और यह कि मुखर कॉल का मूल्य है।

— जॉन हैना

Debug.Assert()रिलीज बिल्ड में कॉल को हटा दिया जाता है। इसलिए, यदि आप कर रहे हैं गलत, तीसरे मामले में , आप इसे उत्पादन में पता नहीं होगा (उत्पादन में एक रिलीज निर्माण का उपयोग कल्पना करते हुए)। हालाँकि, पहले और दूसरे मामलों का व्यवहार डिबग और रिलीज़ बिल्ड में समान है।

— डेविड्रर

@DavidRR, जो इसे तभी उचित बनाता है जब मैं धारण करता हूं कि ऐसा नहीं हो सकता है, क्योंकि यह फिर से तथ्य की परख है, राज्य की जाँच नहीं। बेशक यह भी व्यर्थ है अगर जोर है, तो एक बग है जो इसे पकड़ लेगा, और फिर भी परीक्षण में उस मामले को कभी नहीं मारा।

— जॉन हैना

Answer 14

मुझे लगा कि मैं चार और मामले जोड़ूंगा, जहां डेब्यू।आसर सही विकल्प हो सकता है।

1) कुछ ऐसा है जो मैंने यहां नहीं देखा है, अतिरिक्त वैचारिक कवरेज है जो स्वचालित परीक्षण के दौरान Asserts प्रदान कर सकता है । एक साधारण उदाहरण के रूप में:

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

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

इस बिंदु पर, यूनिट परीक्षणों द्वारा संचालित नए मामले (या किनारे मामले) के साथ युग्मित कैली में शामिल डीबग.एसर्स () स्टेटमेंट्स परीक्षण के दौरान अमूल्य अधिसूचना प्रदान कर सकते हैं कि मूल लेखक की मान्यताओं को अमान्य कर दिया गया है, और कोड नहीं होना चाहिए अतिरिक्त समीक्षा के बिना जारी किया जाए। यूनिट टेस्ट के साथ सही पार्टनर हैं।

2) इसके अतिरिक्त, कुछ परीक्षण लिखने में सरल होते हैं, लेकिन उच्च-लागत और अनावश्यक को शुरुआती मान्यताओं को देखते हुए । उदाहरण के लिए:

यदि किसी ऑब्जेक्ट को केवल एक निश्चित सुरक्षित एंट्री पॉइंट से एक्सेस किया जा सकता है, तो क्या कॉलर के पास अनुमतियाँ हैं यह सुनिश्चित करने के लिए हर ऑब्जेक्ट विधि से नेटवर्क राइट्स डेटाबेस में एक अतिरिक्त क्वेरी की जानी चाहिए? पक्का नहीं। शायद आदर्श समाधान में कैशिंग या सुविधाओं के कुछ अन्य विस्तार शामिल हैं, लेकिन डिजाइन को इसकी आवश्यकता नहीं है। एक डीबग.एजर्स () तुरंत दिखाएगा जब ऑब्जेक्ट को असुरक्षित प्रविष्टि बिंदु से जोड़ा गया है।

3) अगला, कुछ मामलों में आपके उत्पाद में रिलीज़ मोड में तैनात होने पर इसके सभी या इसके संचालन के लिए कोई उपयोगी नैदानिक ​​बातचीत नहीं हो सकती है । उदाहरण के लिए:

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

4) अंत में, कुछ परीक्षण केवल इसलिए अप्रमाणिक हैं क्योंकि कैली को अत्यंत विश्वसनीय माना जाता है । ज्यादातर मामलों में, जितना अधिक पुन: प्रयोज्य कोड होता है, उतना ही अधिक प्रयास इसे विश्वसनीय बनाने में किया जाता है। इसलिए कॉल करने वालों से अनपेक्षित मापदंडों के लिए अपवाद होना आम है, लेकिन कैलेज़ से अनपेक्षित परिणामों के लिए जोर देना। उदाहरण के लिए:

यदि कोई कोर String.Findऑपरेशन बताता है -1कि खोज मानदंड नहीं मिलने पर यह वापस आ जाएगा , तो आप सुरक्षित रूप से तीन के बजाय एक ऑपरेशन करने में सक्षम हो सकते हैं। हालांकि, अगर यह वास्तव में वापस आ गया है -2, तो आपके पास कार्रवाई का कोई उचित कोर्स नहीं हो सकता है। सरल गणना को एक के साथ प्रतिस्थापित करना अनपेक्षित होगा जो एक -1मान के लिए अलग से परीक्षण करता है , और कोर लाइब्रेरी को सुनिश्चित करने वाले परीक्षणों के साथ अपने कोड को लिटाने के लिए अधिकांश रिलीज के वातावरण में अनुचित है। इस मामले में Asserts आदर्श हैं।

Answer 15

द प्रोगामैटिक प्रोग्रामर से लिया गया उद्धरण : जर्नीमैन से मास्टर तक

छोड़ी गई बातों को छोड़ दें

संकलनों और भाषा के वातावरण को लिखने वाले लोगों द्वारा कथनों के बारे में एक आम गलतफहमी है। यह कुछ इस तरह चलता है:

कोड में कुछ ओवरहेड जोड़ते हैं। क्योंकि वे उन चीजों की जांच करते हैं जो कभी नहीं होनी चाहिए, वे कोड में केवल बग द्वारा ट्रिगर हो जाएंगे। एक बार जब कोड का परीक्षण और भेज दिया गया है, तो उन्हें अब आवश्यकता नहीं है, और कोड को तेजी से चलाने के लिए बंद कर दिया जाना चाहिए। दावे एक डिबगिंग सुविधा है।

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

दूसरा, आशावादी यह भूल रहे हैं कि आपका कार्यक्रम एक खतरनाक दुनिया में चलता है। परीक्षण के दौरान, चूहों को शायद संचार केबल के माध्यम से नहीं सूंघा जाएगा, कोई गेम खेलने वाला व्यक्ति मेमोरी को समाप्त नहीं करेगा, और लॉग फाइलें हार्ड ड्राइव को नहीं भरेगी। ये चीजें तब हो सकती हैं जब आपका प्रोग्राम उत्पादन के माहौल में चलता है। रक्षा की आपकी पहली पंक्ति किसी भी संभावित त्रुटि के लिए जाँच कर रही है, और आपका दूसरा उन गलतियों का पता लगाने की कोशिश कर रहा है जिन्हें आपने याद किया है।

जब आप उत्पादन के लिए एक कार्यक्रम वितरित करते हैं, तो बिना किसी नेट के एक उच्च तार को पार करने के समान है क्योंकि आपने एक बार इसे व्यवहार में लाया था । नाटकीय मूल्य है, लेकिन जीवन बीमा प्राप्त करना कठिन है।

यहां तक ​​कि अगर आपके पास प्रदर्शन के मुद्दे हैं, तो केवल उन दावों को बंद करें जो वास्तव में आपको मारते हैं ।

Answer 16

आपको हमेशा दूसरे दृष्टिकोण (अपवादों को फेंकना) का उपयोग करना चाहिए।

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

Comments

नहीं, यहाँ कुछ अन्य उत्तरों के समान है: आप वास्तव में इस अंतर को नहीं समझते हैं, इसलिए आप इस प्रक्रिया में उन दोनों के बीच एक गलत द्वंद्वात्मकता स्थापित करते हुए, किसी एक प्रसाद को चुनते हैं। ड्वा

— कैस्पर लियोन नीलसन

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

— justin.m.chase 16

यह आपकी चर्चा में ट्रेस को शामिल करने के लिए सहायक हो सकता है। क्योंकि इसे एक ही तर्क से खारिज नहीं किया जा सकता है।

— जॉन Coombs

Answer 17

आपको अपने कार्यक्रमों में तार्किक त्रुटियों के परीक्षण के लिए Debug.Assert का उपयोग करना चाहिए। केवल आप वाक्यविन्यास त्रुटियों के बारे में सूचित कर सकते हैं। इसलिए आपको तार्किक त्रुटियों का परीक्षण करने के लिए निश्चित रूप से मुखर बयानों का उपयोग करना चाहिए। जैसे कहना है कि कारों को बेचने वाले प्रोग्राम का परीक्षण करना चाहिए जो केवल बीएमडब्ल्यू जो नीले हैं, उन्हें 15% की छूट मिलनी चाहिए। यदि आप अपने कार्यक्रम को इस प्रदर्शन में तार्किक रूप से सही हैं, लेकिन एक जोरदार बयान सकता है के बारे में आप कुछ नहीं बता सकते।

Comments

क्षमा करें, लेकिन अपवाद सभी समान काम करते हैं, इसलिए यह उत्तर वास्तविक प्रश्न को संबोधित नहीं करता है।

— रोमन स्टार्कोव

Answer 18

मैंने यहाँ उत्तर पढ़े हैं और मुझे लगा कि मुझे एक महत्वपूर्ण अंतर जोड़ना चाहिए। दो अलग-अलग तरीके हैं जिनमें मुखर का उपयोग किया जाता है। एक "के लिए एक अस्थायी डेवलपर शॉर्टकट के रूप में है" यह वास्तव में ऐसा नहीं होना चाहिए अगर यह मुझे पता है तो मैं यह तय कर सकता हूं कि मैं क्या करूं ", सशर्त ब्रेकपॉइंट की तरह, उन मामलों में जिनके लिए आपका कार्यक्रम जारी रखने में सक्षम है। अन्य, अपने कोड में मान्य प्रोग्राम स्टेट्स के बारे में धारणाएं रखने का एक तरीका है।

पहले मामले में, दावे को अंतिम कोड में होने की भी आवश्यकता नहीं है। आपको Debug.Assertविकास के दौरान उपयोग करना चाहिए और यदि आवश्यक नहीं है, तो आप उन्हें हटा सकते हैं। यदि आप उन्हें छोड़ना चाहते हैं या यदि आप उन्हें कोई समस्या नहीं निकालना चाहते हैं, क्योंकि उनके पास रिलीज़ संकलन में कोई परिणाम नहीं होगा।

लेकिन दूसरे मामले में, दावे कोड का हिस्सा हैं। वे, ठीक है, जोर देते हैं, कि आपकी धारणाएँ सच हैं, और उन्हें दस्तावेज भी। उस स्थिति में, आप वास्तव में उन्हें कोड में छोड़ना चाहते हैं। यदि कार्यक्रम अमान्य स्थिति में है, तो इसे जारी रखने की अनुमति नहीं दी जानी चाहिए। यदि आप प्रदर्शन हिट नहीं कर सकते हैं तो आप C # का उपयोग नहीं करेंगे। यदि ऐसा होता है तो एक तरफ डिबगर संलग्न करने में सक्षम होना उपयोगी हो सकता है। दूसरे पर, आप स्टैक ट्रेस को अपने उपयोगकर्ताओं पर पॉपिंग नहीं करना चाहते हैं और शायद अधिक महत्वपूर्ण आप नहीं चाहते कि वे इसे अनदेखा कर सकें। इसके अलावा, अगर यह एक सेवा में है तो इसे हमेशा नजरअंदाज कर दिया जाएगा। इसलिए उत्पादन में सही व्यवहार एक अपवाद को फेंकना होगा, और अपने कार्यक्रम के सामान्य अपवाद हैंडलिंग का उपयोग करना होगा, जो उपयोगकर्ता को एक अच्छा संदेश दिखा सकता है और विवरण लॉग कर सकता है।

Trace.Assertइसे प्राप्त करने का सही तरीका है। इसे उत्पादन में नहीं हटाया जाएगा, और app.config का उपयोग करके विभिन्न श्रोताओं के साथ कॉन्फ़िगर किया जा सकता है। इसलिए विकास के लिए डिफ़ॉल्ट हैंडलर ठीक है, और उत्पादन के लिए आप एक सरल ट्रेसीलिंटर बना सकते हैं जैसे नीचे एक अपवाद फेंकता है और इसे उत्पादन विन्यास फाइल में सक्रिय करता है।

using System.Diagnostics;

public class ExceptionTraceListener : DefaultTraceListener
{
    [DebuggerStepThrough]
    public override void Fail(string message, string detailMessage)
    {
        throw new AssertException(message);
    }
}

public class AssertException : Exception
{
    public AssertException(string message) : base(message) { }
}

और उत्पादन विन्यास फाइल में:

<system.diagnostics>
  <trace>
    <listeners>
      <remove name="Default"/>
      <add name="ExceptionListener" type="Namespace.ExceptionTraceListener,AssemblyName"/>
    </listeners>
  </trace>
 </system.diagnostics>

Answer 19

मुझे नहीं पता कि यह C # और .NET में कैसे है, लेकिन C में मुखर () केवल तभी काम करेगा जब -DDEBUG के साथ संकलित किया जाए - एंड्यूसर कभी भी एक मुखर () नहीं देखेगा यदि यह बिना संकलित किया गया है। यह केवल डेवलपर के लिए है। मैं इसे वास्तव में अक्सर उपयोग करता हूं, कभी-कभी बग को ट्रैक करना आसान होता है।

Answer 20

मैं उनका उपयोग उत्पादन कोड में नहीं करूंगा। अपवाद फेंकें, पकड़ें और लॉग करें।

इसके अलावा asp.net में सावधानी बरतने की जरूरत है, क्योंकि एक दिलासा कंसोल पर दिखाई दे सकता है और अनुरोध को फ्रीज कर सकता है।