C # में "उपयोग" के क्या उपयोग हैं?

Question

यूजर कोकस ने कीवर्ड का उल्लेख करके C # प्रश्न के अद्भुत हिडन फीचर्स का जवाब दिया using। क्या आप इसे विस्तार में बताने में सक्षम हैं? के उपयोग क्या हैं using?

Comments

यह RAII मुहावरे का समर्थन करने का एक C # तरीका है: hackcraft.net/raii

— Nemanja Trifunovic

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

— चरिथज

Answer 1

usingकथन का कारण यह सुनिश्चित करना है कि जैसे ही यह कार्यक्षेत्र से बाहर जाता है, वस्तु का निपटान हो जाता है, और यह सुनिश्चित करने के लिए स्पष्ट कोड की आवश्यकता नहीं होती है कि ऐसा होता है।

जैसे कि C # (कोडप्रोजेक्ट) में '' स्टेटमेंट '' का उपयोग करके समझना और उन वस्तुओं का उपयोग करना जो आईडीआईसोपेरेटरी (microsoft) को लागू करते हैं , C # कंपाइलर कन्वर्ट करता है

using (MyResource myRes = new MyResource())
{
    myRes.DoSomething();
}

सेवा

{ // Limits scope of myRes
    MyResource myRes= new MyResource();
    try
    {
        myRes.DoSomething();
    }
    finally
    {
        // Check for a null resource.
        if (myRes != null)
            // Call the object's Dispose method.
            ((IDisposable)myRes).Dispose();
    }
}

C # 8 एक नया वाक्य-विन्यास पेश करता है, जिसका नाम " घोषणाओं का उपयोग करना " है:

एक का उपयोग कर घोषणा एक चर घोषणा का उपयोग कर खोजशब्द से पहले है। यह संकलक को बताता है कि घोषित किए जा रहे चर को एन्कोडिंग दायरे के अंत में निपटाया जाना चाहिए।

तो ऊपर का समान कोड होगा:

using var myRes = new MyResource();
myRes.DoSomething();

और जब नियंत्रण युक्त स्कोप छोड़ता है (आमतौर पर एक विधि, लेकिन यह एक कोड ब्लॉक भी हो सकता है), myResतो निपटाया जाएगा।

Comments

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

— जॉन सॉन्डर्स

कृपया ध्यान दें कि जब MyRessourceएक संरचना होती है तो उत्पन्न कोड थोड़ा अलग होता है। स्पष्टता के लिए कोई परीक्षा नहीं है, लेकिन कोई मुक्केबाजी भी नहीं है IDisposable। एक विवश आभासी कॉल उत्सर्जित होता है।

— रोमेन वेर्डियर

कोई भी इस बात का उल्लेख क्यों नहीं कर रहा है कि नाम स्थान को आयात करने के लिए भी उपयोग किया जाता है?

— काइल डेलाने

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

— मासिमिलियानो क्रूस

@ जॉनसंडर्स इसके अलावा, अंतिम रूप से बुलाया जाने की गारंटी नहीं है।

— पाब्लो एच

Answer 2

चूंकि बहुत सारे लोग अभी भी करते हैं:

using (System.IO.StreamReader r = new System.IO.StreamReader(""))
using (System.IO.StreamReader r2 = new System.IO.StreamReader("")) {
   //code
}

मुझे लगता है कि बहुत से लोग अभी भी नहीं जानते कि आप कर सकते हैं:

using (System.IO.StreamReader r = new System.IO.StreamReader(""), r2 = new System.IO.StreamReader("")) {
   //code
}

Comments

क्या एक बयान का उपयोग करके विभिन्न प्रकारों की कई वस्तुओं का उपयोग करना संभव है?

— एगेल कुरियन

@AgnelKurian No: "त्रुटि CS1044: एक के लिए एक से अधिक प्रकार का उपयोग नहीं कर सकता, का उपयोग कर, तय, या घोषणा बयान"

— डेविड Sykes

यह प्रश्न का उत्तर कैसे देता है?

— लियाम

मैं वास्तव में नहीं जानता था कि मैं कोड के एक ब्लॉक से पहले दो स्टेटमेंस का उपयोग करके लिख सकता हूं (हर बार उन्हें घोंसला देगा)।

— kub1x

Answer 3

इस तरह की बातें:

using (var conn = new SqlConnection("connection string"))
{
   conn.Open();

    // Execute SQL statement here on the connection you created
}

