[C#] मुझे सी # में "ब्लॉकों का उपयोग करने" का उपयोग कब करना चाहिए?


Answers

कुछ ऑब्जेक्ट्स को उनके साथ समाप्त होने पर कुछ कार्रवाई करने की आवश्यकता होती है। आम तौर पर ऐसा इसलिए होता है क्योंकि ऑब्जेक्ट किसी तरह के संसाधनों का उपयोग करता है जिसे इसके निपटारे की आवश्यकता होती है। उदाहरण के लिए, यदि आपके पास क्लास फ़ाइल का एक फ़ाइल ऑब्जेक्ट है, और यह ऑब्जेक्ट फ़ाइल सिस्टम से फ़ाइल को खोलता है, फाइल सिस्टम में फ़ाइल को फिर से बंद करना होगा।

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

इस समस्या को हल करने के लिए, सी # में IDisposable अंतरफलक है यह एक तरीका है जिसे डिस्पोज़ नाम दिया गया है। ऐसे क्लासेस जिनके लिए कुछ क्लीन अप लागू करने की आवश्यकता होती है, इसे निपटाना विधि। संसाधनों का उपयोग करने वाले किसी भी ऑब्जेक्ट को साफ करने के लिए यह आपको एक मानक तरीका देती है। वहाँ बहुत सारे वर्ग हैं जिन्हें निपटाने के लिए कहा जाता है। इस के साथ समस्या यह है कि कोड को निपटाने के लिए कॉल के साथ कवर किया जाता है, और वे पालन करने के लिए मुश्किल हैं क्योंकि जिस स्थान पर आप नया ऑब्जेक्ट कर चुके हैं और इसे साफ़ करने के लिए कॉल करें अलग हैं तो, आपको कोड के आसपास बहुत कुछ देखना पड़ता था और यह देखने के लिए बहुत सावधान रहना था कि सही जगह पर निपटने के लिए कॉल किए गए थे।

इस समस्या को हल करने के लिए सी # ने 'का उपयोग' कीवर्ड शुरू किया। आप एक 'का उपयोग कर' कीवर्ड को एक नया ऑब्जेक्ट कहां रख सकते हैं, और यह सुनिश्चित करता है कि डिज़ॉज को आपके लिए बुलाया जाएगा। यह गारंटी देता है कि निपटान को जो कुछ भी कहा जाता है ... यहां तक ​​कि अगर उपयोग की गई कथन के शरीर में एक अपवाद डाला गया हो

इसलिए, आपको 'उपयोग' का उपयोग करना चाहिए, जब आप यह सुनिश्चित करना चाहते हैं कि संसाधनों का आवंटन एक वस्तु साफ हो जाएगी

का उपयोग केवल ऑब्जेक्ट के लिए किया जा सकता है जिसे स्टैक पर घोषित किया जाता है, अर्थात फ़ंक्शन में। यह ऐसे ऑब्जेक्ट्स के लिए काम नहीं करता है जिन्हें क्लास के सदस्यों के रूप में घोषित किया गया है। उनके लिए, आपको अपने आप को निपटाना होगा आपको अपने क्लास में डिस्पोज़ाइज़ करना पड़ सकता है जिससे कि किसी भी सदस्य ऑब्जेक्ट पर डिस्पोज्शन कर सकते हैं, जिसके पास इसकी आवश्यकता होती है।

सामान्य वस्तुएं जिन्हें उन पर कॉल किए जाने की आवश्यकता है: फ़ाइलें, डेटाबेस कनेक्शन, ग्राफिक्स ऑब्जेक्ट जैसे पेन और ब्रश।

कभी-कभी यह तब भी प्रयोग किया जाता है जब आप दो संचालन एक साथ होने चाहिए। उदाहरण के लिए यदि आप लॉग स्टेटमेंट लिखना चाहते हैं, जब कोड का एक ब्लॉक दर्ज किया जाता है और जब आप बाहर निकलते हैं तो आप उस लॉग क्लास को लिख सकते हैं जिसे आप इस तरह प्रयोग कर सकते हैं:

using( Log log = new Log("Doing stuff") )
{
    // Stuff
}

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

Question

इस सवाल का पहले से ही उत्तर दिया गया है:

क्या कोई विशेष उदाहरण हैं जहां मुझे "उपयोग" ब्लॉकों का प्रयोग करना चाहिए (या नहीं करना चाहिए):

using(SomeType t = new SomeType()){
    ...
}



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

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




मुझे बहुत सारे अन्य जवाब मिलते हैं जब आपको एक using कथन होना चाहिए । मुझे पता होना चाहिए जब विशेष रूप से using कथन नहीं होना चाहिए:

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

अब, आप यह भी सुनिश्चित करना चाहते हैं कि उन ऑब्जेक्ट्स का निपटारा किया गया है, इसलिए आप कहीं भी एक कथन using सकते हैं। बस उस विधि में शामिल न करें जहां ऑब्जेक्ट वास्तव में बनाया गया है। इसके बजाय, आप फ़ंक्शन को अपने आप को एक using कथन में लपेट कर सकते हैं।




एक विशिष्ट उदाहरण जिसमें आपको एक ब्लॉक का using कर सावधानी बरतनी चाहिए, WCF सेवा क्लाइंट के साथ है

जैसा कि इस MSDN आलेख में वर्णित है, किसी WCF क्लाइंट को (जो कि IDisposable को कार्यान्वित करता है) लपेटकर किसी ब्लॉक में किसी भी त्रुटि को ढंक कर सकता है जिसके परिणामस्वरूप क्लाइंट को दोषपूर्ण स्थिति में छोड़ा जा सकता है (जैसे कि टाइमआउट या संचार समस्या)। लम्बी कहानी छोटी, जब Dispose() को कहा जाता है, ग्राहक की Close() विधि आग लगाती है, लेकिन फेंकता है और त्रुटि क्योंकि यह दोषपूर्ण स्थिति में है। मूल अपवाद तब दूसरे अपवाद द्वारा मुखौटा है अच्छा नही।

वहां कई कार्यवाहीएं हैं, इनमें से एक को एमएसडीएन लेख में भी शामिल है दूसरों को आईएसएसवरीऑरिएंटेड और blog.davidbarret.net पर पाया जा सकता है।

मैं आखिरी विधि को पसंद करता हूं, स्वयं।




उदाहरण:

        using(SqlConnection MyConnection = new SqlConnection("Connection string"))
        {
            MyConnection.Open();

            //...

            // 1. SQLConnection is a type that implements IDisposable
            // 2. So you can use MyConnection in a using statement
            // 3. When using block finishes, it calls Dispose method of 
            // SqlConnection class
            // 4. In this case, it will probably close the connection to 
            // the database and dispose MyConnection object

        }

आप अपने खुद के ऑब्जेक्ट बना सकते हैं जो आईडीिसस्पोज़ाबल लागू करता है:

public class MyOwnObjectThatImplementsIDisposable : IDisposable
{

    //... some code

    public void Dispose()
    {
        // Put here the code you want to be executed when the
        // using statement finish.
    }
}

तो आप एक प्रयोग कथन में MyOwnObjectThanImplementsIDisposable प्रकार के ऑब्जेक्ट का उपयोग कर सकते हैं:

        using(MyOwnObjectThatImplementsIDisposable MyObject = new MyOwnObjectThatImplementsIDisposable)
        {

            // When the statement finishes, it calls the 
            // code you´ve writed in Dispose method
            // of MyOwnObjectThatImplementsIDisposable class
        }

उम्मीद है की यह मदद करेगा




मैं यह भी IDispose कि यदि कोई using() कथन using() उपयोग करता है, तो कुछ भी IDispose और अगर आप जिस तरह से निपटाना चाहते हैं, वह गैर-मैनेज किए गए संसाधनों जैसे डाटाबेस कनेक्शन और फ़ाइल हैंडल

अगर यह एक सामान्य वस्तु है जिसमें एक List<T> , जहां टी Customer ऑब्जेक्ट की तरह है जो नाम और पता रखता है, तो आपको इसकी आवश्यकता नहीं है। कचरा कलेक्टर आपके लिए यह प्रबंधन करने के लिए पर्याप्त स्मार्ट है। लेकिन कचरा कलेक्टर कनेक्शन पूल या बंद फ़ाइल हैंडल के लिए कनेक्शन वापस नहीं करेगा।




प्राइमरी नियम है: * यूज़िंग स्टेटमेंट का प्रयोग करें जब ऑब्जेक्ट आईडीआईस्पोज़ योग्य इंटरफ़ेस लागू करता है।

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

यह बहुत महत्वपूर्ण है कि सभी संसाधन जो अब उपयोग में नहीं हैं जितनी जल्दी हो सके मुक्त हो।

इसके बारे में अधिक जानकारी के लिए बस इस लिंक पर जाएं: माइक्रोसॉफ्ट