लोड हो रहा है...

मेथड्स

एक मेथड नाम ring लिखें जो एक शब्द लिखे: ding. उन लेखन पंक्तियों को खाली कोष्ठक वाले static void ring() के नीचे रखें. Main के अंदर केवल ring(); लिखें — नाम, फिर खाली कोष्ठक, फिर अर्धविराम. प्रोग्राम चलाएँ. स्क्रीन को एक पंक्ति दिखानी चाहिए: ding. Main ding के लिए WriteLine नहीं रखता. मेथड रखता है. यही विभाजन इस पृष्ठ का पाठ है. सार्वजनिक कक्षा का नाम Pine रखें.

वे पंक्तियाँ जो ring के नीचे रहती हैं

अब तक आपका ज़्यादातर लेखन काम सीधे Main के अंदर था. वह अब भी काम करता है. एक मेथड उन्हीं पंक्तियों को अपना नाम देता है. आप पंक्तियाँ एक बार उस नाम के नीचे लिखते हैं. फिर Main नाम को कॉल के रूप में लिखकर उन्हें माँगता है.
Pine फाइल खोलें. कक्षा का नाम Pine रहता है. यह पृष्ठ प्रकार का नाम नहीं बदलता. अगर अभी भी plants या slots घूमने वाला foreach हो तो हटाएँ. अगर अभी भी break या continue वाला गिना हुआ for हो तो हटाएँ. कोई भी ReadLine पंक्ति भी हटाएँ. जो फाइल आप रखते हैं उसमें टाइप की प्रतीक्षा नहीं और Main में बचा लूप डेमो नहीं.
Main के बाहर, फिर भी कक्षा की ब्रेसेस के अंदर, आप static void ring() लिखेंगे जिसकी बॉडी Console.WriteLine("ding"); चलाती है. पूरा प्रोग्राम अगले बॉक्स में है ताकि साफ़ कॉपी कर सकें.
शब्द static इस शुरुआती आकार पर रहता है ताकि Main बिना ऑब्जेक्ट बनाए ring कॉल कर सके. शब्द void का अर्थ है यह मेथड कॉलर को कोई मान वापस नहीं देता — केवल बॉडी चलाता है. नाम ring वह लेबल है जो आप Main में टाइप करेंगे. खाली कोष्ठक () का अर्थ है इस पृष्ठ का मेथड कोई मान अंदर नहीं लेता. ब्रेसेस बॉडी रखती हैं. चलाने से पहले फाइल सहेजें.

वह फाइल जो आप रखते हैं

इस पृष्ठ का पूरा छोटा प्रोग्राम यहाँ है. Main केवल कॉल रखता है. ring लेखन पंक्ति रखता है. इस रखी फाइल में कोई अनुक्रमणिका काउंटर और कोई ऐरे घूमना नहीं है.

ring writes ding

csharp

using System;

public class Pine
{
    public static void Main()
    {
        ring();
    }

    static void ring()
    {
        Console.WriteLine("ding");
    }
}

ऊपर से पढ़ें. using System; छोटे नाम तैयार करता है. public class Pine प्रकार का नाम रखता है. public static void Main() वह जगह है जहाँ रनटाइम शुरू होता है. Main में एकमात्र कथन ring(); है. Main के नीचे, फिर भी कक्षा के अंदर, static void ring() Console.WriteLine("ding"); रखता है. स्क्रीन पर एक पंक्ति: ding.

dotnet run से चलाएँ. प्रोग्राम एक पंक्ति लिखता है और रुकता है. वह आपके टाइप की प्रतीक्षा नहीं करता. अगर dotnet run प्रतीक्षा करे, तो ReadLine अभी भी फाइल में है. उस पंक्ति को हटाएँ और Main में ring(); तथा ऊपर वाला ring मेथड रखें. स्क्रीन ding दिखाती है. अगर स्क्रीन leaf और mint दिखाए, तो बचा हुआ foreach अभी भी लिख रहा है. अगर स्क्रीन अक्षर ring दिखाए, तो लेखन पंक्ति में उस शब्द के चारों ओर उद्धरण हैं: Console.WriteLine("ring");. गलत पंक्ति दिखाने वाली स्क्रीन के लिए आप .NET SDK दोबारा इंस्टॉल नहीं करते.

