弱引用与弱委托

一、弱引用：

  我们设计全局缓存时，使用静态或全局字段来引用某个对象，做到一次创建多次使用。比如：

class Program { private static DataCache _cache; public static DataCache Cache { get { if(_cache == null) _cache = new DataCache(); return _cache; } } static void Main(string[] args) { byte [] ss = new byte[]{1,2,3}; GC.Collect(); Console.WriteLine("GC执行完毕"); Console.Read(); } } class DataCache { private IList<string> datas; }

但这样存在弊端：

• DataCache没频繁使用时，浪费内存空间。
• 由于GC只能回收不可达对象，所以没有办法回收这些资源。

WeakReference出场：即在引用对象的同时仍然允许对该对象进行垃圾回收。

所以我们可以这样设计缓存：

class Program { static WeakReference _cache = new WeakReference(null); public static DataCache Cache { get { DataCache cache = _cache.Target as DataCache; if(cache == null) { cache = new DataCache(); _cache.Target = cache; } return cache; } } static void Main(string[] args) { byte [] ss = new byte[]{1,2,3}; Cache.Test(); Cache.Test(); GC.Collect(); Console.WriteLine("GC执行完毕"); Cache.Test(); Console.Read(); } } class DataCache { private IList<string> datas; ~DataCache() { Console.WriteLine("Destory..."); } public void Test() { Console.WriteLine("Test"); } }

二、弱委托

弱委托解决当委托对象的生命周期足够的长时，导致委托内部持有的强对象不能回收，

比如：

class Program { static void Main(string[] args) { Action<string> sAction = new Action<string>(new ClassTest().Print); sAction("abc"); GC.Collect(); sAction("abc"); } } internal class ClassTest { public void Print(string s) { Console.WriteLine(s); } }

输出结果为：abc abc
为了解决当垃圾回收进行时，委托的对象任然存在，就用到了WeakReference

class Program { static void Main(string[] args) { Action<string> sAction = new Action<string>(new ClassTest().Print); WeakReference weakReference = new WeakReference(new ClassTest()); sAction = (s) => { object o = weakReference.Target; if (o != null) { ((ClassTest)o).Print(s); } }; sAction("def"); GC.Collect(); sAction("def"); } } internal class ClassTest { public void Print(string s) { Console.WriteLine(s); } }

输出结果当然只有一个def了。

CLR var C#中的弱委托：

public abstract class WeakDelegate<TDelegate> where TDelegate : class /* MulticastDelegate */ { // This lightweight private struct puts a compile-time type-safety wrapper around the non-generic WeakReference class private struct WeakReference<T> : IDisposable where T : class { private WeakReference m_weakReference; public WeakReference(T target) { m_weakReference = new WeakReference(target); } public T Target { get { return (T)m_weakReference.Target; } } public void Dispose() { m_weakReference = null; } } private WeakReference<TDelegate> m_weakDelegate; private Action<TDelegate> m_removeDelegateCode; public WeakDelegate(TDelegate @delegate) { var md = (MulticastDelegate)(Object)@delegate; if (md.Target == null) throw new ArgumentException("There is no reason to make a WeakDelegate to a static method."); // Save a WeakReference to the delegate m_weakDelegate = new WeakReference<TDelegate>(@delegate); } public Action<TDelegate> RemoveDelegateCode { set { // Save the delegate that refers to code that knows how to remove the // WeakDelegate object when the non-weak delegate object is GC’d m_removeDelegateCode = value; } } protected TDelegate GetRealDelegate() { // If the real delegate hasn't been GC'd yet, just return it TDelegate realDelegate = m_weakDelegate.Target; if (realDelegate != null) return realDelegate; // The real delegate was GC'd, we don't need our WeakReference to it anymore (it can be GC'd) m_weakDelegate.Dispose(); // Remove the delegate from the chain (if the user told us how) if (m_removeDelegateCode != null) { m_removeDelegateCode(GetDelegate()); m_removeDelegateCode = null; // Let the remove handler delegate be GC'd } return null; // The real delegate was GC'd and can't be called } // All derived classes must return a delegate to a private method matching the TDelegate type public abstract TDelegate GetDelegate(); // Implicit conversion operator to convert a WeakDelegate object to an actual delegate public static implicit operator TDelegate(WeakDelegate<TDelegate> @delegate) { return @delegate.GetDelegate(); } } // This class provides support for the non-generic EventHandler delegate public sealed class WeakEventHandler : WeakDelegate<EventHandler> { public WeakEventHandler(EventHandler @delegate) : base(@delegate) { } /// <summary>Returns a reference to the non-generic EventHandler delegate</summary> public override EventHandler GetDelegate() { return Callback; } // This private method must match the desired delegate’s signature private void Callback(Object sender, EventArgs e) { // If the target hasn't been GC'd invoke it var eh = base.GetRealDelegate(); if (eh != null) eh(sender, e); } } // This WeakDelegate partial class provides support for the generic EventHandler<TEventArgs> delegate public sealed class WeakEventHandler<TEventArgs> : WeakDelegate<EventHandler<TEventArgs>> where TEventArgs : EventArgs { public WeakEventHandler(EventHandler<TEventArgs> @delegate) : base(@delegate) { } /// <summary>Returns a reference to the generic EventHandler<typeparam name="TEventArgs"/> delegate</summary> public override EventHandler<TEventArgs> GetDelegate() { return Callback; } private void Callback(Object sender, TEventArgs e) { // If the target hasn't been GC'd invoke it var eh = base.GetRealDelegate(); if (eh != null) eh(sender, e); } }