Penggunaan metode Finalisasi / Buang dalam C #

C # 2008

Saya telah mengerjakan ini untuk sementara waktu sekarang, dan saya masih bingung tentang penggunaan metode finalisasi dan buang dalam kode. Pertanyaan saya di bawah ini:

1. Saya tahu bahwa kita hanya perlu penyelesai sementara membuang sumber daya yang tidak dikelola. Namun, jika ada sumber daya yang dikelola yang membuat panggilan ke sumber daya yang tidak dikelola, apakah masih perlu menerapkan finalizer?

2. Namun, jika saya mengembangkan kelas yang tidak menggunakan sumber daya yang tidak dikelola - langsung atau tidak langsung, haruskah saya mengimplementasikannya IDisposable agar klien dari kelas itu dapat menggunakan 'pernyataan penggunaan'?

   Apakah layak menerapkan IDisposable hanya untuk memungkinkan klien kelas Anda menggunakan pernyataan menggunakan?

   using(myClass objClass = new myClass())
   {
       // Do stuff here
   }

3. Saya telah mengembangkan kode sederhana di bawah ini untuk menunjukkan penyelesaian / buang penggunaan:

   public class NoGateway : IDisposable
   {
       private WebClient wc = null;
   
       public NoGateway()
       {
           wc = new WebClient();
           wc.DownloadStringCompleted += wc_DownloadStringCompleted;
       }
   
   
       // Start the Async call to find if NoGateway is true or false
       public void NoGatewayStatus()
       {
           // Start the Async's download
               // Do other work here
           wc.DownloadStringAsync(new Uri(www.xxxx.xxx));
       }
   
       private void wc_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)
       {
           // Do work here
       }
   
       // Dispose of the NoGateway object
       public void Dispose()
       {
           wc.DownloadStringCompleted -= wc_DownloadStringCompleted;
           wc.Dispose();
           GC.SuppressFinalize(this);
       }
   }

Pertanyaan tentang kode sumber:

1. Di sini saya belum menambahkan finalizer, dan biasanya finalizer akan dipanggil oleh GC, dan finalizer akan memanggil Buang. Karena saya tidak memiliki finalizer, kapan saya memanggil metode Buang? Apakah klien dari kelas yang harus memanggilnya?

   Jadi kelas saya dalam contoh disebut NoGateway dan klien dapat menggunakan dan membuang kelas seperti ini:

   using(NoGateway objNoGateway = new NoGateway())
   {
       // Do stuff here   
   }

   Apakah metode Buang dipanggil secara otomatis ketika eksekusi mencapai akhir blok penggunaan, atau apakah klien harus memanggil metode buang secara manual? yaitu

   NoGateway objNoGateway = new NoGateway();
   // Do stuff with object
   objNoGateway.Dispose(); // finished with it

2. Saya menggunakan WebClientkelas di NoGatewaykelas saya . Karena WebClientmengimplementasikan IDisposableantarmuka, apakah ini berarti WebClientsecara tidak langsung menggunakan sumber daya yang tidak dikelola? Apakah ada aturan yang keras dan cepat untuk mengikuti ini? Bagaimana saya tahu bahwa suatu kelas menggunakan sumber daya yang tidak dikelola?

Pola IDisposable yang direkomendasikan ada di sini . Saat memprogram kelas yang menggunakan IDisposable, umumnya Anda harus menggunakan dua pola:

Saat menerapkan kelas tertutup yang tidak menggunakan sumber daya yang tidak dikelola, Anda cukup menerapkan metode Buang seperti dengan implementasi antarmuka normal:

public sealed class A : IDisposable
{
    public void Dispose()
    {
        // get rid of managed resources, call Dispose on member variables...
    }
}

Saat menerapkan kelas yang tidak disegel, lakukan seperti ini:

public class B : IDisposable
{    
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (disposing)
        {
            // get rid of managed resources
        }   
        // get rid of unmanaged resources
    }

    // only if you use unmanaged resources directly in B
    //~B()
    //{
    //    Dispose(false);
    //}
}

Perhatikan bahwa saya belum menyatakan finalizer di B; Anda hanya harus menerapkan finalizer jika Anda memiliki sumber daya yang tidak terkelola untuk dibuang. CLR berurusan dengan objek yang dapat diselesaikan secara berbeda dengan objek yang tidak dapat diselesaikan, meskipun SuppressFinalizedisebut.

