👼 🧟 🥙 मनोरंजक # सी। कॉफी के पांच उदाहरण टूटते हैं 🌔 👩‍✈️ 👨🏿‍🤝‍👨🏾

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

दूसरी ओर, हम अनुभवी सहयोगियों की टिप्पणियों को सुनकर खुश होंगे जो या तो हमारे उदाहरणों में खामियों को इंगित करेंगे, या अपने स्वयं के साझा करेंगे। वे साक्षात्कार में ऐसे प्रश्नों का उपयोग करना पसंद करते हैं, इसलिए निश्चित रूप से हम सभी को कुछ बताना होगा।

हमें उम्मीद है कि हमारा चयन आपके लिए उपयोगी होगा, अपने ज्ञान को ताज़ा करने में मदद करेगा या बस मुस्कुराएगा।

उदाहरण 1

सी # में संरचनाएं। उनके साथ, यहां तक कि अनुभवी डेवलपर्स के पास अक्सर सवाल होते हैं, जो कि अक्सर सभी प्रकार के ऑनलाइन परीक्षणों द्वारा उपयोग किया जाता है।

हमारा पहला उदाहरण माइंडफुलनेस और ज्ञान का एक उदाहरण है जिसका उपयोग करके ब्लॉक का विस्तार होता है। और साक्षात्कार के दौरान संचार के लिए भी काफी विषय है।

कोड पर विचार करें:

public struct SDummy : IDisposable { private bool _dispose; public void Dispose() { _dispose = true; } public bool GetDispose() { return _dispose; } static void Main(string[] args) { var d = new SDummy(); using (d) { Console.WriteLine(d.GetDispose()); } Console.WriteLine(d.GetDispose()); } }

मुख्य विधि कंसोल पर क्या प्रिंट करेगी?

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

C # भाषा विनिर्देश के अनुसार , संकलन समय पर महत्वपूर्ण प्रकारों के लिए स्टेटमेंट का उपयोग करना एक अंतत: ब्लॉक में फैलता है:

  try { Console.WriteLine(d.GetDispose()); } finally { ((IDisposable)d).Dispose(); }

तो, हमारे कोड में, GetDispose () विधि का उपयोग करते हुए ब्लॉक के अंदर कहा जाता है, जो बूलियन फ़ील्ड को वापस लौटाता है। डिफ़ॉल्ट गलत है। आगे क्या है?

और फिर सबसे दिलचस्प।
आखिरकार ब्लॉक में एक लाइन चल रही है

  ((IDisposable)d).Dispose();

आम तौर पर मुक्केबाजी की ओर जाता है। यह देखना मुश्किल नहीं है, उदाहरण के लिए, यहां (परिणामों में शीर्ष दाईं ओर, पहले C # का चयन करें, और फिर IL):

इस स्थिति में, डिस्पोज़ विधि पहले से ही किसी अन्य ऑब्जेक्ट के लिए कहा जाता है, और डी ऑब्जेक्ट के लिए बिल्कुल भी नहीं।
हमारे कार्यक्रम को चलाएं और देखें कि कार्यक्रम वास्तव में कंसोल पर "गलत झूठी" प्रदर्शित करता है। लेकिन क्या यह इतना आसान है? :)

वास्तव में, कोई पैकिंग नहीं है। एरिक लिपर्ट के अनुसार, अनुकूलन के लिए क्या किया जाता है ( यहां और यहां देखें)।
लेकिन, अगर कोई पैकेजिंग नहीं है (जो अपने आप में आश्चर्यजनक लग सकता है), स्क्रीन पर "गलत झूठी" और "गलत सत्य" क्यों नहीं है, क्योंकि डिस्पोज़ को अब एक ही वस्तु पर लागू किया जाना चाहिए?

और यहाँ ऐसा नहीं है!
सी # संकलक हमारे कार्यक्रम में विस्तार करता है:

 public struct SDummy : IDisposable { private bool _dispose; public void Dispose() { _dispose = true; } public bool GetDispose() { return _dispose; } private static void Main(string[] args) { SDummy sDummy = default(SDummy); SDummy sDummy2 = sDummy; try { Console.WriteLine(sDummy.GetDispose()); } finally { ((IDisposable)sDummy2).Dispose(); } Console.WriteLine(sDummy.GetDispose()); } }

