डिबग.एसर्स बनाम एक्सेप्शन थ्रोइंग

Question

मैंने बहुत सारे लेख पढ़े हैं (और इसी तरह के कुछ अन्य प्रश्न जो स्टैकऑवरफ़्लो पर पोस्ट किए गए थे) कैसे और कब उपयोग करना है, इसके बारे में और मैंने उन्हें अच्छी तरह समझा। लेकिन फिर भी, मुझे समझ में नहीं आता है कि Debug.Assertएक सादे अपवाद को फेंकने के बजाय मुझे किस तरह की प्रेरणा का उपयोग करना चाहिए । मेरा क्या मतलब है। .NET में एक असफल दावे के लिए डिफ़ॉल्ट प्रतिक्रिया "दुनिया को रोकना" है और उपयोगकर्ता को एक संदेश बॉक्स प्रदर्शित करना है। हालांकि इस तरह के व्यवहार को संशोधित किया जा सकता है, मुझे ऐसा करने के लिए बहुत कष्टप्रद और बेमानी लगता है, जबकि मैं इसके बजाय, बस एक उपयुक्त अपवाद फेंक सकता हूं। इस तरह, मैं अपवाद को फेंकने से ठीक पहले एप्लिकेशन के लॉग में आसानी से त्रुटि लिख सकता था, और इसके अलावा, मेरा आवेदन जरूरी नहीं कि फ्रीज हो।

तो, मुझे क्यों, यदि बिल्कुल, Debug.Assertसादे अपवाद के बजाय उपयोग करना चाहिए ? एक मुखरता की जगह जहां यह सिर्फ "अवांछित व्यवहार" के सभी प्रकार का कारण नहीं हो सकता है, इसलिए मेरे दृष्टिकोण में, मैं वास्तव में अपवाद को फेंकने के बजाय जोर का उपयोग करके कुछ भी हासिल नहीं करता हूं। क्या आप मुझसे सहमत हैं, या मैं यहाँ कुछ याद कर रहा हूँ?

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

---

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

Comments

उन चीजों के लिए जो आप कह रहे हैं "अगर एक उत्पादन रिलीज पर एक बग की खोज की जाती है, तो मैं अभी भी चाहूंगा कि" जोर "विफल हो जाएगा" के बारे में, अपवाद हैं कि आपको क्या उपयोग करना चाहिए

— टॉम नेयलैंड

प्रदर्शन ही एकमात्र कारण है। हर समय सभी चीजों की जाँच करना, गति को कम कर सकता है, हालांकि यह पूरी तरह से ध्यान देने योग्य नहीं हो सकता है। यह मुख्य रूप से ऐसे मामलों के लिए है, जो कभी नहीं होने चाहिए, जैसे कि आप जानते हैं कि आपने इसे पहले से ही पहले ही चेक कर दिया है, फिर से इसे चेक करने का कोई मतलब नहीं है। Debug.assert आपको सूचित करने के लिए अंतिम मौका इकाई परीक्षण की तरह प्रभावी रूप से कार्य करता है।

— रोल

Answer 1

यद्यपि मैं मानता हूं कि आपका तर्क प्रशंसनीय है - अर्थात, यदि किसी दावे का अप्रत्याशित रूप से उल्लंघन किया जाता है, तो यह फेंकने से रोकना समझ में आता है - मैं व्यक्तिगत रूप से मुखरता के स्थान पर अपवादों का उपयोग नहीं करूंगा। यहाँ पर क्यों:

जैसा कि दूसरों ने कहा है, अभिकथन को दस्तावेज होना चाहिए ऐसी स्थितियों का जो असंभव हैं , ऐसे में यदि कथित रूप से असंभव स्थिति गुजरती है, तो डेवलपर को सूचित किया जाता है। इसके विपरीत अपवाद, असाधारण, असंभाव्य या गलत स्थितियों के लिए नियंत्रण प्रवाह तंत्र प्रदान करते हैं, लेकिन असंभव परिस्थितियां नहीं। मेरे लिए, मुख्य अंतर यह है:

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

