तार्किक लेकिन अवैध

मेरा मानना ​​है कि कई लोग जो C ++ की शानदार दुनिया से .NET की शानदार दुनिया में आए थे, उन्हें अच्छी तरह से याद है कि भाषा को इस तरह से व्यवहार करने के लिए उन्हें कैसे मानक रूप से खोदना था, अन्यथा नहीं। बहुत सी चीजें जो उन्हें पूरी तरह से स्पष्ट लग रही थीं, करीबी परीक्षा पर, यह स्पष्ट नहीं था - लेकिन सामान्य ज्ञान के बिल्कुल विपरीत जो हम सभी पर भरोसा करते थे।

हालांकि, सबसे अधिक संभावना है, यह कई प्रोग्रामिंग भाषाओं में एक समस्या है। कई, मुझे लगता है कि जावास्क्रिप्ट और रूबी भाषाओं की कुछ "स्पष्टता" की समस्याओं के लिए समर्पित प्रसिद्ध वाट फिल्म याद है। सीमावर्ती क्षेत्र दिखाई देने पर परिचित दुनिया के तर्क धूम्रपान करते हैं - वे जिनमें सामान्य लोग चढ़ते नहीं हैं।

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

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

और, हां - मैं इस विषय पर एक बार फिर से सचेत नहीं करूंगा कि मैं भारी संरचना का उपयोग किए बिना फ़ंक्शन ट्यूपल से क्या लौटना चाहता हूं और एक साधारण ऑपरेटर का उपयोग करके चर नाम प्राप्त कर सकता हूं। यह यहाँ नहीं है - यह सुविधा अनुरोधों में Microsoft के लिए है। हमारे पास पांच मिनट का हास्य है। तो, वह सब जिसे आप दैनिक लिखना चाहते हैं, लेकिन लिखना नहीं है, क्योंकि आप जानते हैं - यह संकलन नहीं करेगा। चलो चलते हैं!

सबसे सरल से शुरू करते हैं।

int i = 0; 

मैं क्या सुनता? जैसे "यह कोड क्या करता है?" पेशे से बाहर निकलो! इस तरह के बौद्धिक बहुमत का हमारे क्लब ऑफ एगहेड्स में कोई स्थान नहीं है। यह कोड कुछ भी नहीं करता है - संकलनकर्ता अनुकूलन के दौरान इसे बाहर फेंक देगा और बिल्कुल सही होगा। लेकिन इस रिकॉर्ड का अर्थ मानसिक रूप से मंद होने पर भी समझा जा सकता है - हम नाम के साथ एक चर को परिभाषित करते हैं और इसे 0 के बराबर मान असाइन करते हैं।

आइए अधिक जटिल उदाहरण पर चलते हैं।

 int i = 0; int j = i; 

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

चलो यह कोशिश करते हैं

 int i = 0, j = 0; 

और ऐसा है

 int i = 0, j = i; 

कोई समस्या नहीं है।

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

 int i = j = 0; // error CS0103: The name `j' does not exist in the current context 

लेकिन रूसियों ने हार नहीं मानी!

 int i = int j = 0; // error CS1525: Unexpected symbol `j', expecting `.' 

अब जब कि आत्मा में कमजोर ने हमारे कुशल हाथों को छोड़ दिया है, तो आप चर्चा को टर्नरी ऑपरेटर के साथ कुछ हद तक विविधता दे सकते हैं!

 int i = whatever ? 1 : 2; 

