"केवल डीबग करें" कोड जिसे "चालू" होने पर ही चलना चाहिए

Question

मैं कुछ C # "डिबग केवल" कोड जोड़ना चाहूंगा जो केवल तभी चलता है जब व्यक्ति डीबगिंग अनुरोध करता है। C ++ में, मैं निम्नलिखित के समान कुछ करता था:

void foo()
{   
  // ...
  #ifdef DEBUG
  static bool s_bDoDebugOnlyCode = false;
  if (s_bDoDebugOnlyCode)
  {
      // Debug only code here gets executed when the person debugging 
      // manually sets the bool above to true.  It then stays for the rest
      // of the session until they set it to false.
  }
  #endif
 // ...
}

मैं सी # में बिल्कुल ऐसा नहीं कर सकता क्योंकि कोई स्थानीय स्टैटिक्स नहीं है।

प्रश्न : C # में इसे पूरा करने का सबसे अच्छा तरीका क्या है?

1. क्या मुझे C # प्रीप्रोसेसर निर्देशों के साथ एक निजी वर्ग के स्थिर क्षेत्र का उपयोग करना चाहिए (#if/#endif DEBUG ) के ?
2. क्या मुझे सशर्त विशेषता (कोड धारण करने के लिए) का उपयोग करना चाहिए, और फिर एक निजी वर्ग स्थिर क्षेत्र ( नहीं) सी # प्रीप्रोसेसर निर्देशों से घिरा#if/#endif DEBUG ?)।
3. कुछ और?

Answer 1

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

#if DEBUG
private /*static*/ bool s_bDoDebugOnlyCode = false;
#endif

void foo()
{   
  // ...
#if DEBUG
  if (s_bDoDebugOnlyCode)
  {
      // Code here gets executed only when compiled with the DEBUG constant, 
      // and when the person debugging manually sets the bool above to true.  
      // It then stays for the rest of the session until they set it to false.
  }
#endif
 // ...
}

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

private /*static*/ bool doDebugOnlyCode = false; 
[Conditional("DEBUG")]
void foo()
{   
  // ...    
  if (doDebugOnlyCode)
  {
      // Code here gets executed only when compiled with the DEBUG constant, 
      // and when the person debugging manually sets the bool above to true.  
      // It then stays for the rest of the session until they set it to false.
  }    
  // ...
}

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

Comments

अंत में - कोई है जो पूरे प्रश्न को पढ़ता है । धन्यवाद, ठीक है - यह एक लंबा समाधान की तरह लग रहा था (दो preprocessor वर्गों के लिए), लेकिन शायद यह सबसे अच्छा है C # मैं क्या चाहता हूँ के लिए कर सकते हैं।

— मैट स्मिथ

हुंह। मैं इस लंबी बात को सिर्फ इसलिए नहीं कहूंगा क्योंकि आप प्रीप्रोसेसर निर्देश की दो और लाइनें जोड़ते हैं।

— कीथ्स

खैर, बहुत धन्यवाद पैट्रिक, एक के पक्ष में 3 साल पुराने स्वीकृत जवाब को डाउनवॉट करने के लिए जो पूरी समस्या को हल नहीं करता है। सशर्त विशेषता केवल गैर-डीबग मोड में निष्पादित होने वाली विधि को रोकती है। ओपी न केवल इतना चाहता था, बल्कि डिबगर का उपयोग करके कोड को "चालू" करने में सक्षम था। और, गोकक के टैग का उपयोग नहीं किया जाएगा।

— कीथ्स

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

— शेन

Answer 2

तुम जो खोज रहे हो

[ConditionalAttribute("DEBUG")]

विशेषता।

यदि आप उदाहरण के लिए एक विधि लिखते हैं जैसे:

[ConditionalAttribute("DEBUG")]
public static void MyLovelyDebugInfoMethod(string message)
{
    Console.WriteLine("This message was brought to you by your debugger : ");
    Console.WriteLine(message);
}

आपके द्वारा अपने कोड के अंदर इस विधि से की गई किसी भी कॉल को केवल डिबग मोड में निष्पादित किया जाएगा। यदि आप अपने प्रोजेक्ट को रिलीज़ मोड में बनाते हैं, तो भी "MyLovelyDebugInfoMethod" पर कॉल करें और उसे आपके बाइनरी से बाहर निकाल दिया जाएगा।

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

Comments

विशेषता का उपयोग करते समय, आपको प्रत्यय "गुण" लिखने की आवश्यकता नहीं है। सशर्त = संघननक गुण। एक विशेषता वर्ग को "विशेषता" के साथ समाप्त होना चाहिए, लेकिन कोड में विशेषता के रूप में उपयोग किए जाने पर छोड़ा जा सकता है। जब प्रत्यय छोड़ा जाता है तो पढ़ना आसान होता है।

— एरिक ओउलेट 6

Answer 3

यदि आप प्रक्रिया से जुड़े डिबगर होने पर केवल कोड चलाने की आवश्यकता है, तो आप यह कोशिश कर सकते हैं।

if (Debugger.IsAttached)
{
     // do some stuff here
}

Comments

धन्यवाद! यह वही है जो मैं चाहता था: डीबगिंग करते समय कंसोल विंडो को बंद करने से रोकने के लिए अंत में एक कंसोल। रीडलाइन () करें।

— वीवीएस

Answer 4

मैं यह उल्लेख के लायक है कि हो सकता है लगता है [ConditionalAttribute]में है System.Diagnostics;नाम स्थान। जब मैं मिला तो मैं थोड़ा लड़खड़ा गया:

Error 2 The type or namespace name 'ConditionalAttribute' could not be found (are you missing a using directive or an assembly reference?)

पहली बार उपयोग करने के बाद (मुझे लगा कि यह अंदर होगा System)।

Answer 5

यदि आप जानना चाहते हैं कि क्या डिबगिंग, हर जगह कार्यक्रम में। इसे इस्तेमाल करो।

वैश्विक परिवर्तन की घोषणा करें।

bool isDebug=false;

डीबग मोड की जाँच के लिए फ़ंक्शन बनाएँ

[ConditionalAttribute("DEBUG")]
    public static void isDebugging()
    {
        isDebug = true;
    }

प्रारंभिक विधि में फ़ंक्शन को कॉल करें

isDebugging();

अब पूरे कार्यक्रम में। आप डिबगिंग के लिए जाँच कर सकते हैं और संचालन कर सकते हैं। उम्मीद है की यह मदद करेगा!

Comments

AFAIK: यह और वैरिएंट केवल यह सुनिश्चित करने के लिए आग का रास्ता है कि क्या डिबग ध्वज सेट के साथ एक प्रोग्राम वॉश संकलित किया गया है।

— लॉसमनोस