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

रिटर्न वैल्यू

एक मेथड नाम twice लिखें जो int नाम n ले और उस संख्या का दोगुना लौटाए. हेडर int से शुरू होता है, void से नहीं: static int twice(int n). ब्रेसेस के अंदर लिखें return n * 2;. Main में कॉल का परिणाम लिखें: Console.WriteLine(twice(7));. स्क्रीन को एक पंक्ति दिखानी चाहिए: 14. स्वयं twice WriteLine नहीं बुलाता. वह केवल 14 लौटाता है. Main वह संख्या लिखता है. यही लौटाना इस पृष्ठ का पाठ है. सार्वजनिक कक्षा का नाम Pine रखें.

Main को एक संख्या लौटाएँ

पैरामीटर पृष्ठ पर greet और show मेथड बॉडी के अंदर लिखते थे. कॉल मान अंदर भेजता था, और मेथड स्क्रीन पर लिखता था. यहाँ मेथड अभी भी मान लेता है, लेकिन बाहर भी एक मान भेजता है. शब्द return उस बाहर जाने वाले मान को चिह्नित करता है. Main उसे संजो सकता है या लिख सकता है.
Pine फाइल खोलें. कक्षा का नाम Pine रहता है. यह पृष्ठ प्रकार का नाम नहीं बदलता. अगर अभी भी वह greet डेमो है जो केवल मेथड के अंदर hi lena लिखता है और Main में बस वही है, तो उसे हटाएँ. कोई भी बचा ring(); हटाएँ. कोई भी ReadLine पंक्ति हटाएँ. जो फाइल आप रखते हैं उसमें टाइप की प्रतीक्षा नहीं है.
Main के बाहर, फिर भी कक्षा की ब्रेसेस के अंदर, हेडर int कहता है क्योंकि जो मान वापस आता है वह int है. कोष्ठक के बीच int n अभी भी पैरामीटर है — पिछले पृष्ठ जैसा ही विचार. बॉडी में एक निर्देश है: return n * 2;. वह n को 2 से गुणा करता है और गुणनफल उसे लौटाता है जिसने twice बुलाया. इस पृष्ठ पर twice के अंदर कोई Console.WriteLine नहीं है. चलाने से पहले फाइल सहेजें. पहला पूरा प्रोग्राम अगले बॉक्स में है.

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

यह छोटा पूरा प्रोग्राम है. twice गणना करता है. Main लिखता है.

twice returns n times 2

csharp

using System;

public class Pine
{
    public static void Main()
    {
        Console.WriteLine(twice(7));
    }

    static int twice(int n)
    {
        return n * 2;
    }
}

ऊपर से पढ़ें. using System; छोटे नाम तैयार करता है. public class Pine प्रकार का नाम रखता है. public static void Main() वह जगह है जहाँ रनटाइम शुरू होता है. कॉल twice(7) मान 7 को n में भेजता है. static int twice(int n) रखता है return n * 2;. Console.WriteLine वह मान लिखता है जो वापस आया. स्क्रीन पर एक पंक्ति: 14.

dotnet run से चलाएँ. प्रोग्राम एक पंक्ति लिखता है और रुक जाता है. वह आपके टाइप की प्रतीक्षा नहीं करता. अगर dotnet run प्रतीक्षा करे तो फाइल में अभी भी ReadLine है. वह पंक्ति हटाएँ और Console.WriteLine(twice(7)); तथा ऊपर का twice मेथड रखें. स्क्रीन 14 दिखाती है. अगर स्क्रीन hi lena दिखाए तो बचा greet कॉल अभी भी चल रहा है. अगर स्क्रीन अक्षर twice दिखाए तो किसी लेखन पंक्ति में उस शब्द पर उद्धरण हैं: Console.WriteLine("twice");. गलत पंक्ति दिखाने वाली स्क्रीन के लिए आप .NET SDK फिर से इंस्टॉल नहीं करते.

एक पूरा रन क्रम से चलाएँ. C# Main से शुरू होता है. कॉल twice(7) मान 7 को n में भेजता है. twice के अंदर return n * 2; गणना करता है 14 और वह 14 Main को लौटाता है. फिर WriteLine लिखता है 14. twice ने अकेले स्क्रीन पर कभी नहीं लिखा. अगर आप कॉल को twice(3) कर दें तो स्क्रीन को 6 दिखाना चाहिए. मेथड बॉडी वही रहती है; केवल आर्गुमेंट बदलता है, और लौटाया गया गुणनफल उसके साथ बदलता है. अगर स्क्रीन 14 के बजाय 7 दिखाए तो आपने twice के अंदर n लिखा या Main में आर्गुमेंट बिना twice बुलाए लिखा — दोगुना return पंक्ति पर रखें और कॉल का परिणाम लिखें.
महत्वपूर्ण विभाजन यह है कि स्क्रीन से कौन बात करता है. इस पृष्ठ पर twice केवल return के ज़रिए Main से बात करता है. Main WriteLine के ज़रिए स्क्रीन से बात करता है. इसलिए हेडर अब void नहीं कह सकता: Main के लिखने के लिए कुछ वापस आना चाहिए. जब आप पहले परिणाम को result में संजोते हैं, आप अभी भी वही लौटाना इस्तेमाल कर रहे हैं; आप केवल लेखन को एक पंक्ति विलंबित करते हैं.

