弱引用与弱委托

一、弱引用：

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

    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);        }    }