आउट चर में C # 7: अंडरस्कोर (_) और स्टार (*)

Question 1

मैं यहाँ C # 7 में नई परिवर्तनशील विशेषताओं के बारे में पढ़ रहा था । मेरे दो सवाल हैं:

इसे कहते हैं
हम "के रूप में अच्छी तरह से मापदंडों के रूप में" डिस्कार्ड "की अनुमति देते हैं _, आपको उन मापदंडों को अनदेखा करने की अनुमति देता है जिनके बारे में आपको परवाह नहीं है:
```
p.GetCoordinates(out var x, out _); // I only care about x
```
प्रश्न: मुझे लगता है कि यह सिर्फ एक जानकारी है और C # 7 की नई विशेषता नहीं है क्योंकि हम ऐसा पूर्व C # 7.0 में भी कर सकते हैं:
```
var _;
if (Int.TryParse(str, out _))
...
```
या मुझसे यहां कुछ छूट रहा है?
जब मैं एक ही ब्लॉग में उल्लिखित करता हूं तो मेरा कोड एक त्रुटि देता है:
```
~Person() => names.TryRemove(id, out *);
```
*मान्य पहचानकर्ता नहीं है। मैड्स टॉर्गेसेन द्वारा एक निरीक्षण मुझे लगता है?

Question 2

डिस्क्लेमर , C # 7 में जहाँ भी वैरिएबल घोषित किया जाता है, - से - जैसा कि नाम से पता चलता है - परिणाम को छोड़ दें। तो एक विचलन का उपयोग चर के साथ किया जा सकता है:

p.GetCoordinates(out var x, out _);

और इसका उपयोग अभिव्यक्ति परिणाम को छोड़ने के लिए किया जा सकता है:

_ = 42;

उदाहरण में,

p.GetCoordinates(out var x, out _);
_ = 42;

कोई चर नहीं है, _ पेश किया जा रहा है। एक त्याग के सिर्फ दो मामले हैं।

हालाँकि, यदि कोई पहचानकर्ता _दायरे में मौजूद है, तो उपयोग नहीं किया जा सकता है:

var _ = 42;
_ = "hello"; // error - a string cannot explicitly convert from string to int

इसका अपवाद तब होता है जब एक _चर का उपयोग एक बाहरी चर के रूप में किया जाता है। इस मामले में, संकलक प्रकार को अनदेखा varकरता है या इसे त्याग के रूप में मानता है:

if (p.GetCoordinates(out double x, out double _))
{
    _ = "hello"; // works fine.
    Console.WriteLine(_); // error: _ doesn't exist in this context.
}

ध्यान दें कि यह केवल तब होता है, यदि इस मामले में, out var _या out double _इसका उपयोग किया जाता है। बस का उपयोग करें out _और फिर इसे एक मौजूदा चर के संदर्भ के रूप में माना जाता है _, अगर यह दायरे में है, उदाहरण के लिए:

string _;
int.TryParse("1", out _); // complains _ is of the wrong type

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

Question 3

_सी # 7 में डिसॉर्डर ऑपरेटर का एक और उदाहरण एक स्टेटमेंट में एक प्रकार के वेरिएबल से मिलान करना है , जिसे हाल ही में C # 7 में जोड़ा गया था:objectswitch

कोड:

static void Main(string[] args)
{
    object x = 6.4; 
    switch (x)
    {
        case string _:
            Console.WriteLine("it is string");
            break;
        case double _:
            Console.WriteLine("it is double");
            break;
        case int _:
            Console.WriteLine("it is int");
            break;
        default:
            Console.WriteLine("it is Unknown type");
            break;
    }

    // end of main method
}

यह कोड प्रकार से मेल खाएगा और पास किए गए चर को छोड़ देगा case ... _।

Question 4

अधिक जिज्ञासु के लिए

निम्नलिखित स्निपेट पर विचार करें

static void Main(string[] args)
{
    //....
    int a;
    int b;

    Test(out a, out b);
    Test(out _, out _);    
    //....
}

private static void Test(out int a, out int b)
{
    //...
}

यह क्या हो रहा है:

