C# अकादमी · पाठ

क्लोज़र और कैप्चर किए गए वैरिएबल

देखें कि स्थानीय फ़ंक्शन स्थिति को कैसे कैप्चर करते हैं।

पाठ 2, कुल 4 में से13 चरण

क्लोज़र और कैप्चर किए गए वैरिएबल, CoddyKit पर C# अकादमी का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह C# अकादमी सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। C# अकादमी पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

स्थानीय स्थिति पर क्लोज़र

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

चर कैप्चर करना

स्थानीय फ़ंक्शन समाविष्ट विधि से सीधे factor का उपयोग करता है। यह इसे पैरामीटर के रूप में प्राप्त नहीं करता; बल्कि आसपास के दायरे से कैप्चर करता है।

using System;

public class Program
{
    public static void Main()
    {
        int factor = 3;
        int Scale(int n) => n * factor; // captures factor

        Console.WriteLine(Scale(5));
        Console.WriteLine(Scale(10));
    }
}

कैप्चर किए गए चर जीवंत संदर्भ होते हैं

क्लोज़र चर के मान की स्थिर प्रति नहीं, बल्कि स्वयं चर को कैप्चर करता है। फ़ंक्शन परिभाषित होने के बाद यदि चर बदलता है, तो फ़ंक्शन को नया मान दिखाई देता है।

using System;

public class Program
{
    public static void Main()
    {
        int offset = 10;
        int Add(int n) => n + offset;

        Console.WriteLine(Add(1)); // 11
        offset = 100;
        Console.WriteLine(Add(1)); // 101 - sees updated offset
    }
}

कैप्चर किए गए चरों को बदलना

क्लोज़र कैप्चर किए गए चर में लिख सकता है और यह बदलाव समाविष्ट विधि में भी दिखाई देता है। इससे क्लोज़र स्थिति को संचित करने के लिए उपयोगी बनते हैं।

using System;

public class Program
{
    public static void Main()
    {
        int count = 0;
        void Tick() => count++;

        Tick(); Tick(); Tick();
        Console.WriteLine(count); // 3
    }
}

क्लोज़र लौटाना

जब आप स्थानीय चरों को कैप्चर करने वाला लैम्ब्डा लौटाते हैं, तो वे चर विधि के समाप्त होने के बाद भी जीवित रहते हैं। कैप्चर की गई स्थिति तब तक रहती है, जब तक प्रतिनिधि रहता है।

using System;

public class Program
{
    static Func<int> MakeCounter()
    {
        int count = 0;
        return () => ++count; // captures count
    }

    public static void Main()
    {
        var next = MakeCounter();
        Console.WriteLine(next());
        Console.WriteLine(next());
        Console.WriteLine(next());
    }
}

स्वतंत्र क्लोज़र

फ़ैक्टरी को किया गया प्रत्येक कॉल कैप्चर किए गए चरों का नया समूह बनाता है। इस तरह बनाए गए दो काउंटर एक-दूसरे को प्रभावित नहीं करते।

using System;

public class Program
{
    static Func<int> MakeCounter()
    {
        int count = 0;
        return () => ++count;
    }

    public static void Main()
    {
        var a = MakeCounter();
        var b = MakeCounter();
        Console.WriteLine(a()); // 1
        Console.WriteLine(a()); // 2
        Console.WriteLine(b()); // 1 - separate state
    }
}

foreach कैप्चर सुधार

आधुनिक C# में foreach लूप का चर हर पुनरावृत्ति में नया होता है, इसलिए क्लोज़र अपेक्षित मान को कैप्चर करते हैं। नीचे दिया गया हर लैम्ब्डा अपना अलग आइटम याद रखता है।

using System;
using System.Collections.Generic;

public class Program
{
    public static void Main()
    {
        var actions = new List<Action>();
        foreach (var i in new[] { 1, 2, 3 })
            actions.Add(() => Console.WriteLine(i));

        foreach (var act in actions) act(); // prints 1, 2, 3
    }
}

for लूप में कैप्चर करना

एक सामान्य समस्या यह है कि एकल for लूप चर सभी पुनरावृत्तियों में साझा होता है, इसलिए सभी क्लोज़र उसका अंतिम मान देखते हैं। अलग-अलग मान कैप्चर करने के लिए उसकी प्रति हर पुनरावृत्ति के स्थानीय चर में रखें।

