TcpClient का उपयोग करने वाली कक्षा पर अंतिमकरण को लागू करने की आवश्यकता है?

Question

मेरे पास एक कक्षा है (MyClass कहें) जो TcpClient ऑब्जेक्ट का उपयोग करता है (एक निजी क्षेत्र के रूप में है)। MyClass विधि में TcpClient.Close पर कॉलिंग लागू करता है।

मेरा प्रश्न MyClass भी एक finalizer मामले MyClass.Dispose में TcpClient’s अप्रबंधित संसाधनों को मुक्त करने के बुला कोड से बुलाया नहीं है Dispose(bool Disposing) कॉल करने के लिए लागू करना चाहिए है?

धन्यवाद

Answer 1

नहीं, तुम नहीं करना चाहिए कि बेल्ट और ब्रेसिज़ आप कार्यालय में कभी नहीं बुलाया जाता कोड याद है।

क्योंकि आप एक finalizer में एक अन्य वस्तु पर एक विधि कॉल कभी नहीं करना चाहिए, यह आपके वस्तु से पहले अंतिम रूप दिया जा सकता था।

आपके टीसीपी क्लाइंट के अंतिमकर्ता को कचरा कलेक्टर द्वारा बुलाया जाएगा, इसलिए उसे करने दें।

निपटान में पैटर्न है:

protected virtual void Dispose(bool disposing) 
{ 
    if (disposing) 
    { 
     // dispose managed resources (here your TcpClient) 
    } 

    // dispose your unmanaged resources 
    // handles etc using static interop methods. 
} 

Answer 2

हाँ आपको चाहिए - Microsoft even recommends it।

बस पर 2:00 है :)

Answer 3

नहीं आप की जरूरत नहीं है। टीसीपी क्लाइंट अप्रबंधित सॉकेट के चारों ओर एक रैपर वर्ग है और इसके लिए इसे डिस्प्ले किया जाना चाहिए जिस तरह से प्रबंधित किया जाना चाहिए। आपने जो किया है वह पर्याप्त है।

Answer 4

नहीं, आपको नहीं करना चाहिए।

this उत्कृष्ट पद से:

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

यह डिस्पोजेबल की मेरी संदर्भ कार्यान्वयन/टिप्पणियों जब उपयोग करने के लिए क्या समझा साथ पैटर्न को अंतिम रूप देने है: मेरा मानना ​​है कि

/// <summary> 
    /// Example of how to implement the dispose pattern. 
    /// </summary> 
    public class PerfectDisposableClass : IDisposable 
    { 
     /// <summary> 
     /// Type constructor. 
     /// </summary> 
     public PerfectDisposableClass() 
     { 
      Console.WriteLine("Constructing");  
     } 

     /// <summary> 
     /// Dispose method, disposes resources and suppresses finalization. 
     /// </summary> 
     public void Dispose() 
     { 
      Dispose(true); 
      GC.SuppressFinalize(this); 
     } 

     /// <summary> 
     /// Disposes resources used by class. 
     /// </summary> 
     /// <param name="disposing"> 
     /// True if called from user code, false if called from finalizer. 
     /// When true will also call dispose for any managed objects. 
     /// </param> 
     protected virtual void Dispose(bool disposing) 
     { 
      Console.WriteLine("Dispose(bool disposing) called, disposing = {0}", disposing); 

      if (disposing) 
      { 
       // Call dispose here for any managed objects (use lock if thread safety required), e.g. 
       // 
       // if(myManagedObject != null) 
       // { 
       //  myManagedObject.Dispose(); 
       //  myManagedObject = null; 
       // } 
      } 
     } 

     /// <summary> 
     /// Called by the finalizer. Note that if <see cref="Dispose()"/> has been called then finalization will 
     /// have been suspended and therefore never called. 
     /// </summary> 
     /// <remarks> 
     /// This is a safety net to ensure that our resources (managed and unmanaged) are cleaned up after usage as 
     /// we can guarantee that the finalizer will be called at some point providing <see cref="Dispose()"/> is 
     /// not called. 
     /// Adding a finalizer, however, IS EXPENSIVE. So only add if using unmanaged resources (and even then try 
     /// and avoid a finalizer by using <see cref="SafeHandle"/>). 
     /// </remarks> 
     ~PerfectDisposableClass() 
     { 
      Dispose(false); 
     } 
    }