From: 011netservice@gmail.com
Date: 2022-04-24
Subject: IDisposable.txt
歡迎來信交流
/*
IDisposableSample.cs
*/
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
// add
using System;
namespace ZLib.DSample
{
///
/// Design pattern for a IDisposable class.
///
class BaseClass : IDisposable // CodeHelper IDisposable.
{
#region IDisposable Support
private bool MDispose = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!MDispose)
{
if (disposing)
{
// TODO: dispose managed state (managed objects).
}
// TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
// TODO: set large fields to null.
MDispose = true;
}
}
// TODO: override a finalizer only if Dispose(bool disposing) above has code to free unmanaged resources.
// ~BaseClass() {
// // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
// Dispose(false);
// }
// This code added to correctly implement the disposable pattern.
public void Dispose()
{
// Do not change this code. Put cleanup code in Dispose(bool disposing) above.
Dispose(true);
// TODO: uncomment the following line if the finalizer is overridden above.
// GC.SuppressFinalize(this);
}
#endregion
}
///
/// Design pattern for a derived class.
///
class DerivedClass : BaseClass // Sample: IDisposable for derived class.
{
#region IDisposable for a derived class Support
// Design pattern for a derived class.
private bool MDispose = false;
protected override void Dispose(bool disposing)
{
if (!MDispose)
{
if (disposing)
{
// Release managed resources.
}
// Release unmanaged resources.
// Set large fields to null.
// Call Dispose on your base class.
MDispose = true;
}
base.Dispose(disposing);
}
// The derived class does not have a Finalize method
// or a Dispose method without parameters because it inherits
// them from the base class.
#endregion
}
}
----------
20180821
類別執行個體通常透過非執行階段所管理的資源，例如視窗控制代碼 (HWND)、資料庫連接等等，來封裝控制項。 因此，您應該提供明確和隱含的方式來釋放這些資源。 請藉由在物件上實作受保護的 Finalize，來提供隱含控制 (C# 和 C++ 中為解構函式語法)。 在不再有任何有效的物件參考之後，記憶體回收行程會某些時間點上呼叫這個方法。
在某些情況下，您可能想要提供程式設計人員在記憶體回收行程釋放物件之前，使用能夠明確釋放這些外部資源的物件。 如果外部資源不足或太過消耗，若程式設計人員明確釋放不再被使用的資源，會達到更佳的效能。 若要提供明確控制，請實作 IDisposable 提供的 Dispose。 物件的消費者應該在完成此物件的使用時呼叫此方法。 即使此物件的其他參考仍然存在，還是可以呼叫 Dispose。
請注意，即使當您使用 Dispose 來提供明確控制時，也應該使用 Finalize 方法提供隱含清除。 如果程式設計人員呼叫 Dispose 失敗，則 Finalize 會提供備份，以避免資源被永久遺漏。
如需實作 Finalize 和 Dispose 來清除 Unmanaged 資源的詳細資訊，請參閱記憶體回收。 下麵的示例闡釋的基本設計模式，實施處置。 這個範例需要 System 命名空間。
範例1: 實作 IDisposable
// Design pattern for a base class.
public class Base: IDisposable
{
#region IDisposable Support
private bool mbDispose = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!mbDispose)
{
if (disposing)
{
// TODO: dispose managed state (managed objects).
}
// TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
// TODO: set large fields to null.
mbDispose = true;
}
}
// TODO: override a finalizer only if Dispose(bool disposing) above has code to free unmanaged resources.
// ~Base() {
// // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
// Dispose(false);
// }
// This code added to correctly implement the disposable pattern.
public void Dispose()
{
// Do not change this code. Put cleanup code in Dispose(bool disposing) above.
Dispose(true);
// TODO: uncomment the following line if the finalizer is overridden above.
// GC.SuppressFinalize(this);
}
#endregion
}
範例2: 繼承 IDisposable 的物件.
// Design pattern for a derived class.
public class Derived: Base
{
#region IDisposable for a derived class Support
// Design pattern for a derived class.
private bool mbDispose = false;
protected override void Dispose(bool disposing)
{
if (!mbDispose)
{
if (disposing)
{
// Release managed resources.
}
// Release unmanaged resources.
// Set large fields to null.
// Call Dispose on your base class.
mbDispose = true;
}
base.Dispose(disposing);
}
// The derived class does not have a Finalize method
// or a Dispose method without parameters because it inherits
// them from the base class.
#endregion
}
----------
using System;
using System.ComponentModel;
// The following example demonstrates how to create
// a resource class that implements the IDisposable interface
// and the IDisposable.Dispose method.
public class DisposeExample
{
// A base class that implements IDisposable.
// By implementing IDisposable, you are announcing that
// instances of this type allocate scarce resources.
public class MyResource: IDisposable
{
// Pointer to an external unmanaged resource.
private IntPtr handle;
// Other managed resource this class uses.
private Component component = new Component();
// Track whether Dispose has been called.
private bool disposed = false;
// The class constructor.
public MyResource(IntPtr handle)
{
this.handle = handle;
}
// Implement IDisposable.
// Do not make this method virtual.
// A derived class should not be able to override this method.
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.
GC.SuppressFinalize(this);
}
// Dispose(bool disposing) executes in two distinct scenarios.
// If disposing equals true, the method has been called directly
// or indirectly by a user's code. Managed and unmanaged resources
// can be disposed.
// If disposing 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.
private void Dispose(bool disposing)
{
// Check to see if Dispose has already been called.
if(!this.disposed)
{
// If disposing equals true, dispose all managed
// and unmanaged resources.
if(disposing)
{
// Dispose managed resources.
component.Dispose();
}
// Call the appropriate methods to clean up
// unmanaged resources here.
// If disposing is false,
// only the following code is executed.
CloseHandle(handle);
handle = IntPtr.Zero;
// Note disposing has been done.
disposed = true;
}
}
// Use interop to call the method necessary
// to clean up the unmanaged resource.
[System.Runtime.InteropServices.DllImport("Kernel32")]
private extern static Boolean CloseHandle(IntPtr handle);
// Use C# destructor syntax for finalization code.
// This destructor will run only if the Dispose method
// does not get called.
// It gives your base class the opportunity to finalize.
// Do not provide destructors in types derived from this class.
~MyResource()
{
// Do not re-create Dispose clean-up code here.
// Calling Dispose(false) is optimal in terms of
// readability and maintainability.
Dispose(false);
}
}
public static void Main()
{
// Insert code here to create
// and use the MyResource object.
}
}