• यह एक परीक्षण मामले का उत्पादन करने के लिए संभव होना चाहिए जो आग लगने का कारण बनता है। यदि एक जोर से आग लग जाती है, तो या तो कोड गलत है या दावा गलत है; किसी भी तरह से, कोड में कुछ बदलने की जरूरत है।

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

Comments

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

— kizzx2

@ kizzx2: ठीक है, तो आप उत्पादन कोड की प्रति पंक्ति कितने असंभव अपवाद लिखते हैं?

— एरिक लिपपर्ट 15

@ kixxx2: यह C # है, इसलिए आप Trace.Assert का उपयोग करके उत्पादन कोड में दावे रख सकते हैं । आप एंड-यूज़र के लिए असभ्य होने के बजाय एक टेक्स्ट फ़ाइल में उत्पादन के दावे को फिर से निर्देशित करने के लिए app.config फ़ाइल का उपयोग भी कर सकते हैं।

— HTTP 410

@AnorZaken: आपका बिंदु अपवादों में एक डिज़ाइन दोष दिखाता है। जैसा कि मैंने अन्यत्र उल्लेख किया है, अपवाद हैं (1) घातक आपदाएँ, (2) अस्थि-पंजर गलतियाँ जो कभी नहीं होनी चाहिए, (3) डिज़ाइन विफलताएँ जहाँ एक अपवाद का उपयोग एक गैर-असाधारण स्थिति, या (4) अप्रत्याशित बहिर्जात स्थितियों को इंगित करने के लिए किया जाता है । इन चार पूरी तरह से अलग-अलग चीजें क्यों हैं जो सभी अपवादों द्वारा प्रतिनिधित्व करते हैं? यदि मेरे पास मेरे शराबी थे , तो हड्डी वाले "अशक्त थे" को छोड़ दिया गया था, अपवाद बिल्कुल भी नहीं होगा । यह कभी भी सही नहीं है, और इससे अधिक नुकसान पहुंचाने से पहले अपने कार्यक्रम को समाप्त कर देना चाहिए । उन्हें मुखरता अधिक पसंद होनी चाहिए।

— एरिक लिपर्ट

@ बैकवर्ड_डेव: झूठे दावे बुरे हैं, सच्चे नहीं। दावे आपको महंगे सत्यापन चेक चलाने में सक्षम बनाते हैं जिन्हें आप उत्पादन में नहीं चलाना चाहते हैं। और अगर उत्पादन में एक उल्लंघन का उल्लंघन होता है, तो अंतिम उपयोगकर्ता को इसके बारे में क्या करना चाहिए?

— एरिक लिपर्ट

Answer 2

दुनिया की प्रोग्रामर की समझ की जाँच करने के लिए अभिकथन का उपयोग किया जाता है। यदि प्रोग्रामर ने कुछ गलत किया है, तो एक जोर ही विफल होना चाहिए। उदाहरण के लिए, उपयोगकर्ता इनपुट की जांच करने के लिए कभी भी उपयोग न करें।

उन स्थितियों के लिए परीक्षण करता है जो "नहीं हो सकते"। अपवाद उन स्थितियों के लिए हैं जो "नहीं होना चाहिए लेकिन करते हैं"।

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

यदि आप दावे के बजाय अपवादों का उपयोग करते हैं, तो आप कुछ मूल्य खो देते हैं:

1. कोड अधिक वर्बोज़ है, क्योंकि एक अपवाद का परीक्षण और फेंकना कम से कम दो लाइनें हैं, जबकि एक मुखर केवल एक है।

2. आपका परीक्षण और फेंक कोड हमेशा चलेगा, जबकि मुखर को संकलित किया जा सकता है।

3. आप अन्य डेवलपर्स के साथ कुछ संचार खो देते हैं, क्योंकि उत्पाद कोड की तुलना में एस्कॉर्ट्स का एक अलग अर्थ है जो जांच और फेंकता है। यदि आप वास्तव में एक प्रोग्रामिंग अभिकथन का परीक्षण कर रहे हैं, तो एक मुखर का उपयोग करें।

यहाँ और अधिक: http://nedbatchelder.com/text/assert.html

Comments