...

13:             int  a;
14:             int  b;
15: 
16:             Test(out a, out b);
02340473  lea         ecx,[ebp-40h]  
02340476  lea         edx,[ebp-44h]  
02340479  call        02340040  
0234047E  nop  
    17:             Test(out _, out _);
0234047F  lea         ecx,[ebp-48h]  
02340482  lea         edx,[ebp-4Ch]  
02340485  call        02340040  
0234048A  nop 

...

जैसा कि आप दृश्य के पीछे देख सकते हैं कि दो कॉल एक ही बात कर रहे हैं।

जैसा कि @ सर्व लॉरिजसेन ने कहा कि ठंडी बात यह है कि आपको उन चरों को पहले से घोषित नहीं करना है, जो कुछ मूल्यों में दिलचस्पी नहीं रखते हैं।

Question 5

पहले सवाल के बारे में

मुझे लगता है कि यह सिर्फ एक जानकारी है और C # 7 की नई विशेषता नहीं है क्योंकि हम ऐसा पूर्व C # 7.0 में भी कर सकते हैं।
var _;
if (Int.TryParse(str, out _))
    // ...

नवीनता यह है कि आपको _अभिव्यक्ति के अंदर या बाहर अब और घोषित नहीं करना है और आप बस टाइप कर सकते हैं

int.TryParse(s, out _);

यह एक लाइनर पूर्व C # 7 करने की कोशिश करें:

private void btnDialogOk_Click_1(object sender, RoutedEventArgs e)
{
     DialogResult = int.TryParse(Answer, out _);
}

Question 6

C # 7.0 (मार्च 2017 के आसपास विजुअल स्टूडियो 2017) में, निम्नलिखित संदर्भों में असाइनमेंट में डिस्क्स का समर्थन किया जाता है:

टप्ले और ऑब्जेक्ट डिकंस्ट्रक्शन।
पैटर्न के साथ मिलान और स्विच है ।
मापदंडों के साथ विधियों को कॉल करता है।
एक स्टैंडअलोन _ जब कोई _ गुंजाइश में न हो।

अन्य उपयोगी नोट्स

डिस्क मेमोरी मेमोरी को कम कर सकते हैं। क्योंकि वे आपके कोड के इरादे को स्पष्ट करते हैं, वे इसकी पठनीयता और स्थिरता को बढ़ाते हैं
ध्यान दें कि _ एक मान्य पहचानकर्ता भी है। जब एक समर्थित संदर्भ के बाहर उपयोग किया जाता है

सरल उदाहरण: यहां हम 1 और 2 पैरा का उपयोग नहीं करना चाहते हैं और केवल 3 जी परम की जरूरत है

(_, _, area) = city.GetCityInformation(cityName);

स्विच केस में उन्नत उदाहरण जो आधुनिक स्विच केस पैटर्न मिलान ( स्रोत ) का उपयोग करता है

switch (exception)                {
case ExceptionCustom exceptionCustom:       
        //do something unique
        //...
    break;
case OperationCanceledException _:
    //do something else here and we can also cast it 
    //...
    break;
default:
    logger?.Error(exception.Message, exception);
    //..
    break;

}

Question 7

क्यू: ... हम पूर्व C # 7.0 में भी ऐसा कर सकते हैं:

var _;
if (Int.TryParse(str, out _))

या मुझसे यहां कुछ छूट रहा है?

यह एक ही बात नहीं है।
आपका कोड एक असाइनमेंट बना रहा है।

C # 7.0 _ में एक वैरिएबल नहीं है, यह संकलक को मूल्य त्यागने के लिए कहता है
( जब तक कि आपने घोषित नहीं किया है _ को वेरिएबल किया है ... अगर आप ऐसा करते हैं कि वेरिएबल को डिसाइड सिंबल के बजाय इस्तेमाल किया जाता है)

उदाहरण: आप एक कोड के समान स्टिंग और एक इंट के रूप में _ का उपयोग कर सकते हैं :

string a; 
int b;
Test(out a, out b);
Test(out _, out _);

//...

void Test(out string a, out int b)
{
   //...
}