हर दिन हम ऐसा कोड लिखते हैं। लेकिन हर कोई नहीं जानता (विशेषकर वे जो कभी भी C ++ में नहीं लिखे हैं, हालांकि, जो इस भाषा के शब्दार्थ को C # से कई गुना अधिक शक्तिशाली मानते हैं और उन्हें इस बात का एहसास नहीं है कि कई ऑपरेशन उसी तरह से किए जाते हैं), इस तरह किया जा सकता है।

 int i = whatever ? (j = 1) : 2; 

मुझे संदेह है कि ऐसे लोग हैं जिनके लिए यह प्रविष्टि एक रहस्य है। इसका मतलब एक साधारण बात है - यदि जो कुछ भी है, तो j को एक में असाइन करें और वेरिएबल i को असाइन करने का परिणाम (जो कि j का मान है)। अन्यथा, उसे असाइन करें 2. इस अविश्वसनीय शक्ति के साथ सशस्त्र, कूल्हे से गोली मारो!

 int i = whatever ? 2 * (j = 1) - 1 : 2; 

लेकिन एक हमेशा कुछ अजीब चाहता है - उदाहरण के लिए, एक टर्नरी ऑपरेटर में एक बाइबिक समीकरण को हल करने के लिए। या बस कुछ बचा है।

 int i = whatever ? { j = 1; return 2; } : 2; // error CS8025: Parsing error 

काश, मानव मन एक रक्तपात मशीन के सामने असफल हो रहा है। वह एक समाधान खोजने की कोशिश कर रहा है ...

 int i = whatever ? ( () => 1 )() : 2; // error CS0119: Expression denotes a `anonymous method', where a `method group' was expected 

इसलिए मैंने कंपाइलर को चिल्लाते हुए सुना:
- हां, मैं आपको एक प्रतिनिधि बनाऊंगा, मैं आपको बताऊंगा कि आप किस प्रकार का है?
- कोई भी!
- क्या?
- कोई भी। Lyuyuyubogo। Lyuyuyuyubogo!
- सिस्टम.मल्टीकास्टडेलेगेट।
- नहीं, ठीक है, बिल्कुल नहीं ...

(वैसे, जो इस वीडियो को YouTube पर ढूंढने में मदद करेगा - मैं बहुत आभारी रहूंगा)

और उसे पाता है!

 int i = whatever ? new System.Func<int>( () => 1 )() : 2; 

यद्यपि, अफसोस, वह मूल विचार की तरह सुंदर नहीं है।

 int i = whatever ? new System.Func<int>( () => { j = 1; return 2 + j; } )() : 2; 

लेकिन मछली की कमी पर, जैसा कि वे कहते हैं, बूट चुन्नी है।

अब जब बाकी के आधे पहले से ही जोर से खर्राटे ले रहे हैं, तो आप जटिल निर्देशों - ब्लॉकों पर जा सकते हैं।

हम सभी ने साइकिल लिखी।

 for(int i = 0; i < 10; i++); 

और हम जानते हैं कि वास्तव में यह प्रविष्टि निम्नलिखित के समान है:

 { int i = 0; while(i < 10) i++; } 

खैर, ऐसे

 int i; for(i = 0; i < 10; i++) 

इस कोड के समान।

 int i = 0; while(i < 10) i++; 

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

 using(IDisposable data = GetSomeData()) { } 

जो कुछ इस तरह सामने आता है

 { IDisposable data = null; try { data = GetSomeData(); } finally { if(data != null) data.Dispose(); } } 

अब कल्पना करें कि हम निम्नलिखित अभिव्यक्ति में "संक्षिप्त रूप" लिखना चाहते हैं

 { int i = 5; if(i < 10) i = 7; } 

नियंत्रण कथन में एक चर घोषणा को लागू करना तर्कसंगत होगा। जीतना?

 if((int i = 5) < 10) // error CS1525: Unexpected symbol `i', expecting `)' or `.' i = 7; 

इतने पास ...

ठीक है, लेकिन C # ऑब्जेक्ट ओरिएंटेड है। चलो वस्तुओं के साथ खेलते हैं!

स्मरण करो कि कैसे हम बस और प्रभावी ढंग से व्युत्पन्न वर्ग के निर्माता से मूल निर्माता को बुलाते हैं। क्या एक सुंदर और समझने योग्य वाक्यविन्यास था - गले में आँखों के लिए एक दृष्टि!

 class SomeClass { public SomeClass(int data) { } } class SomeOtherClass : SomeClass { public SomeOtherClass(int data) : base (data) { } } 

और मैं तुरंत कुछ अजीब चाहता हूं।

 class SomeClass { public virtual void SomeMethod(int data) { } } class SomeOtherClass : SomeClass { public override void SomeMethod(int data) : base (data) { } // Unexpected symbol `:' in class, struct, or interface member declaration } 

पिछली बार मैंने कंपाइलर को समझाने की कोशिश की कि मेरे लिखने का तरीका समझ में आता है - इसने मेरी दो पसलियाँ तोड़ दीं। प्रयोगों से सावधान रहें!

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

दूसरों के विपरीत, वैसे, यह सभी संस्करणों में संकलित है।

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

हमारे पास दो वर्गों का एक पदानुक्रम होगा जो एक इंटरफ़ेस को लागू करता है। और हम निम्नलिखित चुनौतियों का सामना करेंगे और परिणाम देखेंगे।

 new FooA().Foo(); new FooB().Foo(); ((IFoo) new FooA()).Foo(); ((IFoo) new FooB()).Foo(); ((FooA) new FooB()).Foo(); ((IFoo)(FooA) new FooB()).Foo(); 

क्योंकि हम कितने मजाकिया हैं।

चलो सरलतम - आभासी तरीकों से शुरू करते हैं। एक किताब की तरह।

 interface IFoo { void Foo(); } class FooA : IFoo { public virtual void Foo() { System.Console.WriteLine("A"); } } class FooB : FooA, IFoo { public override void Foo() { System.Console.WriteLine("B"); } } 

परिणाम स्पष्ट है!

 new FooA().Foo(); // A new FooB().Foo(); // B ((IFoo) new FooA()).Foo(); // A ((IFoo) new FooB()).Foo(); // B ((FooA) new FooB()).Foo(); // B ((IFoo)(FooA) new FooB()).Foo(); // B 

लेकिन हम होशियार हैं। हमें आभासी तरीकों की आवश्यकता क्यों है? हमारा एक इंटरफ़ेस है।

 interface IFoo { void Foo(); } class FooA : IFoo { public void Foo() { System.Console.WriteLine("A"); } } class FooB : FooA, IFoo { public void Foo() { System.Console.WriteLine("B"); } } 

निश्चित ही हमें एक चेतावनी मिलेगी

 // warning CS0108: `FooB.Foo()' hides inherited member `FooA.Foo()'. Use the new keyword if hiding was intended 

लेकिन ध्यान न दें - समस्या इसमें नहीं है, और नया कीवर्ड प्रयोग को प्रभावित नहीं करता है।

परिणाम भारी है।

 new FooA().Foo(); // A new FooB().Foo(); // B ((IFoo) new FooA()).Foo(); // A ((IFoo) new FooB()).Foo(); // B ((FooA) new FooB()).Foo(); // A ((IFoo)(FooA) new FooB()).Foo(); // B 

यहाँ सबसे राक्षसी बात यह है कि एक बेस क्लास के लिए कास्टिंग के माध्यम से एक विधि को कॉल करने और एक बेस क्लास को कास्टिंग के माध्यम से एक विधि को कॉल करने और फिर इंटरफ़ेस के बीच का अंतर है। क्योंकि विधि एक आभासी विधि के रूप में व्यवहार करेगी, एक मामले के अपवाद के साथ - एक बेस क्लास के लिए कास्टिंग।

चलो इंटरफेस के बिना इसका अनुकरण करने की कोशिश करते हैं। मान लें कि इंटरफ़ेस हमेशा पदानुक्रम में प्रथम श्रेणी पद्धति को कॉल करेगा।

 class IFoo { public void Foo() { System.Console.WriteLine("A (I)"); } } class FooA : IFoo { public void Foo() { System.Console.WriteLine("A"); } } class FooB : FooA { public void Foo() { System.Console.WriteLine("B"); } } 

काश, उपद्रव - व्यवहार पूरी तरह से वह नहीं है जो हम चाहते हैं।

 new FooA().Foo(); // A new FooB().Foo(); // B ((IFoo) new FooA()).Foo(); // A (I) ((IFoo) new FooB()).Foo(); // A (I) ((FooA) new FooB()).Foo(); // A ((IFoo)(FooA) new FooB()).Foo(); // A (I) 

यदि वह पदानुक्रम में अंतिम विधि कहता है, तो व्यवहार भी इंटरफ़ेस से हमारे पास बहुत भिन्न है।

कोई भी तर्क सिर्फ इस तरह के व्यवहार को समझ नहीं सकता है। उस अनुच्छेद 3 को छोड़कर, संशोधन 4 के 2005 मानक के खंड 2 के भाग 3 के अध्याय 1 के पैरा 1 के उपखंड 14 को चौथे महीने के तीसरे सप्ताह में 2 बैठक के 1 पढ़ने पर अपनाया गया।

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