क्या यह SQLConnection

Question

का निपटान करने का सही तरीका है, मैं सोच रहा था कि मेरा नीचे कार्यान्वयन इस मामले में SQLconnection का निपटान करने का सबसे प्रभावी तरीका है या नहीं।

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

public class SqlRepository : IRepository 
{ 
    private readonly string connectionString; 
    private SqlConnection connection; 

    public SqlRepository(string connectionString) 
    { 
     this.connectionString = connectionString; 
     connection = new SqlConnection(connectionString); 
     connection.Open(); 
    } 

    public void Method_A() 
    { 
     // uses the SqlConnection to fetch data 
    }  

    public void Method_B() 
    { 
     // uses the SqlConnection to fetch data 
    }  

    public void Dispose() 
    {    
     connection.Dispose(); 
    } 
} 

उपयोग:

using (IRepository repository = new SqlRepository(connectionString)) 
{ 
    var item = repository.items;  
} 

अद्यतन IRepository IDisposable

Answer 1

कनेक्शन को खुली अवधि में कॉल न रखें। आप कनेक्शन पूलिंग को हरा रहे हैं।

यदि आप पूल किए गए कनेक्शन (एसक्लसेवरर) के साथ काम कर रहे हैं, तो यह पूल और पुन: उपयोग करेगा। विधि के भीतर बस खोलें और बंद करें & बी।

आप तर्क दे सकते हैं कि अगर कॉलर एक विधि कॉल के साथ उपयोग करने के साथ करता है तो यह ठीक है। लेकिन यदि आप प्रत्येक कार्यकर्ता विधि (1) के अंदर sqlconnection के साथ {} का उपयोग करते हैं तो कोड सरल होगा और (2) आपको यह सुनिश्चित किया जाता है कि पूलिंग को पराजित नहीं किया जाएगा (जिसका मतलब है कि आपके होल्डिंग आइटम पूलिंग से बाहर हैं जब अन्य अनुरोध इसका उपयोग कर सकते हैं) ।

संपादित करें:

टिप्पणी के आधार पर छद्म जोड़ा जा रहा है।

पैटर्न समस्याग्रस्त है क्योंकि एक कॉलर कर सकता है।

//pseudo code 
using (SqlRepository r) 
{ 
    r.MethodA(); 

    // other code here that takes some time. your holding a connection 
    // out of the pool and being selfish. other threads could have 
    // used your connection before you get a chance to use it again. 

    r.MethodB(); 
} // freed for others here. 

जो सर्वर की स्केलेबिलिटी को मार देगा - मेरा विश्वास करो। मैंने देखा है कि बहुत बड़ी प्रणालियों को इस तरह से दबाया जाता है - आम तौर पर क्योंकि वे एटी साइड लेनदेन कर रहे हैं।

एक बेहतर पैटर्न:

class Repository 
{ 
    void MethodA() 
    { 
     using (Sqlconnection) 
     { 
      // db call 
     } 
    } 

    void MethodB() 
    { 
     using (Sqlconnection) 
     { 
      // you can even have multiple calls here (roundtrips) 
      // and start transactions. although that can be problematic 
      // for other reasons. 
     } 
    } 

अब, पूल सबसे प्रभावी है। मुझे एहसास है कि सवाल डिस्पोजेबल पैटर्न पर था - और हाँ आप इसे कर सकते हैं। लेकिन ...

मैं कनेक्शन को भंडार के जीवनकाल तक नहीं पहुंचूंगा। IDisposable से

Answer 2

लागू आप ऐसा करना चाहते हैं, तो आप IDisposable को लागू (मैं अगर आप ध्यान दें नहीं कर सकते बता सुनिश्चित करता है यह आपके आईआरपॉजिटरी इंटरफेस पर है या नहीं) और मैं कुछ ऐसा करूंगा:

 

     private bool disposed = false; 

     protected virtual void Dispose(bool disposing) 
     { 
      if (!this.disposed) 
      { 
       if (disposing) 
       { 
        _context.Dispose(); 
       } 
      } 
      this.disposed = true; 
     } 

     public void Dispose() 
     { 
      Dispose(true); 
      GC.SuppressFinalize(this); 
     } 

स्पष्ट रूप से _context यहां आपका एसक्यूएलकनेक्शन है।

हालांकि - क्या आप वाकई प्रति भंडार एक कनेक्शन चाहते हैं? एक से अधिक भंडार फैलाने वाले संचालन के बारे में क्या?

Answer 3

मान लिया जाये कि IRepository इनहेरिट करती है, अपने कार्यान्वयन ठीक आप अपने SqlRepository वर्ग लंबे समय तक की तुलना में यह डेटाबेस पर प्रश्नों की एक 'तार्किक' अनुक्रम प्रदर्शन करने के लिए ले जाता है के लिए खुला का एक उदाहरण रखते हुए नहीं कर रहे हैं प्रदान की जाती है।तथ्य यह है कि यह अनुक्रम कई विधि कॉलों का विस्तार कर सकता है कोई समस्या नहीं है।

मैं @ bryanmac के जवाब से असहमत:

कनेक्शन खुला स्पैनिंग कॉल न रखें। आप कनेक्शन पूलिंग को हरा रहे हैं।

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

हालांकि एक टिप्पणी। आपको:

• या तो मानक IDisposable पैटर्न (एक protected void Dispose(bool disposing) विधि है कि व्युत्पन्न वर्ग

• या अपने वर्ग सील कर में अधिरोहित जा सकता है के साथ, ऐसी स्थिति में अपने मौजूदा IDisposable कार्यान्वयन ठीक है को लागू

  ।