c# - सरल सी#नूप स्टेटमेंट




noop (10)

C # में एक सरल Noop स्टेटमेंट क्या है, जिसे किसी विधि को लागू करने की आवश्यकता नहीं है? (इनलाइन / लैंबडा विधियां ठीक हैं, हालांकि)

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


C # में मानक रिक्त विवरण / noop कार्रवाई है ; जैसा कि if (true) ;
- ब्लूबेरी फल

लेकिन उस मानक का उपयोग करना ; if किसी स्टेटमेंट की एक शाखा के रूप में एमएस विजुअल स्टूडियो 2010 एक चेतावनी दिखाता है: "संभावित गलत स्टेटमेंट"। (चेतावनी CS0642, हालांकि VS2010 मुझे यह नहीं बताता है या चेतावनी के लिए वास्तविक मदद के लिए लिंक है।)

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

इससे भी बुरी बात यह है कि ऐसा लगता है कि VS2010 व्यक्तिगत चेतावनी को दबाने के लिए कोई रास्ता नहीं प्रदान करता है। मुझे लाइन (ओं) और [वैकल्पिक रूप से] #pragma warning disable CS0642 बाद #pragma warning disable CS0642 से पहले #pragma warning disable CS0642 को सम्मिलित करना होगा। मेरे लिए, यह चेतावनी की तुलना में बदसूरत है। मैं के स्थान पर { } का उपयोग करना बेहतर होगा ; । (मैं एक ओवरराइड का उपयोग कर सकता हूं जो थोड़ा कम बदसूरत है।)

मैंने "सी # नो-ऑप" के लिए यहां देखा क्योंकि मुझे उस चेतावनी से छुटकारा पाने के लिए "खाली बयान" का विकल्प चाहिए था। मुझे चौकी की जरूरत नहीं है। मुझे बस एक काम चाहिए- [बिल्कुल] -सुंदर जो "खाली बयान" की तरह अस्पष्ट नहीं है।

विकल्प को कुछ अन्य चेतावनी भड़काने नहीं चाहिए। int u; यह अच्छा नहीं है क्योंकि यह चेतावनी को उकसाता है "चर 'यू' घोषित है लेकिन कभी इस्तेमाल नहीं किया गया"। int u = 0; यह अच्छा नहीं है क्योंकि यह चेतावनी को उत्तेजित करता है "चर 'u' को असाइन किया गया है लेकिन इसका मान कभी उपयोग नहीं किया जाता है"।

अगर noop; (या इसी तरह) एक अस्पष्ट खाली बयान (एक स्थूल परिभाषा नहीं) के रूप में जोड़ा गया था, जो बहुत अच्छा होगा।

यदि noop(); (या इसी तरह) एक खाली शरीर के साथ एक फ़ंक्शन था (जो पूरी तरह से गायब हो सकता है जब संकलक इसमें प्रवेश करता है), जो लगभग महान होगा।

जब शाखा केवल एक बयान होती है, तो मैं अक्सर आसपास के { और } LINES को छोड़ देता हूं क्योंकि उनकी आवश्यकता नहीं होती है और वे कोड को लंबवत रूप से खींचते हैं, जिससे इसे पढ़ना मुश्किल हो जाता है। भाषा में विसंगति यह है कि मैं आसपास के { और } LINES को तब नहीं छोड़ सकता जब वे Zero स्टेटमेंट को घेर लेते हैं। मैं एक ही लाइन पर दो पंक्तियों को { } कॉम्पैक्ट कर सकता हूं, लेकिन यह असंगत है। मुझे लगता है ; एक लाइन पर सबसे साफ समाधान है, और यह "खराब रूप" के [अस्थिर] आधार पर चेतावनी का कारण नहीं होना चाहिए। मुझे लगता है कि CS0642 को चेतावनी देना बंद होना चाहिए। मुझे लगता है कि निम्नलिखित कोड स्वीकार्य होना चाहिए:

if (condition1)
  action1;
else if (condition2)
  ;  // (do nothing)
else if (condition3)
  action3;
else if (condition4)
  ;  // (do nothing)
else if (condition5)
  action5;
else
  action99;

(मैंने इसे टिप्पणी के रूप में लिखने में असमर्थता व्यक्त की क्योंकि मुझे अभी तक "टिप्पणी करने के लिए 50 प्रतिष्ठा नहीं मिली है"। अब जब मैं टिप्पणी कर सकता हूं, तो 2k बाइट्स पर, यह 1.5K बाइट्स द्वारा टिप्पणी के लिए बहुत लंबा है, इसलिए यह यहां रह रहा है। ।)


C # में मानक रिक्त विवरण / noop ऑपरेशन है

;

जैसे की:

if (true)
    ;

( प्रासंगिक दस्तावेज )

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


आप बस लिख सकते हैं:

catch {
    ;
}

एक एकल अर्धविराम वाला खाली कथन C # NOOP है।


उन उत्तरों के अलावा जो सीधे प्रश्न का उत्तर देते हैं।