Jadi, Anda tidak boleh mendeklarasikan finalizer kecuali Anda harus melakukannya, tetapi Anda memberikan hook kelas kepada Anda untuk menelepon Anda Disposedan mengimplementasikan finalizer sendiri jika mereka menggunakan sumber daya yang tidak dikelola secara langsung:

public class C : B
{
    private IntPtr m_Handle;

    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            // get rid of managed resources
        }
        ReleaseHandle(m_Handle);

        base.Dispose(disposing);
    }

    ~C() {
        Dispose(false);
    }
}

Jika Anda tidak menggunakan sumber daya yang tidak dikelola secara langsung ( SafeHandledan teman-teman tidak masuk hitungan, karena mereka menyatakan finalizer mereka sendiri), maka jangan mengimplementasikan finalizer, karena GC berurusan dengan kelas finalizable secara berbeda, bahkan jika Anda kemudian menekan finalizer. Perhatikan juga, meskipun Btidak memiliki finalizer, ia tetap memanggilSuppressFinalize untuk berurusan dengan benar dengan setiap subclass yang mengimplementasikan finalizer.

Ketika sebuah kelas mengimplementasikan antarmuka IDisposable, itu berarti bahwa di suatu tempat ada beberapa sumber daya yang tidak dikelola yang harus dihilangkan ketika Anda selesai menggunakan kelas. Sumber daya aktual dirangkum dalam kelas; Anda tidak perlu menghapusnya secara eksplisit. Cukup dengan menelepon Dispose()atau membungkus kelas dalam a using(...) {}akan memastikan sumber daya yang tidak dikelola dihilangkan seperlunya.

Pola resmi untuk mengimplementasikannya IDisposablesulit dipahami. Saya percaya ini lebih baik :

public class BetterDisposableClass : IDisposable {

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

  protected virtual void CleanUpManagedResources() { 
    // ...
  }
  protected virtual void CleanUpNativeResources() {
    // ...
  }

  ~BetterDisposableClass() {
    CleanUpNativeResources();
  }

}

Sebuah lebih baik solusi adalah memiliki aturan bahwa Anda selalu harus membuat kelas wrapper untuk setiap sumber daya unmanaged yang Anda butuhkan untuk menangani:

public class NativeDisposable : IDisposable {

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

  protected virtual void CleanUpNativeResource() {
    // ...
  }

  ~NativeDisposable() {
    CleanUpNativeResource();
  }

}

Dengan SafeHandledan turunannya, kelas-kelas ini harus sangat jarang .

Hasil untuk kelas sekali pakai yang tidak berurusan langsung dengan sumber daya yang tidak dikelola, bahkan di hadapan warisan, sangat kuat: mereka tidak perlu lagi peduli dengan sumber daya yang tidak dikelola lagi . Mereka akan mudah diimplementasikan dan dipahami:

public class ManagedDisposable : IDisposable {

  public virtual void Dispose() {
    // dispose of managed resources
  }

}