एक नया चर sDummy2 है, जिसमें डिस्पोज़ () पद्धति लागू है!
यह छिपा हुआ चर कहाँ से आया?
चलिए फिर से कल्पना की ओर मुड़ते हैं:

'स्टेटमेंट (एक्सप्रेशन) स्टेटमेंट' के फॉर्म के उपयोग के तीन संभावित विस्तार समान हैं। इस स्थिति में रिसोर्स टाइप स्पष्ट रूप से संकलित समय-प्रकार की अभिव्यक्ति है ... 'संसाधन' वेरिएबल इन-लाइसेबल है, और इनबाउंड किए गए स्टेटमेंट के लिए अदृश्य है।

इस प्रकार sDummy वैरिएबल उपयोग करने वाले ब्लॉक के एम्बेडेड स्टेटमेंट के लिए अदृश्य और अप्राप्य है, और इस एक्सप्रेशन के अंदर सभी ऑपरेशन दूसरे sDummy2 वेरिएबल के साथ किए जाते हैं।

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

सामान्य निष्कर्ष यह है: उत्परिवर्तनीय मूल्य प्रकार बुराई है जो सबसे अच्छा बचा जाता है।

एक समान उदाहरण यहां माना जाता है । यदि विषय दिलचस्प है, तो हम अत्यधिक झांकने की सलाह देते हैं।

मैं इस उदाहरण पर मूल्यवान टिप्पणियों के लिए सर्गेईटी के लिए एक विशेष धन्यवाद कहना चाहूंगा।

उदाहरण 2

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

तो, MyLogger वर्ग पर विचार करें:

 class MyLogger { static MyLogger innerInstance = new MyLogger(); static MyLogger() { Console.WriteLine("Static Logger Constructor"); } private MyLogger() { Console.WriteLine("Instance Logger Constructor"); } public static MyLogger Instance { get { return innerInstance; } } }

मान लीजिए कि इस वर्ग के पास कुछ व्यावसायिक तर्क हैं जिन्हें हमें लॉगिंग का समर्थन करने की आवश्यकता है (कार्यक्षमता अभी महत्वपूर्ण नहीं है)।

आइए देखें कि हमारे MyLogger वर्ग में क्या है:

स्टेटिक कंस्ट्रक्टर निर्दिष्ट
मापदंडों के बिना एक निजी कंस्ट्रक्टर है
बंद स्थिर वैरिएबल इनरस्टेंस को परिभाषित किया गया है
और बाहरी दुनिया के साथ संवाद स्थापित करने के लिए इंस्टेंस की एक खुली स्थैतिक संपत्ति है

इस उदाहरण के विश्लेषण में आसानी के लिए, हमने क्लास के कंस्ट्रक्टर्स को सरल कंसोल आउटपुट जोड़ा।

वर्ग के बाहर (प्रतिबिंब जैसी चाल का उपयोग किए बिना) हम केवल सार्वजनिक स्टेटिक इंस्टेंस संपत्ति का उपयोग कर सकते हैं, जिसे हम इस तरह से कॉल कर सकते हैं:

 class Program { public static void Main() { var logger = MyLogger.Instance; } }

इस कार्यक्रम का उत्पादन क्या होगा?

हम सभी जानते हैं कि वर्ग के किसी भी सदस्य (स्थिरांक के अपवाद के साथ) तक पहुंचने से पहले एक स्थिर निर्माणकर्ता को बुलाया जाता है। इस स्थिति में, इसे केवल एक बार एप्लिकेशन डोमेन में लॉन्च किया जाता है।

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

स्टेटिक लॉगर कंस्ट्रक्टर
इंस्टेंस लकड़हारा कंस्ट्रक्टर

हालाँकि, प्रोग्राम शुरू करने के बाद, हम कंसोल पर आते हैं:

