सी # घुंघराले ब्रैकेट के साथ/बिना कथन कथन .... क्या अंतर है?

Question

क्या सी # ने आपको case: कथन के बीच switch() कथन के अंदर घुंघराले ब्रैकेट को छोड़ने की अनुमति दी है?

जावास्क्रिप्ट प्रोग्रामर अक्सर करते समय उन्हें छोड़ने का क्या प्रभाव पड़ता है?

उदाहरण:

switch(x) 
{ 
    case OneWay: 
    {        // <---- Omit this entire line 
    int y = 123; 
    FindYou(ref y); 
    break; 
    }        // <---- Omit this entire line 
    case TheOther: 
    {        // <---- Omit this entire line 
    double y = 456.7; // legal! 
    GetchaGetcha(ref y); 
    break; 
    }        // <---- Omit this entire line 
} 

Answer 1

घुंघराले ब्रेसिज़ की आवश्यकता नहीं है, लेकिन वे एक नई घोषणा स्थान पेश करने के लिए आसान हो सकते हैं। जहां तक ​​मुझे पता है सी # 1.0 के बाद से यह व्यवहार नहीं बदला है।

उन्हें छोड़ने का प्रभाव यह है कि switch कथन के अंदर कहीं भी घोषित सभी चर सभी केस शाखाओं में घोषणा के उनके बिंदु से दिखाई दे रहे हैं।

भी देखें एरिक Lippert के उदाहरण (पोस्ट में मामला 3):

Four switch oddities

एरिक के उदाहरण:

switch(x) 
{ 
    case OneWay: 
    int y = 123; 
    FindYou(ref y); 
    break; 
    case TheOther: 
    double y = 456.7; // illegal! 
    GetchaGetcha(ref y); 
    break; 
} 

यह संकलन नहीं है क्योंकि int y और double y वें द्वारा पेश की गई एक ही घोषणा स्थान में हैं ई switch कथन।आप ब्रेसिज़ का उपयोग कर घोषणा रिक्त स्थान को अलग करके त्रुटि को ठीक कर सकते हैं:

switch(x) 
{ 
    case OneWay: 
    { 
    int y = 123; 
    FindYou(ref y); 
    break; 
    } 
    case TheOther: 
    { 
    double y = 456.7; // legal! 
    GetchaGetcha(ref y); 
    break; 
    } 
} 

Answer 2

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

वे स्विच ब्लॉक के भीतर दायरे को सीमित करने के लिए उपयोगी हो सकते हैं। उदाहरण के लिए:

int x = 5; 

switch(x) 
{ 
case 4: 
    int y = 3; 
    break; 
case 5: 
    y = 4; 
    //...      
    break; 
} 

बनाम ...

int x = 5; 

switch(x) 
{ 
    case 4: 
    { 
    int y = 3; 
    break; 
    } 
    case 5: 
    { 
    y = 4;//compiling error 
    //...      
    break; 
    } 
} 

नोट: सी # उपयोग करने से पहले पहले उदाहरण में मामला 5 ब्लॉक के भीतर y के लिए एक मूल्य निर्धारित करने की आवश्यकता होगी। यह दुर्घटनाग्रस्त परिवर्तनीय अनुवर्ती के खिलाफ सुरक्षा है।

Answer 3

वे कड़ाई से जरूरी नहीं हैं लेकिन जैसे ही आप स्थानीय चर (स्विच शाखाओं में) घोषित करना शुरू करते हैं, उनकी बहुत अधिक अनुशंसा की जाती है।

यह काम करेगा नहीं:

// does not compile 
    switch (x) 
    { 
     case 1 :    
      int j = 1; 
      ... 
      break; 

     case 3: 
      int j = 3; // error 
      ... 
      break; 
    } 

यह संकलित लेकिन यह डरावना है:

switch (x) 
    { 
     case 1 :    
      int j = 1; 
      ... 
      break; 

     case 3: 
      j = 3; 
      ... 
      break; 
    } 

तो यह सबसे अच्छा है:

switch (x) 
    { 
     case 1 : 
     {    
      int j = 1; 
      ... 
     } 
     break; // I prefer the break outside of the { } 

     case 3: 
     { 
      int j = 3; 
      ... 
     } 
     break; 
    } 

बस इसे सरल और पठनीय रहते हैं। आप मध्य उदाहरण में शामिल नियमों का विस्तृत ज्ञान रखने के लिए पाठकों की आवश्यकता नहीं लेना चाहते हैं।

Answer 4

ब्रेसिज़ के अंदर स्विच वास्तव में स्विच संरचना का हिस्सा ही नहीं है। वे केवल स्कोप ब्लॉक हैं, जिन्हें आप कहीं भी कोड में लागू कर सकते हैं।

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

उदाहरण:

int x = 42; 
{ 
    int y = x; 
} 
{ 
    int y = x + 1; // legal, as it's in a separate scope 
}