यदि यह "नहीं हो सकता है", तो क्यों लिखें क्या यह बेमानी नहीं है? अगर यह वास्तव में हो सकता है, लेकिन ऐसा नहीं होना चाहिए, तो यह "ऐसा नहीं होना चाहिए, लेकिन ऐसा नहीं है" जो अपवादों के लिए है?

— डेविड क्लेम्फनर

"हो नहीं सकता" एक कारण के लिए उद्धरण में है: यह केवल तभी हो सकता है जब प्रोग्रामर ने प्रोग्राम के दूसरे भाग में कुछ गलत किया हो। मुखर प्रोग्रामर गलतियों के खिलाफ एक जाँच है।

— नेड बाचेल्डर

जब आप एक पुस्तकालय विकसित करते हैं तो @NedBatchelder शब्द प्रोग्रामर थोड़ा अस्पष्ट होता है। क्या यह सही है कि उन "असंभव स्थितियों" को पुस्तकालय उपयोगकर्ता द्वारा असंभव होना चाहिए , लेकिन यह संभव हो सकता है जब पुस्तकालय लेखक ने गलती की?

— ब्रूनो ज़ेल

Answer 3

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

मैं अपने शब्दों में एक जवाब टाइप करने जा रहा था, लेकिन इस अवधारणा से मुझे बेहतर न्याय मिलता है:

C # स्टेशन: अभिकथन

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

निम्नलिखित स्थिति के सभी होने पर ही एक परख का उपयोग किसी स्थिति का परीक्षण करने के लिए किया जाता है:

* the condition should never be false if the code is correct,
* the condition is not so trivial so as to obviously be always true, and
* the condition is in some sense internal to a body of software.

सॉफ़्टवेयर के सामान्य संचालन के दौरान उत्पन्न होने वाली स्थितियों का पता लगाने के लिए अभिक्रियाओं का उपयोग लगभग कभी नहीं किया जाना चाहिए। उदाहरण के लिए, आमतौर पर किसी उपयोगकर्ता के इनपुट में त्रुटियों की जांच के लिए अभिकथन का उपयोग नहीं किया जाना चाहिए। हालाँकि, यह पुष्टि करने के लिए समझ में आता है कि किसी कॉलर ने पहले ही उपयोगकर्ता के इनपुट की जाँच कर ली है।

मूल रूप से, उन चीजों के अपवादों का उपयोग करें जिन्हें उत्पादन एप्लिकेशन में पकड़ा जाना चाहिए / निपटाया जाना चाहिए, तार्किक जांच करने के लिए अभिकथन का उपयोग करें जो विकास के लिए उपयोगी होगा, लेकिन उत्पादन में बंद हो जाएगा।

Comments

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

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

— एड एस।

मुझे लगता है कि यह सब नीचे आता है कि आप कितना रक्षात्मक रूप से कोड करना चाहते हैं।

— नेड बाचेल्डर

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

— टॉम नेयलैंड

Answer 4

मुझे लगता है कि एक (आकस्मिक) व्यावहारिक उदाहरण अंतर को रोशन करने में मदद कर सकता है:

( MoreLinq के बैच विस्तार से अनुकूलित )

// 'public facing' method
public int DoSomething(List<string> stuff, object doohickey, int limit) {

    // validate user input and report problems externally with exceptions

    if(stuff == null) throw new ArgumentNullException("stuff");
    if(doohickey == null) throw new ArgumentNullException("doohickey");
    if(limit <= 0) throw new ArgumentOutOfRangeException("limit", limit, "Should be > 0");

    return DoSomethingImpl(stuff, doohickey, limit);
}

// 'developer only' method
private static int DoSomethingImpl(List<string> stuff, object doohickey, int limit) {

    // validate input that should only come from other programming methods
    // which we have control over (e.g. we already validated user input in
    // the calling method above), so anything using this method shouldn't
    // need to report problems externally, and compilation mode can remove
    // this "unnecessary" check from production

    Debug.Assert(stuff != null);
    Debug.Assert(doohickey != null);
    Debug.Assert(limit > 0);

    /* now do the actual work... */
}

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

Comments

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