यह SqlConnectionस्पष्ट रूप से कॉल करने के लिए की जरूरत के बिना बंद कर दिया जाएगा .Close()समारोह, और इस का क्या होगा , भले ही एक अपवाद फेंक दिया जाता है एक की आवश्यकता के बिना, try/ catch/ finally।

Comments

क्या होगा अगर मैं एक विधि के अंदर "उपयोग" कर रहा हूं, और मैं एक उपयोग के बीच में लौटता हूं। कोई दिक़्क़त है क्या?

— francisco_ssb 14

कोई समस्या नहीं है। यहां उदाहरण में, कनेक्शन अभी भी बंद हो जाएगा, भले ही आप ब्लॉक returnके बीच से हों using।

— जोएल कोएहॉर्न

Answer 4

उपयोग करने के लिए आईडीआईसॉपी का इस्तेमाल किया जा सकता है। इसका उपयोग अन्य प्रकारों के लिए भी किया जा सकता है।

using (SqlConnection cnn = new SqlConnection()) { /*code*/}
using f1 = System.Windows.Forms.Form;

Answer 5

का उपयोग कर, के अर्थ में

using (var foo = new Bar())
{
  Baz();
}

वास्तव में एक कोशिश / अंत में ब्लॉक के लिए आशुलिपि है। यह कोड के बराबर है:

var foo = new Bar();
try
{
  Baz();
}
finally
{
  foo.Dispose();
}

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

using (new Scope(() => IsWorking = false))
{
  IsWorking = true;
  MundaneYetDangerousWork();
}

आप हमारे समाधान के बारे में अधिक पढ़ सकते हैं और हमने इसे यहां कैसे प्राप्त किया ।

Answer 6