इंस्टेंस लकड़हारा कंस्ट्रक्टर
स्टेटिक लॉगर कंस्ट्रक्टर

ऐसा कैसे? इंस्टेंस कंस्ट्रक्टर ने स्टैटिक कंस्ट्रक्टर से पहले काम किया है?
उत्तर: हाँ!

और यहाँ क्यों है।

C # ECMA-334 मानक स्टेटिक क्लास के लिए निम्नलिखित बताता है:

17.4.5.1: "यदि एक स्थिर रचनाकार ()17.11) वर्ग में मौजूद है, तो स्थैतिक क्षेत्र के शुरुआती का निष्पादन उस स्थैतिक निर्माता को निष्पादित करने से तुरंत पहले होता है।
...
17.11: ... यदि किसी वर्ग में इनिशियलाइज़र वाले कोई स्टैटिक फ़ील्ड शामिल हैं, तो उन इनिशियलाइज़र को स्थिर कंस्ट्रक्टर को निष्पादित करने के तुरंत पहले पाठ्य क्रम में निष्पादित किया जाता है

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

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

ध्यान दें कि यह केवल स्थिर फ़ील्ड इनिशियलाइज़र के लिए सही है। सामान्य तौर पर, एक स्थिर निर्माणकर्ता को वर्ग उदाहरण के निर्माता को कॉल करने वाला BEFORE कहा जाता है।

उदाहरण के लिए, यहाँ:

 class MyLogger { static MyLogger() { Console.WriteLine("Static Logger Constructor"); } public MyLogger() { Console.WriteLine("Instance Logger Constructor"); } } class Program { public static void Main() { var logger = new MyLogger(); } }

और कार्यक्रम कंसोल के आउटपुट के लिए अपेक्षित है:

स्टेटिक लॉगर कंस्ट्रक्टर
इंस्टेंस लकड़हारा कंस्ट्रक्टर

उदाहरण 3

प्रोग्रामर को अक्सर अपने जीवन को आसान बनाने के लिए सहायक कार्यों (उपयोगिताओं, सहायकों, आदि) को लिखना पड़ता है। आमतौर पर, इस तरह के कार्य काफी सरल होते हैं और अक्सर कोड की केवल कुछ लाइनें लेते हैं। लेकिन आप नीले रंग से बाहर भी ठोकर खा सकते हैं।

मान लें कि हमें एक फ़ंक्शन को लागू करने की आवश्यकता है जो विषमता के लिए संख्या की जांच करता है (यानी कि संख्या शेष के बिना 2 से विभाज्य नहीं है)।

एक कार्यान्वयन इस तरह लग सकता है:

 static bool isOddNumber(int i) { return (i % 2 == 1); }

पहली नज़र में, सब कुछ ठीक है और, उदाहरण के लिए, 5.7 और 11 की संख्या के लिए, हमें उम्मीद है कि यह सच है।

IsOddNumber (-5) फ़ंक्शन क्या लौटाएगा?

-5 एक विषम संख्या है, लेकिन हमारे कार्य के उत्तर के रूप में हमें गलत मिलता है!
आइए जानें कि क्या कारण है।

MSDN के अनुसार, शेष% डिवीजन ऑपरेटर के बारे में निम्नलिखित लिखा है:
"पूर्णांक परिचालनों के लिए,% b का परिणाम - (a / b) * b" द्वारा उत्पादित मूल्य है।
हमारे मामले में, a = -5, b = 2 के लिए हम प्राप्त करते हैं:
-5% 2 = (-5) - ((-5) / 2) * 2 = -5 + 4 = -1
लेकिन -1 हमेशा 1 के बराबर नहीं होता है, जो हमारे परिणाम को गलत बताता है।

% ऑपरेटर ऑपरेंड के संकेत के प्रति संवेदनशील है। इसलिए, ऐसे "आश्चर्य" न प्राप्त करने के लिए, परिणाम की तुलना शून्य से करना बेहतर है, जिसमें कोई संकेत नहीं है:

 static bool isOddNumber(int i) { return (i % 2 != 0); }