यदि आप बस ब्रेक करना चाहते हैं, तो आप हमेशा ब्रेकपॉइंट को ब्रेक ब्लॉक के उद्घाटन { या समापन } पर रख सकते हैं।


क्या आप किसी रिलीज़ (अनुकूलित) निर्माण को डीबग करने का प्रयास कर रहे हैं? यह सामान्य रूप से ऑप्टिमाइज़र है जो अपरिवर्तित चर और खाली ब्लॉकों को हटा देता है।

दो समाधान:

  • डीबग बिल्ड में डीबग करें।
  • लोकल टूल विंडो में फ्लाइट में अपवाद को रेफर करने के लिए डिबगर द्वारा बनाई गई catch ही ब्रेक प्वाइंट लगाएं और $exception उपयोग करें।

क्यों इस पर इंजीनियर?

var x = 0;

ठीक काम करता है :)


मुझे पता है कि यह एक पुराना प्रश्न है और तकनीकी रूप से, यह उत्तर प्रश्नकर्ता के उपयोग के मामले से संबंधित नहीं है। हालाँकि, CIL में एक NOOP निर्देश है, जो कि nop । एक प्रयोग के रूप में, निम्नलिखित सीआईएल आवेदन लें।

.assembly extern mscorlib {}

.assembly Test
{
    .ver 1:0:1:0
}
.module test.exe

.method static void main() cil managed
{
    .maxstack 1
    .entrypoint

    nop
    nop
    nop
    nop

    ret
}

यदि आप एप्लिकेशन को संकलित करते हैं, और इसे ILSpy, C # जैसे टूल के साथ डिकम्पाइल करते हैं, तो यह मुख्य () विधि की सामग्री है:

static void main()
{
}

जैसा कि आप देख सकते हैं, वहाँ कुछ भी नहीं है। हालाँकि, अगर हम यह सत्यापित करना चाहते हैं कि CIL कंपाइलर ने इन nop स्टेटमेंट्स को ऑप्टिमाइज़ नहीं किया है, तो हम ILSpy में डिकम्प्लेस्ड IL कोड में अपना एप्लिकेशन देख सकते हैं, और यही हम मुख्य विधि के लिए देखते हैं:

.method static privatescope 
    void main$PST06000001 () cil managed 
{
    // Method begins at RVA 0x2050
    // Code size 5 (0x5)
    .maxstack 1
    .entrypoint

    IL_0000: nop
    IL_0001: nop
    IL_0002: nop
    IL_0003: nop
    IL_0004: ret
} // end of method '<Module>'::main

सीआईएल निश्चित रूप से विधानसभा में nop निर्देशों का संकलन कर रहा है। चूंकि C # में इस निर्देश का कोई कार्यान्वयन नहीं है, इसलिए इन nop कमांडों को nop C # कोड के भीतर नहीं दिखाया गया है।

मेरे पास रिफ्लेक्टर का लाइसेंस नहीं है, लेकिन मुझे लगता है कि अगर आप रिफ्लेक्टर के साथ इन बायनेरिज़ को डिकंपाइल करते हैं तो आपको C # के लिए समान आउटपुट मिलेगा।


मुझे यह काफी पसंद है, सिर्फ इसलिए कि यह भ्रमित करेगा कि जो भी इसके पार आएगा:

catch (SomeException e)
{
    lock(e);
} 

यदि आप वास्तव में शून्य चाहते हैं, तो यह एक ऐसी अमानवीय कार्रवाई को परिभाषित करता है जो कुछ भी नहीं करती है, और फिर इसे लागू करती है, जिससे कुछ भी नहीं होता है:

((Action)(() => { }))();

यह @AHM के उत्तर के अतिरिक्त है क्योंकि मैं डिबगिंग उद्देश्यों के लिए NOOP करने का एक आसान तरीका चाहता था (AB PLC CompactLogix के साथ संवाद करना और C ++ लाइब्रेरी DLL C # में आयात के कारण केवल Disassembly में दिखाई देने वाली त्रुटियों में भाग गया)।

मैंने वन-लाइनर लिया

((Action)(() => { }))();

और इसे noop.snippet नाम के एक स्निपेट में डाल दिया और फिर इसे My Code Snippets नाम के फ़ोल्डर में रख दिया।
( उपकरण -> कोड स्निपेट प्रबंधक -> स्थान ) या तार ( Ctrl + K, Ctrl + B )

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets  xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
    <CodeSnippet Format="1.0.0">
        <Header>
            <Title>noop</Title>
            <Shortcut>noop</Shortcut>
            <Description>Code snippet to inject an assembly (x86) equivalent of the NOOP command into the code's disassembly.</Description>
            <Author>Jay Whaley</Author>
            <SnippetTypes>
                <SnippetType>Expansion</SnippetType>
            </SnippetTypes>
        </Header>
        <Snippet>
            <Code Language="csharp">
            <![CDATA[// Forces a psuedo NOOP in disassembly
                ((Action)(() => { }))();
            $end$]]>
            </Code>
        </Snippet>
    </CodeSnippet>
</CodeSnippets>

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





noop