Microsoft दस्तावेज़ बताता है कि उपयोग करने का दोहरा कार्य ( https://msdn.microsoft.com/en-us/library/zhdeatwt.aspx ) है, दोनों निर्देश के रूप में और बयानों में । एक बयान के रूप में, जैसा कि अन्य उत्तरों में यहां बताया गया था, कीवर्ड मूल रूप से सिंटैक्टिक शुगर है जो एक आईडीआरोपयोगी वस्तु को निपटाने के लिए गुंजाइश निर्धारित करता है । निर्देश के रूप में , यह नियमित रूप से नामस्थान और प्रकारों को आयात करने के लिए उपयोग किया जाता है। एक निर्देश के रूप में, आप नाम स्थान और प्रकारों के लिए उपनाम बना सकते हैं , जैसा कि "C # 5.0 इन नटशेल: द डेफिनिटिव गाइड" पुस्तक में बताया गया है ( http://www.amazon.com/5-0-Nutshell-The- निश्चित-संदर्भ-ebook / डी पी / B008E6I1K8), जोसेफ और बेन अलबहारी द्वारा। एक उदाहरण:

namespace HelloWorld
{
    using AppFunc = Func<IDictionary<DateTime, string>, List<string>>;
    public class Startup
    {
        public static AppFunc OrderEvents() 
        {
            AppFunc appFunc = (IDictionary<DateTime, string> events) =>
            {
                if ((events != null) && (events.Count > 0))
                {
                    List<string> result = events.OrderBy(ev => ev.Key)
                        .Select(ev => ev.Value)
                        .ToList();
                    return result;
                }
                throw new ArgumentException("Event dictionary is null or empty.");
            };
            return appFunc;
        }
    }
}

यह समझदारी से अपनाने के लिए कुछ है, क्योंकि इस प्रथा के दुरुपयोग से किसी के कोड की स्पष्टता को चोट पहुंच सकती है। D #NetNetPearls ( http://www.dotnetperls.com/using-alias ) में C # उपनामों पर एक अच्छा स्पष्टीकरण है, जिसमें पेशेवरों और विपक्षों का भी उल्लेख है ।

Comments

झूठ नहीं बोलने वाला: मैं एक उपनाम उपकरण के रूप में उपयोग से नफरत करता हूं using। कोड पढ़ते समय यह मुझे भ्रमित करता है - मुझे पहले से ही पता है कि System.Collectionsमौजूद है और IEnumerable<T>कक्षा है। किसी अन्य चीज़ को कॉल करने के लिए अन्य उपनाम का उपयोग करना मेरे लिए इसे बाधित करता है। समझाusing FooCollection = IEnumerable<Foo> बाद में डेवलपर्स को कोड पढ़ने और सोचने के लिए एक तरीका के रूप में हूं, "नरक क्या है FooCollectionऔर कहीं इसके लिए एक वर्ग क्यों नहीं है?" मैं इसका उपयोग कभी नहीं करता और इसके उपयोग को हतोत्साहित करता। लेकिन यह सिर्फ मुझे हो सकता है।

— अरि रोथ

परिशिष्ट: मैं मानता हूँ कि आपके उदाहरण में जहाँ आप इसका उपयोग किसी प्रतिनिधि को परिभाषित करने के लिए करते हैं, कभी-कभार इसके लिए कोई उपयोग हो सकता है। लेकिन मेरा तर्क है कि वे अपेक्षाकृत दुर्लभ हैं।

— अरी रोथ

Answer 7

मैंने इनपुट और आउटपुट स्ट्रीम के साथ काम करने के लिए अतीत में इसका उपयोग किया है। आप उन्हें अच्छी तरह से घोंसला बना सकते हैं और यह आपके द्वारा आमतौर पर चलाए जा रहे संभावित समस्याओं का एक बहुत दूर ले जाता है (स्वचालित रूप से निपटान कहकर)। उदाहरण के लिए:

        using (FileStream fs = new FileStream("c:\file.txt", FileMode.Open))
        {
            using (BufferedStream bs = new BufferedStream(fs))
            {
                using (System.IO.StreamReader sr = new StreamReader(bs))
                {
                    string output = sr.ReadToEnd();
                }
            }
        }

Answer 8

बस थोड़ा सा कुछ जोड़ना जो मुझे आश्चर्यचकित कर रहा था, ऊपर नहीं आया। उपयोग करने की सबसे दिलचस्प विशेषता (मेरी राय में) यह है कि कोई भी मैटर नहीं है कि आप उपयोग करने वाले ब्लॉक से कैसे बाहर निकलते हैं, यह हमेशा वस्तु का निपटान करेगा। इसमें रिटर्न और अपवाद शामिल हैं।

using (var db = new DbContext())
{
    if(db.State == State.Closed) throw new Exception("Database connection is closed.");
    return db.Something.ToList();
}

इससे कोई फर्क नहीं पड़ता कि अपवाद फेंक दिया गया है या सूची वापस आ गई है। DbContext ऑब्जेक्ट हमेशा निपटाया जाएगा।

Answer 9

उपयोग करने का एक और बड़ा उपयोग यह है कि जब एक मोडल डायलॉग को तत्काल किया जाए।

Using frm as new Form1

Form1.ShowDialog

' do stuff here

End Using

Comments

क्या आपका मतलब frm.ShowDialog था?

— उउदद्ल्र्र्र्स

Answer 10

अंत में, जब आप एक प्रकार का एक स्थानीय चर का उपयोग लागू करता है कि IDisposable, हमेशा , बिना किसी अपवाद के, का उपयोग using¹ ।

यदि आप नॉन-फोकल IDisposableचर का उपयोग करते हैं , तो हमेशा IDisposableपैटर्न को लागू करें ।

दो सरल नियम, कोई अपवाद ¹ । संसाधन लीक को रोकना अन्यथा * एसएस में एक वास्तविक दर्द है।

---

¹⁾ : एकमात्र अपवाद है - जब आप अपवादों को संभाल रहे हैं। यह ब्लॉक Disposeमें स्पष्ट रूप से कॉल करने के लिए कम कोड हो सकता है finally।

Answer 11

आप निम्न उदाहरण के माध्यम से उपनाम नामस्थान का उपयोग कर सकते हैं:

using LegacyEntities = CompanyFoo.CoreLib.x86.VBComponents.CompanyObjects;

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

LegacyEntities.Account

के बजाय

CompanyFoo.CoreLib.x86.VBComponents.CompanyObjects.Account

या केवल

Account   // It is not obvious this is a legacy entity

Answer 12

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

यह आपको कहा ऑपरेशन के स्पष्ट शुरुआत और अंत को दर्शाने के लिए वाक्यविन्यास का उपयोग करके वास्तव में अच्छा उपयोग करने की अनुमति देता है। यह भी है कि कैसे System.Transactions सामान काम करता है।

Answer 13

ADO.NET का उपयोग करते समय आप अपने कनेक्शन ऑब्जेक्ट या रीडर ऑब्जेक्ट जैसी चीजों के लिए कीवर्क का उपयोग कर सकते हैं। इस तरह से जब कोड ब्लॉक पूरा हो जाता है तो यह स्वचालित रूप से आपके कनेक्शन का निपटान करेगा।

Comments

मैं सिर्फ इतना जोड़ूंगा कि कोड ब्लॉक को भी पूरा नहीं करना है। एक अनहेल्दी अपवाद की स्थिति में भी एक ब्लॉकिंग संसाधन का निपटान करेगा।

— हार्पो

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

— मस्जिद

Answer 14

"का उपयोग" का उपयोग नाम स्थान के टकराव को हल करने के लिए भी किया जा सकता है। एक संक्षिप्त ट्यूटोरियल के लिए http://www.davidarno.org/c-howtos/aliases-overcoming-name-conflicts/ देखें जो मैंने इस विषय पर लिखा था।

Answer 15

public class ClassA:IDisposable

{
   #region IDisposable Members        
    public void Dispose()
    {            
        GC.SuppressFinalize(this);
    }
    #endregion
}

---

public void fn_Data()

    {
     using (ClassA ObjectName = new ClassA())
            {
                //use objectName 
            }
    }

Answer 16

का उपयोग करते हुए का उपयोग तब किया जाता है जब आपके पास एक संसाधन होता है जिसे आप उपयोग किए जाने के बाद निपटाना चाहते हैं।

उदाहरण के लिए, यदि आप एक फ़ाइल संसाधन आवंटित करते हैं और इसे केवल पढ़ने या लिखने के लिए कोड के एक भाग में उपयोग करने की आवश्यकता होती है, तो उपयोग करना आपके किए गए जैसे ही फ़ाइल संसाधन के निपटान के लिए सहायक होता है।

उपयोग किए जा रहे संसाधन को सही ढंग से काम करने के लिए आईडीसोपायरी को लागू करने की आवश्यकता है।

उदाहरण:

using (File file = new File (parameters))
{
    *code to do stuff with the file*
}

Answer 17

उपयोग करने वाला कीवर्ड ऑब्जेक्ट के लिए गुंजाइश को परिभाषित करता है और फिर गुंजाइश पूरी होने पर ऑब्जेक्ट का निपटान करता है। उदाहरण के लिए।

using (Font font2 = new Font("Arial", 10.0f))
{
    // use font2
}

कीवर्ड का उपयोग करके C # पर MSDN लेख के लिए यहां देखें ।

Answer 18

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

Answer 19

नीचे दिए गए टिप्पणियों के लिए धन्यवाद, मैं इस पोस्ट को थोड़ा साफ कर दूंगा (मुझे उस समय 'कचरा संग्रह' शब्द का इस्तेमाल नहीं करना चाहिए था, माफी):
जब आप उपयोग करते हैं, तो यह ऑब्जेक्ट पर डिस्पोज () विधि को कॉल करेगा उपयोग के दायरे के अंत में। तो आप अपने निपटान () विधि में काफी महान सफाई कोड हो सकते हैं।
यहां एक बुलेट पॉइंट जो उम्मीद है कि शायद यह अन-मार्कडाउन हो सकता है: यदि आप आईडीसोपायरी को लागू करते हैं, तो सुनिश्चित करें कि आप अपने निपटान में GC.SuppressFinalize () कार्यान्वयन को कॉल करें, क्योंकि अन्यथा स्वचालित कचरा संग्रह के साथ आने और इसे अंतिम रूप देने की कोशिश करेंगे बिंदु, जो कम से कम संसाधनों की बर्बादी होगी यदि आप पहले से ही इसका निपटान () कर चुके हैं।

Comments

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

— कैंट बूगार्ट

Answer 20

एक उचित उपयोग का दूसरा उदाहरण जिसमें वस्तु को तुरंत निपटाया जाता है:

using (IDataReader myReader = DataFunctions.ExecuteReader(CommandType.Text, sql.ToString(), dp.Parameters, myConnectionString)) 
{
    while (myReader.Read()) 
    {
        MyObject theObject = new MyObject();
        theObject.PublicProperty = myReader.GetString(0);
        myCollection.Add(theObject);
    }
}

Answer 21

घुंघराले कोष्ठक के बाहर सब कुछ निपटाया जाता है, इसलिए यदि आप उनका उपयोग नहीं कर रहे हैं तो अपनी वस्तुओं को निपटाना बहुत अच्छा है। ऐसा इसलिए है क्योंकि यदि आपके पास SqlDataAdapter ऑब्जेक्ट है और आप इसे केवल एक बार एप्लिकेशन जीवन चक्र में उपयोग कर रहे हैं और आप सिर्फ एक डेटासेट भर रहे हैं और आपको इसकी कोई आवश्यकता नहीं है, तो आप कोड का उपयोग कर सकते हैं:

using(SqlDataAdapter adapter_object = new SqlDataAdapter(sql_command_parameter))
{
   // do stuff
} // here adapter_object is disposed automatically

Answer 22

उपयोग कथन सही ढंग से आईडिसेप्‍टुरेबल वस्‍तुओं का उपयोग करने के लिए एक सुविधा तंत्र प्रदान करता है। एक नियम के रूप में, जब आप एक आइडीएसोपॉलिज्ड ऑब्जेक्ट का उपयोग करते हैं, तो आपको एक उपयोग स्टेटमेंट में इसे घोषित और तत्काल करना चाहिए। उपयोग करने वाला कथन ऑब्जेक्ट को सही तरीके से डिस्पोज़ करने के तरीके को कहता है, और (जब आप इसे पहले दिखाए गए अनुसार उपयोग करते हैं) तो यह ऑब्जेक्ट को स्कोप से बाहर जाने की संभावना का भी कारण बनता है। उपयोग ब्लॉक के भीतर, ऑब्जेक्ट केवल पढ़ने के लिए और संशोधित या पुन: असाइन नहीं किया जा सकता है।

यह यहां से आता है:

Answer 23

मेरे लिए "उपयोग" नाम थोड़ा भ्रमित करने वाला है, क्योंकि त्रुटि से निपटने के लिए नामस्पेस या एक बयान (जैसे यहां चर्चा की गई) आयात करने का निर्देश हो सकता है।

त्रुटि से निपटने के लिए एक अलग नाम अच्छा रहा होगा, और शायद किसी तरह अधिक स्पष्ट।

Answer 24

इसका उपयोग उदाहरण के लिए स्कोप बनाने के लिए भी किया जा सकता है:

class LoggerScope:IDisposable {
   static ThreadLocal<LoggerScope> threadScope = 
        new ThreadLocal<LoggerScope>();
   private LoggerScope previous;

   public static LoggerScope Current=> threadScope.Value;

   public bool WithTime{get;}

   public LoggerScope(bool withTime){
       previous = threadScope.Value;
       threadScope.Value = this;
       WithTime=withTime;
   }

   public void Dispose(){
       threadScope.Value = previous;
   }
}


class Program {
   public static void Main(params string[] args){
       new Program().Run();
   }

   public void Run(){
      log("something happend!");
      using(new LoggerScope(false)){
          log("the quick brown fox jumps over the lazy dog!");
          using(new LoggerScope(true)){
              log("nested scope!");
          }
      }
   }

   void log(string message){
      if(LoggerScope.Current!=null){
          Console.WriteLine(message);
          if(LoggerScope.Current.WithTime){
             Console.WriteLine(DateTime.Now);
          }
      }
   }

}

Answer 25

उपयोग करने वाला कथन .NET का उपयोग ब्लॉक में निर्दिष्ट ऑब्जेक्ट को एक बार जारी करने के लिए कहता है, जिसकी अब आवश्यकता नहीं है। इसलिए आपको उन वर्गों के लिए 'उपयोग' ब्लॉक का उपयोग करना चाहिए जिनके लिए उनके बाद सफाई की आवश्यकता होती है, जैसे कि System.IO प्रकार।

Answer 26

usingC # में कीवर्ड के दो उपयोग हैं।

1. एक निर्देश के रूप में

   आम तौर पर हम उपयोग करते हैं using कोड-पीछे और वर्ग फ़ाइलों में नामस्थान जोड़ने के कीवर्ड का । फिर यह वर्तमान पृष्ठ में सभी वर्गों, इंटरफेस और अमूर्त वर्ग और उनके तरीकों और गुणों को उपलब्ध कराता है।

   उदाहरण:

   using System.IO;

2. एक बयान के रूप में

   यह उपयोग करने का एक और तरीका है using C # में कीवर्ड । यह कचरा संग्रह में प्रदर्शन को बेहतर बनाने में एक महत्वपूर्ण भूमिका निभाता है।

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

   एक अन्य महत्वपूर्ण कारक यह है कि यह कनेक्शन पूलिंग में मदद करता है। .NET में कनेक्शन पूलिंग एक डेटाबेस कनेक्शन के समापन को कई बार समाप्त करने में मदद करता है। यह कनेक्शन ऑब्जेक्ट को भविष्य में उपयोग (अगले डेटाबेस कॉल) के लिए एक पूल में भेजता है। अगली बार जब आपके एप्लिकेशन से डेटाबेस कनेक्शन कहा जाता है तो कनेक्शन पूल पूल में उपलब्ध वस्तुओं को प्राप्त करता है। तो यह एप्लिकेशन के प्रदर्शन को बेहतर बनाने में मदद करता है। इसलिए जब हम उपयोग करने वाले बयान का उपयोग करते हैं तो नियंत्रक ऑब्जेक्ट को कनेक्शन पूल में स्वचालित रूप से भेजता है, बंद () और निपटान () विधियों को स्पष्ट रूप से कॉल करने की आवश्यकता नहीं है।

   आप वैसा ही कर सकते हैं जैसा कि ट्राइ-कैच ब्लॉक का उपयोग करके बयान कर रहा है और अंत में ब्लॉक के अंदर डिस्पोज़ () को स्पष्ट रूप से कॉल करें। लेकिन कोडिंग क्लीनर और अधिक सुरुचिपूर्ण बनाने के लिए कॉलिंग स्टेटमेंट स्वचालित रूप से कॉल करता है। उपयोग ब्लॉक के भीतर, ऑब्जेक्ट केवल पढ़ने के लिए और संशोधित या पुन: असाइन नहीं किया जा सकता है।

   उदाहरण:

   string connString = "Data Source=localhost;Integrated Security=SSPI;Initial Catalog=Northwind;";
   
   using (SqlConnection conn = new SqlConnection(connString))
   {
         SqlCommand cmd = conn.CreateCommand();
         cmd.CommandText = "SELECT CustomerId, CompanyName FROM Customers";
         conn.Open();
         using (SqlDataReader dr = cmd.ExecuteReader())
         {
            while (dr.Read())
            Console.WriteLine("{0}\t{1}", dr.GetString(0), dr.GetString(1));
         }
   }

पूर्ववर्ती कोड में मैं कोई कनेक्शन बंद नहीं कर रहा हूं; यह अपने आप बंद हो जाएगा। usingबयान के कारण स्वचालित रूप से conn.Close (कॉल करेंगे) usingबयान ( using (SqlConnection conn = new SqlConnection(connString)) और एक SqlDataReader वस्तु के लिए एक ही। और अगर कोई अपवाद होता है तो यह कनेक्शन को स्वचालित रूप से बंद कर देगा।

अधिक जानकारी के लिए, C # में उपयोग करने का उपयोग और महत्व देखें ।

Answer 27

राइनो Mocks रिकार्ड प्लेबैक सिंटेक्स का एक दिलचस्प इस्तेमाल करता है using।

Comments

मूल रूप से प्लेबैक कॉलिंग के रूप में एक ही है और यह सब सत्यापित करता है कि डिस्पोज़ () विधियों में

— जॉर्ज माउर

Answer 28

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

CLR आपके कोड को MSIL में बदल देता है। और उपयोग करने वाला कथन एक कोशिश और अंत में ब्लॉक होने में अनुवादित हो जाता है। इस प्रकार IL में स्टेटमेंट का उपयोग किया गया है। एक उपयोग कथन को तीन भागों में अनुवादित किया जाता है: अधिग्रहण, उपयोग और निपटान। संसाधन को पहले अधिग्रहित किया जाता है, फिर उपयोग को अंतिम विवरण के साथ एक कोशिश बयान में संलग्न किया जाता है। वस्तु तब अंत में खंड में समा जाती है।

Answer 29

क्लॉज का उपयोग विशेष चर के लिए गुंजाइश को परिभाषित करने के लिए किया जाता है। उदाहरण के लिए:

     Using(SqlConnection conn=new SqlConnection(ConnectionString)
            {
                Conn.Open()
            // Execute sql statements here.
           // You do not have to close the connection explicitly here as "USING" will close the connection once the object Conn becomes out of the defined scope.
            }

Comments

यह किसी को याद कर सकता है, उपयोग वस्तुओं को निपटाने के लिए है। शायद आप इसे कोड ब्लॉक के साथ भ्रमित कर रहे हैं, यदि आप एक चर के दायरे को सीमित करना चाहते हैं तो आप इसके लिए नेस्टेड कोड ब्लॉक का उपयोग कर सकते हैं: सार्वजनिक स्थैतिक शून्य मुख्य (पैरामस स्ट्रिंग [] args) {{// नेस्टेड कोड ब्लॉक}}

— luuuardohd