या समता के लिए जाँच के लिए एक अलग फ़ंक्शन प्राप्त करें और इसके माध्यम से तर्क को लागू करें:

 static bool isEvenNumber(int i) { return (i % 2 == 0); } static bool isOddNumber(int i) { return !isEvenNumber(i); }

उदाहरण 4

C # में क्रमादेशित सभी लोग, शायद LINQ के साथ मिले, जो संग्रह के साथ काम करने के लिए सुविधाजनक है, प्रश्न बनाने, फ़िल्टर करने और उपयोगकर्ता को एकत्रित करने के लिए ...

हम LINQ के हुड के नीचे नहीं देखेंगे। शायद हम इसे दूसरी बार करेंगे।

इस बीच, एक छोटे से उदाहरण पर विचार करें:

 int[] dataArray = new int[] { 0, 1, 2, 3, 4, 5 }; int summResult = 0; var selectedData = dataArray.Select( x => { summResult += x; return x; }); Console.WriteLine(summResult);

यह कोड आउटपुट क्या होगा?

हम स्क्रीन पर वैरिएबल योग का मान प्राप्त करते हैं, जो प्रारंभिक मूल्य के बराबर है, अर्थात्। 0।

ऐसा क्यों हुआ?

और क्योंकि LINQ क्वेरी की परिभाषा और इस क्वेरी के लॉन्च दो ऑपरेशन हैं जो अलग-अलग किए जाते हैं। इस प्रकार, अनुरोध की परिभाषा का अर्थ इसके लॉन्च / निष्पादन से नहीं है।

SumResult चर का चयन विधि में एक अनाम प्रतिनिधि के अंदर किया जाता है: dataArray सरणी के तत्व क्रमिक रूप से सॉर्ट किए जाते हैं और sumResult चर में जोड़े जाते हैं।

हम मान सकते हैं कि हमारा कोड dataArray एरे के तत्वों का योग प्रिंट करेगा। लेकिन LINQ उस तरह से काम नहीं करता है।

चयनित डेटा चर पर विचार करें। Var कीवर्ड "सिन्टैक्टिक शुगर" है, जो कई मामलों में प्रोग्राम कोड के आकार को कम करता है और इसकी पठनीयता में सुधार करता है। और चयनित प्रकार चर का वास्तविक प्रकार IEnumerable इंटरफ़ेस को लागू करता है। यानी हमारा कोड इस तरह दिखता है:

  IEnumerable<int> selectedData = dataArray.Select( x => { summResult += x; return x; });

यहां हम क्वेरी (क्वेरी) को परिभाषित करते हैं, लेकिन क्वेरी स्वयं शुरू नहीं होती है। इसी तरह, आप SQL क्वेरी को स्ट्रिंग के रूप में निर्दिष्ट करके डेटाबेस के साथ काम कर सकते हैं, लेकिन परिणाम प्राप्त करने के लिए, डेटाबेस को देखें और इस क्वेरी को स्पष्ट रूप से चलाएं।

यही है, अब तक हमने केवल एक अनुरोध निर्धारित किया है, लेकिन इसे लॉन्च नहीं किया है। यही कारण है कि sumResult चर का मूल्य अपरिवर्तित रहता है। एक क्वेरी लॉन्च की जा सकती है, उदाहरण के लिए, ToArray, ToList या ToDictionary विधियों का उपयोग करके:

 int[] dataArray = new int[] { 0, 1, 2, 3, 4, 5 }; int summResult = 0; //        selectedData IEnumerable<int> selectedData = dataArray.Select( x => { summResult += x; return x; }); //   selectedData selectedData.ToArray(); //    summResult Console.WriteLine(summResult);

यह कोड पहले से ही वैरिएबल sumResult के मान को प्रदर्शित करेगा, डेटाअरे सरणी के सभी तत्वों के योग के बराबर, 15 के बराबर।

हमने इसका पता लगा लिया। और फिर यह कार्यक्रम स्क्रीन पर क्या प्रदर्शित करेगा?

 int[] dataArray = new int[] { 0, 1, 2, 3, 4, 5 }; //1 var summResult = dataArray.Sum() + dataArray.Skip(3).Take(2).Sum(); //2 var groupedData = dataArray.GroupBy(x => x).Select( //3 x => { summResult += x.Key; return x.Key; }); Console.WriteLine(summResult); //4