— डेविड क्लेम्फनर

यह बात है - कि वहाँ असंभव है दस्तावेज़ सामग्री के लिए दावे हैं। तुम ऐसा क्यों करोगे? क्योंकि आपके पास ReSharper जैसा कुछ हो सकता है जो आपको DoSomethingImpl पद्धति के अंदर चेतावनी देता है कि "आप यहाँ नीरस हो सकते हैं" और आप इसे बताना चाहते हैं "मुझे पता है कि मैं क्या कर रहा हूँ, यह कभी भी अशक्त नहीं हो सकता"। यह कुछ बाद के प्रोग्रामर के लिए भी एक संकेत है, जो तुरंत DoSomething और DoSomethingImpl के बीच संबंध का एहसास नहीं कर सकते हैं, खासकर अगर वे लाइनों के सौ अलग हैं।

— मार्सेल पोपस्कु

Answer 5

कोड पूरा से एक और डली :

"एक दावा एक फ़ंक्शन या मैक्रो है जो जोर से शिकायत करता है यदि कोई धारणा सत्य नहीं है। कोड में किए गए दस्तावेज़ मान्यताओं और अप्रत्याशित स्थितियों को बाहर निकालने के लिए दावे का उपयोग करें। ...

"विकास के दौरान, विरोधाभासी विरोधाभासों, अप्रत्याशित स्थितियों, खराब मूल्यों को दिनचर्या में पारित कर दिया जाता है, और इसी तरह।"

उन्होंने कहा कि क्या होना चाहिए और क्या नहीं होना चाहिए पर कुछ दिशानिर्देश जोड़ने के लिए जाता है।

दूसरी ओर, अपवाद:

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

यदि आपके पास यह पुस्तक नहीं है, तो आपको इसे खरीदना चाहिए।

Comments

मैंने किताब पढ़ी है, यह बेहतरीन है। हालाँकि .. आपने मेरे सवाल का जवाब नहीं दिया :)

आप सही हैं मैंने इसका जवाब नहीं दिया। मेरे जवाब नहीं मैं आपसे सहमत नहीं हूं। दावे और अपवाद अलग-अलग जानवर हैं जो ऊपर कवर किए गए हैं और कुछ अन्य यहां पोस्ट किए गए उत्तर हैं।

— एंड्रयू कोवेनहॉवन

Answer 6

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

Comments

पहला आंशिक वाक्य सच है, बाकी सामान्य रूप से एक बुरा विचार है: दावे मान्यताओं हैं और कोई सत्यापन (जैसा कि ऊपर कहा गया है), रिलीज में डिबग को सक्षम करना वास्तव में कोई विकल्प नहीं है।

— मार्क विटके

Answer 7

जो चीजें हैं, उनके लिए अभिकथन का उपयोग करें संभव है, लेकिन ऐसा नहीं होना चाहिए (अगर यह असंभव थे, तुम क्यों एक अभिकथन रखा?)।

एक का उपयोग करने के लिए एक मामले की तरह है कि ध्वनि नहीं है Exception? आप एक के बजाय एक दावे का उपयोग क्यों करेंगेException ?

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

आमतौर पर आपके सामने कोई कोड नहीं होता है Exception जो गारंटी देता है कि इसे फेंका नहीं जाएगा।

यह अच्छा क्यों है Debug.Assert()जो ठेस में संकलित है? यदि आप डिबग में इसके बारे में जानना चाहते हैं, तो क्या आप इसके बारे में जानना नहीं चाहते हैं?

आप इसे केवल विकास के दौरान चाहते हैं, क्योंकि एक बार जब आप Debug.Assert(false)स्थितियों का पता लगाते हैं, तो आप गारंटी के लिए कोड लिखते हैं जो Debug.Assert(false)फिर से नहीं होता है। एक बार विकास हो जाने के बाद, यह मानते हुए कि आपने Debug.Assert(false)स्थितियों को ढूंढ लिया है और उन्हें ठीक कर लिया है, उन्हें Debug.Assert()सुरक्षित रूप से संकलित किया जा सकता है क्योंकि वे अब बेमानी हैं।

Answer 8

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