एक पूरा रन क्रम से चलाएँ. C# Main से शुरू होता है. Main में एकमात्र कथन ring(); है. वह कॉल ring मेथड में कूदता है. ring के अंदर WriteLine ding लिखता है. फिर ring खत्म होता है, और Main में कुछ नहीं बचता, इसलिए प्रोग्राम समाप्त होता है. आपने इस पृष्ठ पर Console.WriteLine("ding"); को Main के अंदर नहीं रखा. आपने इसे ring के नीचे रखा और नाम से माँगा. अगर स्क्रीन ding दिखाए, कॉल बॉडी तक पहुँचा. अगर साफ़ बिल्ड के बाद स्क्रीन खाली रहे, तो Main ने कभी ring कॉल नहीं किया.
ring को लेखन पंक्तियों की लेबल वाली शेल्फ समझें. Main को वे पंक्तियाँ दोहराने की ज़रूरत नहीं. उसे केवल शेल्फ का नाम कॉल के रूप में लिखना है. इसलिए छोटा Main भी साफ़ स्क्रीन पंक्ति दे सकता है: काम मेथड नाम के नीचे रहता है, और कॉल अनुरोध है. जब यह पैटर्न स्पष्ट हो जाए, तो एक और कॉल जोड़ना उसी लेखन शेल्फ से एक और अनुरोध मात्र है.

Main से ring को एक से अधिक बार कॉल करें

केवल Main बदलें ताकि वह वही मेथड दो बार कॉल करे. स्वयं ring मेथड को अकेला छोड़ दें. बॉडी अभी भी प्रति कॉल एक बार ding लिखती है.

ring called twice

csharp

using System;

public class Pine
{
    public static void Main()
    {
        ring();
        ring();
    }

    static void ring()
    {
        Console.WriteLine("ding");
    }
}

यह दूसरी फाइल है. यह एक-कॉल आकार के लिए रखी फाइल नहीं है, पर यही मेथड सिखाती है. dotnet run चलाएँ. स्क्रीन को दो पंक्तियाँ दिखानी चाहिए, प्रत्येक ding कहती हुई. पहली कॉल बॉडी एक बार चलाती है. दूसरी कॉल वही बॉडी फिर चलाती है. यही पुन: उपयोग नाम रखने का कारण है. आपने WriteLine को ring के नीचे दूसरी बार कॉपी नहीं किया. आपने Main में दूसरी कॉल लिखी.
अगर आप केवल एक ring(); छोड़ते हैं, स्क्रीन फिर एक ding पर लौटती है. मेथड परिभाषा स्वयं नहीं लिखती. केवल Main से कॉल बॉडी चलाती है. जो फाइल ring परिभाषित करती है पर कभी कॉल नहीं करती, वह बिल्ड हो सकती है और चलाने पर फिर भी खाली स्क्रीन दिखा सकती है. दो पंक्तियाँ देखने के बाद, अगर वह आकार सहेजना हो तो रखी एक-कॉल फाइल वापस रखें: Main में एक ring();.

मेथड हेडर के टुकड़े

इस पृष्ठ पर हेडर static void ring() है. बाएँ से दाएँ पढ़ें. static इस शुरुआती आकार पर Main को मेथड कॉल करने देता है. void का अर्थ है कॉल से कोई मान वापस नहीं आता. ring नाम है. () जानबूझकर खाली हैं: यह सत्र मेथड में शब्द या संख्या नहीं भेजता. अगला पृष्ठ, parameters, उन कोष्ठकों के अंदर नाम रखता है. उसके बाद का पृष्ठ, return, जब आपको मान वापस चाहिए तो void बदलता है. दोनों बाद के लिए रखें. आज खाली () और void पर्याप्त हैं.