GroupedData चर (पंक्ति 3) वास्तव में IEnumerable इंटरफ़ेस को लागू करता है और अनिवार्य रूप से डेटाअरे डेटा स्रोत के लिए अनुरोध को परिभाषित करता है। इसका मतलब यह है कि काम करने के लिए एक अनाम प्रतिनिधि के लिए, जो सारांश संस्करण के मूल्य को बदलता है, यह अनुरोध स्पष्ट रूप से चलाया जाना चाहिए। लेकिन हमारे कार्यक्रम में ऐसा कोई लॉन्च नहीं है। इसलिए, sumResult चर का मूल्य केवल पंक्ति 2 में बदल दिया जाएगा, और हम अपनी गणना में बाकी सब पर विचार नहीं कर सकते।

फिर चर योग के मूल्य की गणना करना आसान है, जो क्रमशः 15 + 7 है, अर्थात। 22।

उदाहरण 5

हमें तुरंत बताएं - हम अकादमी में अपने व्याख्यान में इस उदाहरण पर विचार नहीं करते हैं, लेकिन कभी-कभी हम मजाक के रूप में कॉफी ब्रेक के दौरान इसकी चर्चा करते हैं।

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

तो कोड की एक पंक्ति है:

 int i = (int)+(char)-(int)+(long)-1;

चर i का मान क्या होगा?

उत्तर: १

आप सोच सकते हैं कि अंकगणितीय अंकगणित का उपयोग बाइट्स में प्रत्येक प्रकार के आकारों में किया जाता है, क्योंकि संकेत "+" और "-" टाइप रूपांतरण के लिए यहां अप्रत्याशित रूप से सामना किए जाते हैं।

C # में, पूर्णांक प्रकार को 4 बाइट्स लंबे, 8 लंबे, चार 2 के रूप में जाना जाता है।

फिर यह सोचना आसान है कि हमारी कोड ऑफ़ लाइन निम्नलिखित अंकगणितीय अभिव्यक्ति के बराबर होगी:

 int i = (4)+(2)-(4)+(8)-1;

हालाँकि, ऐसा नहीं है। और इस तरह के झूठे तर्क द्वारा भ्रमित करने और निर्देशित करने के लिए, उदाहरण को बदला जा सकता है, जैसे:

 int i = (int)+(char)-(int)+(long)-sizeof(int);

इस उदाहरण में "+" और "-" का उपयोग द्विआधारी अंकगणितीय कार्यों के रूप में नहीं, बल्कि एकरी संचालकों के रूप में किया जाता है। फिर हमारी लाइन ऑफ कोड, स्पष्ट प्रकार के रूपांतरणों का एक क्रम है, जो एकतरफा कार्रवाई के लिए कॉल के साथ मिलाया जाता है, जिसे निम्नानुसार लिखा जा सकता है:

  int i = (int)( // call explicit operator int(char), ie char to int +( // call unary operator + (char)( // call explicit operator char(int), ie int to char -( // call unary operator - (int)( // call explicit operator int(long), ie long to int +( // call unary operator + (long)( // call explicit operator long(int), ie int to long -1 ) ) ) ) ) ) );

Veeam अकादमी में सीखने के इच्छुक हैं?

अब सेंट पीटर्सबर्ग में सी # पर वसंत गहन के लिए एक सेट है, और हम सभी को वीम अकादमी अकादमी की वेबसाइट पर ऑनलाइन परीक्षण से गुजरने के लिए आमंत्रित करते हैं ।

यह कोर्स 18 फरवरी, 2019 को शुरू होता है, मई के मध्य तक चलता है और हमेशा की तरह, पूरी तरह से मुक्त होगा। जो कोई भी प्रवेश परीक्षा से गुजरना चाहता है, उसके लिए पंजीकरण अकादमी वेबसाइट: academy.veeam.ru पर पहले से ही उपलब्ध है