学步园

来源地址：http://www.albahari.com/nutshell/cs4ch12.aspx

Calling Dispose from a finalizer（采用完成执行后的释放，也就是析构函数）：

class Test : IDisposable
{
public void Dispose()             // NOT virtual(非虚函数)
  {
    Dispose (true);
    GC.SuppressFinalize (this);     // Prevent finalizer from running.(在执行过程中防止调用最终的资源释放函数)
  }

protected virtual void Dispose (bool disposing)
  {
if (disposing)
    {
// Call Dispose() on other objects owned by this instance（通过其它（类）对象的当前实例调用Dispose() 函数）.
// You can reference other finalizable objects here.（你可以在这里引用其它对象的终结方法）
// ...
    }

// Release unmanaged resources owned by (just) this object.(在当前的对象（类）中释放其非托管资源)
// ...
  }

  ˜Test()
  {
    Dispose (false);
  }
}

Resurrection - deleting temporary file（采用析构函数的方式激活删除临时文件的方法）

public class TempFileRef
{
public readonly string FilePath;
public TempFileRef (string filePath) { FilePath = filePath; }

  ~TempFileRef() { File.Delete (FilePath); }
}

Better solution（更好的解决方案）：

public class TempFileRef
{
static ConcurrentQueue<TempFileRef> _failedDeletions
    = new ConcurrentQueue<TempFileRef>();

public readonly string FilePath;
public Exception DeletionError { get; private set; }

public TempFileRef (string filePath) { FilePath = filePath; }

  ~TempFileRef()
  {
try { File.Delete (FilePath); }
catch (Exception ex)
    {
      DeletionError = ex;
      _failedDeletions.Enqueue (this);   // Resurrection
    }
  }
}

GC.ReRegisterForFinalize（这是垃圾回收（类）对象的一个静态方法）

public class TempFileRef
{
public readonly string FilePath;
int _deleteAttempt;

public TempFileRef (string filePath) { FilePath = filePath; }

  ~TempFileRef()
  {
try { File.Delete (FilePath); }
catch
    {
if (_deleteAttempt++ < 3) GC.ReRegisterForFinalize (this);
    }
  }
}

Managed Memory Leak（托管堆的内在泄漏）

class Host
{
public event EventHandler Click;
}

class Client
{
  Host _host;
public Client (Host host)
  {
    _host = host;
    _host.Click += HostClicked;
  }

void HostClicked (object sender, EventArgs e) { ... }
}

class Test
{
static Host _host = new Host();

public static void CreateClients()
  {
    Client[] clients = Enumerable.Range (0, 1000)
     .Select (i => new Client (_host))
     .ToArray();

// Do something with clients ... （对客户端做一些操作）
  }
}

Timers and memory leaks（时间对象与内在的泄漏）

using System.Timers;

class Foo
{
  Timer _timer;

  Foo() 
  {
    _timer = new System.Timers.Timer { Interval = 1000 };
    _timer.Elapsed += tmr_Elapsed;
    _timer.Start();
  }

void tmr_Elapsed (object sender, ElapsedEventArgs e) { ... }
}

class Foo : IDisposable
{
  ...
public void Dispose() { _timer.Dispose(); }
}

static void Main()
{
var tmr = new System.Threading.Timer (TimerTick, null, 1000, 1000);
  GC.Collect();
  System.Threading.Thread.Sleep (10000);    // Wait 10 seconds （线程等待10秒）
}

static void TimerTick (object notUsed) { Console.WriteLine ("tick"); }

using (var tmr = new System.Threading.Timer (TimerTick, null, 1000, 1000))
{
  GC.Collect();
  System.Threading.Thread.Sleep (10000);    // Wait 10 seconds 
}

Weak references（弱类型引用：var）:

var sb = new StringBuilder ("this is a test");
var weak = new WeakReference (sb);
Console.WriteLine (weak.Target);     // This is a test（测试目标对象输出的结果）

var weak = new WeakReference (new StringBuilder ("weak"));
Console.WriteLine (weak.Target);   // weak（输出弱类型目标对象）
GC.Collect();
Console.WriteLine (weak.Target);   // (nothing)由于上一行代码执行了垃圾回收，这里的资源已经被释放了

class Widget
{
static List<WeakReference> _allWidgets = new List<WeakReference>();

public readonly string Name;

public Widget (string name)
  {
    Name = name;
    _allWidgets.Add (new WeakReference (this));
  }

public static void ListAllWidgets()
  {
foreach (WeakReference weak in _allWidgets)
    {
      Widget w = (Widget)weak.Target;
if (w != null) Console.WriteLine (w.Name);
    }
  }
}

Weak references and events（弱类型引用与其事件）

public class WeakDelegate<TDelegate> where TDelegate : class
{
class MethodTarget
  {
public readonly WeakReference Reference;
public readonly MethodInfo Method;

public MethodTarget (Delegate d)
    {
      Reference = new WeakReference (d.Target);
      Method = d.Method;
    }
  }

  List<MethodTarget> _targets = new List<MethodTarget>();

public WeakDelegate()
  {
if (!typeof (TDelegate).IsSubclassOf (typeof (Delegate)))
throw new InvalidOperationException
        ("TDelegate must be a delegate type");
  }

public void Combine (TDelegate target)
  {
if (target == null) return;

foreach (Delegate d in (target as Delegate).GetInvocationList())
      _targets.Add (new MethodTarget (d));
  }

public void Remove (TDelegate target)
  {
if (target == null) return;
foreach (Delegate d in (target as Delegate).GetInvocationList())
    {
      MethodTarget mt = _targets.Find (w => 
        d.Target.Equals (w.Reference.Target) && 
        d.Method.MethodHandle.Equals (w.Method.MethodHandle));

if (mt != null) _targets.Remove (mt);
    }
  }

public TDelegate Target
  {
get
    {
var deadRefs = new List<MethodTarget>();
      Delegate combinedTarget = null;

foreach (MethodTarget mt in _targets.ToArray())
      {
        WeakReference target = mt.Reference;
if (target != null && target.IsAlive)
        {
var newDelegate = Delegate.CreateDelegate (
typeof (TDelegate), mt.Reference.Target, mt.Method);

          combinedTarget = Delegate.Combine (combinedTarget, newDelegate);
        }
else
          deadRefs.Add (mt);
      }

foreach (MethodTarget mt in deadRefs)   // Remove dead references
        _targets.Remove (mt);                 // from _targets.（移除一些无效的引用对象）

return combinedTarget as TDelegate;
    }
set
    {
      _targets.Clear();
      Combine (value);
    }
  }
}

public class Foo
{
  WeakDelegate<EventHandler> _click = new WeakDelegate<EventHandler>();

public event EventHandler Click
  {
    add { _click.Combine (value); } remove { _click.Remove (value); }
  }

protected virtual void OnClick (EventArgs e)
  {
    EventHandler target = _click.Target;
if (target != null) target (this, e);
  }
}