using System;
using System.Collections.Generic;

public class Program
{
    public static void Main()
    {
        var actions = new List<Action>();
        for (int i = 0; i < 3; i++)
        {
            int copy = i; // fresh local each iteration
            actions.Add(() => Console.WriteLine(copy));
        }
        foreach (var act in actions) act(); // prints 0, 1, 2
    }
}

क्लोज़र मान से नहीं, संदर्भ से कैप्चर करते हैं

कैप्चर संदर्भ के माध्यम से होता है, इसलिए कैप्चर करने के बाद मूल मान में किया गया बदलाव क्लोज़र को दिखाई देता है। पढ़ने और लिखने का समय महत्वपूर्ण हो तो इसे याद रखें।

using System;

public class Program
{
    public static void Main()
    {
        string message = "first";
        Action print = () => Console.WriteLine(message);

        print();          // first
        message = "second";
        print();          // second
    }
}

व्यावहारिक उपयोग: विन्यास योग्य व्यवहार

क्लोज़र आपको संदर्भ के साथ पहले से तैयार छोटे फ़ंक्शन बनाने देते हैं। यहाँ छूट वाला फ़ंक्शन एक दर को कैप्चर करके पुनः उपयोग योग्य, विन्यासित गणक बनाता है।

using System;

public class Program
{
    static Func<double, double> MakeDiscount(double rate)
        => price => price * (1 - rate);

    public static void Main()
    {
        var tenOff = MakeDiscount(0.10);
        var halfOff = MakeDiscount(0.50);
        Console.WriteLine(tenOff(100));
        Console.WriteLine(halfOff(100));
    }
}

स्वयं करके देखें

ऐसी काउंटर फ़ैक्टरी बनाएँ जिसका लौटाया गया क्लोज़र निजी स्थिति को जीवित रखे, फिर उससे दो स्वतंत्र काउंटर बनाएँ।

using System;

public class Program
{
    static Func<int> MakeStepper(int step)
    {
        int current = 0;
        return () => { current += step; return current; }; // captures current and step
    }

    public static void Main()
    {
        var byTwos = MakeStepper(2);
        var byTens = MakeStepper(10);
        Console.WriteLine(byTwos()); // 2
        Console.WriteLine(byTwos()); // 4
        Console.WriteLine(byTens()); // 10 - separate state
    }
}

त्वरित जाँच

समझें कि कैप्चर कैसे काम करता है।

पुनरावलोकन

क्लोज़र समाविष्ट चरों को संदर्भ के माध्यम से कैप्चर करते हैं।

  • फ़ंक्शन को चर का वर्तमान मान दिखाई देता है, जिसमें बाद में हुए बदलाव भी शामिल हैं।
  • यह कैप्चर किए गए चरों को बदल सकता है और विधि के साथ स्थिति साझा कर सकता है।
  • लौटाए गए क्लोज़र अपने कैप्चर किए गए चरों को जीवित रखते हैं।
  • for लूप में अलग-अलग मान कैप्चर करने के लिए हर पुनरावृत्ति में स्थानीय चर का उपयोग करें।
शुरुआत निःशुल्क

एआई शिक्षक के साथ C# सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम
93
पाठ
346

अक्सर पूछे जाने वाले प्रश्न

क्या “क्लोज़र और कैप्चर किए गए वैरिएबल” पाठ निःशुल्क है?

हाँ—“क्लोज़र और कैप्चर किए गए वैरिएबल” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और C# अकादमी पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। C# अकादमी पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“क्लोज़र और कैप्चर किए गए वैरिएबल” में मैं क्या सीखूँगा?

देखें कि स्थानीय फ़ंक्शन स्थिति को कैसे कैप्चर करते हैं। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ C# अकादमी का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या C# अकादमी शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर C# अकादमी शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।

“क्लोज़र और कैप्चर किए गए वैरिएबल” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस C# अकादमी पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर C# अकादमी पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

  1. स्थानीय फ़ंक्शन घोषित करना
  2. क्लोज़र और कैप्चर किए गए वैरिएबल
  3. स्टैटिक स्थानीय फ़ंक्शन
  4. स्थानीय फ़ंक्शन बनाम लैम्ब्डा
← C# अकादमी पर वापस जाएँ