Perhatikan bahwa implementasi IDisposable harus mengikuti pola di bawah ini (IMHO). Saya mengembangkan pola ini berdasarkan info dari beberapa .NET "allah" yang bagus .NET Framework Design Guidelines (perhatikan bahwa MSDN tidak mengikuti ini karena alasan tertentu!). Pedoman .NET Framework Design ditulis oleh Krzysztof Cwalina (CLR Architect pada saat itu) dan Brad Abrams (saya percaya Manajer Program CLR pada saat itu) dan Bill Wagner ([C Efektif] dan [Lebih Efektif C #] (cukup ambil lihat ini di Amazon.com:

Perhatikan bahwa Anda tidak akan pernah mengimplementasikan Finalizer kecuali kelas Anda secara langsung berisi (bukan warisan) sumber daya yang tidak dikelola. Setelah Anda menerapkan Finalizer di kelas, bahkan jika itu tidak pernah dipanggil, dijamin akan hidup untuk koleksi tambahan. Itu secara otomatis ditempatkan pada Antrian Finalisasi (yang berjalan pada satu utas). Juga, satu catatan yang sangat penting ... semua kode yang dieksekusi dalam Finalizer (harus Anda perlu menerapkannya) HARUS aman dari thread DAN pengecualian aman! Hal-hal buruk akan terjadi sebaliknya ... (yaitu perilaku yang tidak ditentukan dan dalam kasus pengecualian, aplikasi crash fatal yang tidak dapat dipulihkan).

Pola yang saya kumpulkan (dan menulis cuplikan kode) berikut:

#region IDisposable implementation

//TODO remember to make this class inherit from IDisposable -> $className$ : IDisposable

// Default initialization for a bool is 'false'
private bool IsDisposed { get; set; }

/// <summary>
/// Implementation of Dispose according to .NET Framework Design Guidelines.
/// </summary>
/// <remarks>Do not make this method virtual.
/// A derived class should not be able to override this method.
/// </remarks>
public void Dispose()
{
    Dispose( true );

    // This object will be cleaned up by the Dispose method.
    // Therefore, you should call GC.SupressFinalize to
    // take this object off the finalization queue 
    // and prevent finalization code for this object
    // from executing a second time.

    // Always use SuppressFinalize() in case a subclass
    // of this type implements a finalizer.
    GC.SuppressFinalize( this );
}

/// <summary>
/// Overloaded Implementation of Dispose.
/// </summary>
/// <param name="isDisposing"></param>
/// <remarks>
/// <para><list type="bulleted">Dispose(bool isDisposing) executes in two distinct scenarios.
/// <item>If <paramref name="isDisposing"/> equals true, the method has been called directly
/// or indirectly by a user's code. Managed and unmanaged resources
/// can be disposed.</item>
/// <item>If <paramref name="isDisposing"/> equals false, the method has been called by the 
/// runtime from inside the finalizer and you should not reference 
/// other objects. Only unmanaged resources can be disposed.</item></list></para>
/// </remarks>
protected virtual void Dispose( bool isDisposing )
{
    // TODO If you need thread safety, use a lock around these 
    // operations, as well as in your methods that use the resource.
    try
    {
        if( !this.IsDisposed )
        {
            if( isDisposing )
            {
                // TODO Release all managed resources here

                $end$
            }

            // TODO Release all unmanaged resources here



            // TODO explicitly set root references to null to expressly tell the GarbageCollector
            // that the resources have been disposed of and its ok to release the memory allocated for them.


        }
    }
    finally
    {
        // explicitly call the base class Dispose implementation
        base.Dispose( isDisposing );

        this.IsDisposed = true;
    }
}

//TODO Uncomment this code if this class will contain members which are UNmanaged
// 
///// <summary>Finalizer for $className$</summary>
///// <remarks>This finalizer will run only if the Dispose method does not get called.
///// It gives your base class the opportunity to finalize.
///// DO NOT provide finalizers in types derived from this class.
///// All code executed within a Finalizer MUST be thread-safe!</remarks>
//  ~$className$()
//  {
//     Dispose( false );
//  }
#endregion IDisposable implementation

Berikut adalah kode untuk mengimplementasikan IDisposable di kelas turunan. Perhatikan bahwa Anda tidak perlu membuat daftar warisan secara eksplisit dari IDisposable dalam definisi kelas turunan.

public DerivedClass : BaseClass, IDisposable (remove the IDisposable because it is inherited from BaseClass)


protected override void Dispose( bool isDisposing )
{
    try
    {
        if ( !this.IsDisposed )
        {
            if ( isDisposing )
            {
                // Release all managed resources here

            }
        }
    }
    finally
    {
        // explicitly call the base class Dispose implementation
        base.Dispose( isDisposing );
    }
}

Saya telah memposting implementasi ini di blog saya di: Cara Menerapkan Pola Buang dengan Benar

Saya setuju dengan PM100 (dan seharusnya secara eksplisit mengatakan ini di posting saya sebelumnya).

Anda tidak boleh menerapkan IDisposable di kelas kecuali Anda membutuhkannya. Untuk lebih spesifik, ada sekitar 5 kali ketika Anda membutuhkan / harus menerapkan IDisposable:

1. Kelas Anda secara eksplisit berisi (yaitu bukan melalui warisan) sumber daya yang dikelola yang menerapkan IDisposable dan harus dibersihkan setelah kelas Anda tidak lagi digunakan. Misalnya, jika kelas Anda berisi turunan dari Stream, DbCommand, DataTable, dll.

2. Kelas Anda secara eksplisit berisi sumber daya yang dikelola yang menerapkan metode Tutup () - misalnya IDataReader, IDbConnection, dll. Perhatikan bahwa beberapa kelas ini menerapkan IDisposable dengan memiliki metode Buang () serta Tutup ().

3. Kelas Anda secara eksplisit berisi sumber daya yang tidak dikelola - misalnya objek COM, pointer (ya, Anda dapat menggunakan pointer dalam C # yang dikelola tetapi mereka harus dideklarasikan dalam blok 'tidak aman', dll. Dalam kasus sumber daya yang tidak dikelola, Anda juga harus memastikan untuk sebut System.Runtime.InteropServices.Marshal.ReleaseComObject () pada RCW. Meskipun RCW, secara teori, merupakan pembungkus yang dikelola, masih ada penghitungan referensi yang terjadi di bawah selimut.

4. Jika kelas Anda berlangganan acara menggunakan referensi kuat. Anda harus membatalkan registrasi / melepaskan diri dari peristiwa tersebut. Selalu pastikan ini bukan nol dulu sebelum mencoba membatalkan pendaftaran / lepaskan mereka !.

5. Kelas Anda mengandung kombinasi apa pun di atas ...

Alternatif yang disarankan untuk bekerja dengan objek COM dan harus menggunakan Marshal.ReleaseComObject () adalah dengan menggunakan kelas System.Runtime.InteropServices.SafeHandle.

BCL (Tim Perpustakaan Kelas Dasar) memiliki posting blog yang bagus tentang hal ini di sini http://blogs.msdn.com/bclteam/archive/2005/03/16/396900.aspx

Satu catatan yang sangat penting untuk dibuat adalah bahwa jika Anda bekerja dengan WCF dan membersihkan sumber daya, Anda harus HAMPIR SELALU menghindari blok 'menggunakan'. Ada banyak posting blog di luar sana dan beberapa di MSDN tentang mengapa ini adalah ide yang buruk. Saya juga mempostingnya di sini - Jangan gunakan 'using ()' dengan proxy WCF

Menggunakan lambdas bukan IDisposable.

Saya tidak pernah senang dengan keseluruhan menggunakan / ide IDisposable. Masalahnya adalah itu mengharuskan penelepon untuk:

• tahu bahwa mereka harus menggunakan IDisposable
• ingat untuk menggunakan 'menggunakan'.

Metode pilihan baru saya adalah menggunakan metode pabrik dan lambda sebagai gantinya

Bayangkan saya ingin melakukan sesuatu dengan SqlConnection (sesuatu yang harus dibungkus menggunakan). Klasik yang akan Anda lakukan

using (Var conn = Factory.MakeConnection())
{
     conn.Query(....);
}

Jalan baru

Factory.DoWithConnection((conn)=>
{
    conn.Query(...);
}

Dalam kasus pertama penelepon tidak bisa menggunakan sintaks menggunakan. Dalam kasus kedua, pengguna tidak memiliki pilihan. Tidak ada metode yang membuat objek SqlConnection, pemanggil harus memanggil DoWithConnection.

DoWithConnection terlihat seperti ini

void DoWithConnection(Action<SqlConnection> action)
{
   using (var conn = MakeConnection())
   {
       action(conn);
   }
}

MakeConnection sekarang pribadi

tidak ada yang menjawab pertanyaan tentang apakah Anda harus menerapkan IDisposable meskipun Anda tidak membutuhkannya.

Jawaban singkat: Tidak

Jawaban panjang:

Ini akan memungkinkan konsumen kelas Anda untuk menggunakan 'menggunakan'. Pertanyaan yang akan saya tanyakan adalah - mengapa mereka melakukannya? Sebagian besar devs tidak akan menggunakan 'menggunakan' kecuali mereka tahu bahwa mereka harus - dan bagaimana mereka tahu. Antara

• itu obviuos mereka dari pengalaman (kelas soket misalnya)
• itu didokumentasikan
• mereka berhati-hati dan dapat melihat bahwa kelas mengimplementasikan IDisposable

Jadi dengan mengimplementasikan IDisposable Anda memberitahu devs (setidaknya beberapa) bahwa kelas ini merangkum sesuatu yang harus dirilis. Mereka akan menggunakan 'menggunakan' - tetapi ada kasus-kasus lain di mana penggunaan tidak memungkinkan (ruang lingkup objek tidak lokal); dan mereka harus mulai khawatir tentang masa hidup benda-benda dalam kasus-kasus lain - saya pasti khawatir. Tetapi ini tidak perlu

Anda menerapkan Idisposable untuk memungkinkan mereka menggunakan menggunakan, tetapi mereka tidak akan menggunakan menggunakan kecuali jika Anda memberi tahu mereka.

Jadi jangan lakukan itu

1. Jika Anda menggunakan objek terkelola lainnya yang menggunakan sumber daya yang tidak dikelola, itu bukan tanggung jawab Anda untuk memastikan mereka selesai. Tanggung jawab Anda adalah memanggil Buanglah benda-benda itu saat Buang dipanggil pada benda Anda, dan benda itu berhenti di sana.

2. Jika kelas Anda tidak menggunakan sumber daya yang langka, saya gagal melihat mengapa Anda membuat kelas Anda mengimplementasikan IDisposable. Anda hanya harus melakukannya jika Anda:

   • Ketahuilah bahwa Anda akan memiliki sumber daya yang langka di objek Anda segera, tidak sekarang (dan maksud saya bahwa seperti "kita masih berkembang, itu akan ada di sini sebelum kita selesai", bukan seperti dalam "Saya pikir kita akan membutuhkan ini ")
   • Menggunakan sumber daya yang langka

3. Ya, kode yang menggunakan kode Anda harus memanggil metode Buang objek Anda. Dan ya, kode yang menggunakan objek Anda dapat digunakan usingseperti yang Anda tunjukkan.

4. (2 lagi?) Sepertinya WebClient menggunakan sumber daya yang tidak dikelola, atau sumber daya yang dikelola lainnya yang menerapkan IDisposable. Namun, alasan pastinya tidak penting. Yang penting adalah mengimplementasikan IDisposable, sehingga Anda harus bertindak berdasarkan pengetahuan itu dengan membuang objek ketika Anda selesai menggunakannya, bahkan jika ternyata WebClient tidak menggunakan sumber daya lain sama sekali.

Buang pola:

public abstract class DisposableObject : IDisposable
{
    public bool Disposed { get; private set;}      

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

    ~DisposableObject()
    {
        Dispose(false);
    }

    private void Dispose(bool disposing)
    {
        if (!Disposed)
        {
            if (disposing)
            {
                DisposeManagedResources();
            }

            DisposeUnmanagedResources();
            Disposed = true;
        }
    }

    protected virtual void DisposeManagedResources() { }
    protected virtual void DisposeUnmanagedResources() { }
}

Contoh warisan:

public class A : DisposableObject
{
    public Component components_a { get; set; }
    private IntPtr handle_a;

    protected override void DisposeManagedResources()
    {
        try
        {
          Console.WriteLine("A_DisposeManagedResources");
          components_a.Dispose();
          components_a = null;
        }
        finally
        { 
          base.DisposeManagedResources();
        }
    }

    protected override void DisposeUnmanagedResources()
    {
        try
        {
          Console.WriteLine("A_DisposeUnmanagedResources");
          CloseHandle(handle_a);
          handle_a = IntPtr.Zero;
        }
        finally
        { 
          base.DisposeUnmanagedResources();
        }
    }
}

public class B : A
{
    public Component components_b { get; set; }
    private IntPtr handle_b;

    protected override void DisposeManagedResources()
    {
        try
        {
          Console.WriteLine("B_DisposeManagedResources");
          components_b.Dispose();
          components_b = null;
        }
        finally
        { 
          base.DisposeManagedResources();
        }
    }

    protected override void DisposeUnmanagedResources()
    {
        try
        {
          Console.WriteLine("B_DisposeUnmanagedResources");
          CloseHandle(handle_b);
          handle_b = IntPtr.Zero;
        }
        finally
        { 
          base.DisposeUnmanagedResources();
        }
    }
}

Beberapa aspek dari jawaban lain sedikit salah karena 2 alasan:

Pertama,

using(NoGateway objNoGateway = new NoGateway())

sebenarnya setara dengan:

try
{
    NoGateway = new NoGateway();
}
finally
{
    if(NoGateway != null)
    {
        NoGateway.Dispose();
    }
}

Ini mungkin terdengar konyol karena operator 'baru' tidak boleh mengembalikan 'null' kecuali Anda memiliki pengecualian OutOfMemory. Tetapi pertimbangkan kasus-kasus berikut: 1. Anda memanggil FactoryClass yang mengembalikan sumber daya IDisposable atau 2. Jika Anda memiliki tipe yang mungkin atau mungkin tidak mewarisi dari IDisposable tergantung pada implementasinya - ingat bahwa saya telah melihat pola IDisposable diimplementasikan secara salah banyak kali di banyak klien di mana pengembang hanya menambahkan metode Buang () tanpa mewarisi dari IDisposable (buruk, buruk, buruk). Anda juga dapat memiliki kasus sumber daya IDisposable yang dikembalikan dari properti atau metode (lagi buruk, buruk, buruk - jangan 'memberikan sumber daya IDisposable Anda)

using(IDisposable objNoGateway = new NoGateway() as IDisposable)
{
    if (NoGateway != null)
    {
        ...

Jika operator 'as' mengembalikan null (atau properti atau metode yang mengembalikan sumber daya), dan kode Anda di blok 'using' melindungi terhadap 'null', kode Anda tidak akan meledak ketika mencoba memanggil Buang di objek nol karena cek nol 'bawaan'.

Alasan kedua balasan Anda tidak akurat adalah karena stmt berikut:

Seorang finalizer dipanggil pada GC yang menghancurkan objek Anda

Pertama, Finalisasi (dan juga GC itu sendiri) adalah non-deterministik. CLR menentukan kapan akan memanggil finalizer. yaitu pengembang / kode tidak tahu. Jika pola IDisposable diimplementasikan dengan benar (seperti yang saya posting di atas) dan GC.SuppressFinalize () telah dipanggil, Finalizer TIDAK akan dipanggil. Ini adalah salah satu alasan utama untuk menerapkan pola dengan benar. Karena hanya ada 1 utas Finalizer per proses yang dikelola, terlepas dari jumlah prosesor logis, Anda dapat dengan mudah menurunkan kinerja dengan mencadangkan atau bahkan menggantung utas Finalizer dengan lupa menelepon GC.SuppressFinalize ().

Saya telah memposting implementasi Pola Buang yang benar di blog saya: Cara Menerapkan Pola Buang dengan Benar

1) WebClient adalah tipe yang dikelola, jadi Anda tidak perlu finalizer. Finalizer diperlukan jika pengguna Anda tidak membuang () kelas NoGateway Anda dan tipe asli (yang tidak dikumpulkan oleh GC) perlu dibersihkan setelahnya. Dalam hal ini, jika pengguna tidak memanggil Buang (), WebClient yang terkandung akan dibuang oleh GC tepat setelah NoGateway melakukannya.

2) Secara tidak langsung ya, tetapi Anda tidak perlu khawatir tentang hal itu. Kode Anda benar sebagai tegakan dan Anda tidak dapat mencegah pengguna Anda lupa untuk Membuang () dengan sangat mudah.

Pola dari msdn

public class BaseResource: IDisposable
{
   private IntPtr handle;
   private Component Components;
   private bool disposed = false;
   public BaseResource()
   {
   }
   public void Dispose()
   {
      Dispose(true);      
      GC.SuppressFinalize(this);
   }
   protected virtual void Dispose(bool disposing)
   {
      if(!this.disposed)
      {        
         if(disposing)
         {
            Components.Dispose();
         }         
         CloseHandle(handle);
         handle = IntPtr.Zero;
       }
      disposed = true;         
   }
   ~BaseResource()      
   {      Dispose(false);
   }
   public void DoSomething()
   {
      if(this.disposed)
      {
         throw new ObjectDisposedException();
      }
   }
}
public class MyResourceWrapper: BaseResource
{
   private ManagedResource addedManaged;
   private NativeResource addedNative;
   private bool disposed = false;
   public MyResourceWrapper()
   {
   }
   protected override void Dispose(bool disposing)
   {
      if(!this.disposed)
      {
         try
         {
            if(disposing)
            {             
               addedManaged.Dispose();         
            }
            CloseHandle(addedNative);
            this.disposed = true;
         }
         finally
         {
            base.Dispose(disposing);
         }
      }
   }
}

using(NoGateway objNoGateway = new NoGateway())

setara dengan

try
{
    NoGateway = new NoGateway();
}

finally
{
    NoGateway.Dispose();
}

Seorang finalizer dipanggil pada GC yang menghancurkan objek Anda. Ini bisa pada waktu yang sama sekali berbeda dari ketika Anda meninggalkan metode Anda. Buang IDisposable dipanggil segera setelah Anda meninggalkan blok menggunakan. Karenanya polanya biasanya digunakan untuk membebaskan sumber daya segera setelah Anda tidak membutuhkannya lagi.

Dari apa yang saya tahu, sangat disarankan untuk TIDAK menggunakan Finalizer / Destructor:

public ~MyClass() {
  //dont use this
}

Sebagian besar, ini karena tidak tahu kapan atau JIKA itu akan dipanggil. Metode buang jauh lebih baik, terutama jika Anda menggunakan atau membuang langsung.

menggunakan itu baik. Gunakan :)