📊 Header piece on this page

Piece	On this page
`static`	`Main` can call `ring` without an object
`void`	`ring` does not hand a value back
`ring`	the name you type in the call
`()`	no values go in on this page
`{ ... }`	the body that writes `ding`

Main में कॉल नाम से ठीक मेल खानी चाहिए: ring(); छोटे r के साथ, खाली कोष्ठक, और अर्धविराम. बड़े R वाला Ring(); C# के लिए अलग नाम है. बिना () के ring लिखना इस आकार पर कॉल नहीं है. Console.WriteLine("ring"); शब्द ring के चार अक्षर लिखता है; यह मेथड बॉडी नहीं चलाता. जब स्क्रीन पर ding चाहिए तो कॉल ring(); ही रखें.

एक आम बचाव पुराना foreach plants घूमना है जो नए कॉल के साथ अभी भी Main में बैठा है. तब स्क्रीन leaf और mint, या 2, 4, और 6 दिखा सकती है ding की जगह — या दोनों तरह की पंक्तियाँ मिली-जुली. Main को इस पाठ की ज़रूरत वाले ring(); कॉल तक साफ़ करें. एक और गलती मेथड को Main की ब्रेसेस के अंदर रखना है. इस पृष्ठ की मेथड कक्षा के अंदर, Main के बगल में बैठती हैं, Main के अंदर नहीं.

पिछले पृष्ठ का foreach ऐरे में पहले से रखे मान घूमता था. यह पृष्ठ ऐरे नहीं घूमता. यह एक void मेथड नाम रखता है और उसे कॉल करता है. उसी Main में foreach (string plant in plants) न छोड़ें और हैरान न हों कि स्क्रीन ding की जगह leaf क्यों दिखाती है. इस सत्र का रखा Main केवल ring(); कॉल रखे. मेथड बॉडी ding की लेखन पंक्ति रखती है.

अब आप static void ring() लिख सकते हैं, उसकी ब्रेसेस में WriteLine रख सकते हैं, और Main से ring() कॉल कर सकते हैं ताकि स्क्रीन ding दिखाए. दो बार कॉल करने से बिना बॉडी कॉपी किए दो बार ding लिखा जाता है. खाली कोष्ठक और void जानबूझकर इसी पृष्ठ पर रहते हैं. अगला पृष्ठ parameters है, जहाँ कोष्ठकों के अंदर नाम आते हैं ताकि मेथड वे मान उपयोग कर सके जो आप Main से भेजते हैं.

स्क्रीन मेथड बॉडी है

जो फाइल आप रखते हैं वह एक बार ding लिखती है जब Main में एक कॉल हो. नाम ring कॉल में है, और अक्षर ring स्क्रीन पर छपा शब्द नहीं होते जब तक आपने उन्हें उद्धरण में न रखा हो. खाली () हेडर और कॉल दोनों पर बैठते हैं. ring को Main के अंदर रखना वह आकार नहीं है जो यह पाठ बनाता है.

🧠 अपने ज्ञान की परीक्षा करें

शुरू करने के लिए तैयार

अपने ज्ञान की परीक्षा करें

इस इंटरैक्टिव क्विज़ के साथ अपनी चुनौती लें और देखें कि आप विषय को कितनी अच्छी तरह समझते हैं

❓

प्रश्न

🎯

70%

पास करने के लिए

♾️

∞

समय

🔄

∞

प्रयास

📝 निर्देश

हर प्रश्न को ध्यान से पढ़ें
हर प्रश्न के लिए सबसे अच्छा उत्तर चुनें
आप जितनी बार चाहें क्विज़ दोबारा दे सकते हैं
आपकी प्रगति शीर्ष पर दिखाई जाएगी