वह मान लिखें जो Main को मिला

आप लौटाए गए मान को लिखने से पहले Main के अंदर एक नाम में भी रख सकते हैं. अगर अलग स्क्रीन पंक्ति चाहिए तो केवल कॉल में संख्या बदलें. return n * 2; को अकेला छोड़ें.

store the returned value

csharp

using System;

public class Pine
{
    public static void Main()
    {
        int result = twice(7);
        Console.WriteLine(result);
    }

    static int twice(int n)
    {
        return n * 2;
    }
}

यह दूसरी फाइल है. यह वही return संजोए नाम के साथ सिखाती है. dotnet run चलाएँ. वह अभी भी एक पंक्ति दिखाता है: 14. कॉल पहले पूरा होता है और result भरता है. फिर WriteLine result लिखता है. दोनों आकार — कॉल सीधे लिखना, या संजोकर फिर लिखना — twice का वही return इस्तेमाल करते हैं. twice(0) को 0 लिखना चाहिए. twice(10) को 20 लिखना चाहिए. हर बार Main वही लिखता है जो twice ने लौटाया. संजोया आकार देखने के बाद, अगर सहेजने वाला आकार एक-पंक्ति कॉल है तो रखी फाइल वापस रखें: Main में Console.WriteLine(twice(7));.
अगर twice हेडर में अभी भी void कहे जबकि बॉडी में return n * 2; हो, बिल्ड एक त्रुटि लिखता है — void का अर्थ है कुछ वापस नहीं आता, इसलिए मान वाला return फिट नहीं बैठता. अगर हेडर int कहे लेकिन बॉडी में return न हो, बिल्ड भी त्रुटि लिखता है — इस शुरुआती आकार पर int मेथड को एक int लौटाना चाहिए. अगर बॉडी लिखे और कभी न लौटाए, आप पैरामीटर पृष्ठ के विचार पर वापस हैं; यह पृष्ठ संख्या Main के हाथों में चाहता है.

void बनाम टाइप वाला return

दोनों आकार साथ पढ़ें. एक void मेथड अपनी बॉडी चलाता है और खत्म होता है. टाइप वाले return वाली मेथड को return से एक मान लौटाना चाहिए. जब रिटर्न प्रकार void नहीं होता तो Main कॉल को उसी मान की तरह मानता है.

📊 void body versus return

Shape	What the method does	What Main often does
`void show(int n)`	writes inside the body	calls `show(9);` and may write nothing else
`int twice(int n)`	`return n * 2;`	writes or stores `twice(7)`

एक आम गड़बड़ है twice के अंदर Console.WriteLine(n * 2); रखना और हेडर को बिना return के int छोड़ना. तब बिल्ड शिकायत करता है, या आप हेडर वापस void कर देते हैं और कॉल से Main के लिखने के लिए मान नहीं बचता. दूसरी गड़बड़ है हेडर int कहते हुए बिना मान के return; लिखना. return n * 2; रखें ताकि लौटाई गई अभिव्यक्ति का प्रकार int से मेल खाए. Main में Console.WriteLine("twice"); लिखना शब्द twice लिखता है; वह मेथड नहीं बुलाता. जब स्क्रीन पर 14 चाहिए तो Console.WriteLine(twice(7)) रखें.

एक बचा greet डेमो जो केवल मेथड के अंदर hi lena लिखता है उसी फाइल में रह सकता है और स्क्रीन भ्रमित कर सकता है. Main को उस WriteLine तक साफ़ करें जो twice इस्तेमाल करता है, और एक लौटाने वाला मेथड रखें. twice को Main की ब्रेसेस के अंदर न घुसाएँ. मेथड कक्षा के अंदर, Main के पास बैठते हैं.

आप static int twice(int n) लिख सकते हैं, गणना किया मान लौटा सकते हैं, और वह मान Main से लिख सकते हैं. स्क्रीन वह संख्या दिखाती है जो Main को मिली, वह पंक्ति नहीं जो मेथड ने अकेले लिखी. जब आपको मान वापस चाहिए तो void गलत हेडर है. अगला पृष्ठ overloading है, जहाँ एक से अधिक मेथड एक नाम साझा कर सकते हैं जब उनकी पैरामीटर सूचियाँ अलग हों.

स्क्रीन वही रखती है जो Main को मिला

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

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

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

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

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

❓

प्रश्न

🎯

70%

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

♾️

∞

समय

🔄

∞

प्रयास

📝 निर्देश

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