[.NET]Event handler没有注销就会内存泄露吗？

我们经常会写EventHandler += AFunction; 如果没有手动注销这个Event handler类似：EventHandler –= AFunction 会内存泄露吗？会! 这个Event handler的问题是内存泄露的几大元凶之一。通常观察者模式就是用EventHandler来实现，也容易内存泄露。话虽如此，但要分清楚几个情况，不要谈虎色变。其实大多数有时候我们没必要手动注销EventHandler，也没有内存泄露。看下面的例子：

 

没有手动注销Event handler也没有内存泄露

class TestClassHasEvent
{
    public delegate void TestEventHandler(object sender, EventArgs e);
    public event TestEventHandler YourEvent;
    protected void OnYourEvent(EventArgs e)
    {
        if (YourEvent != null) YourEvent(this, e);
    }
}

class TestListener
{
    byte[] m_ExtraMemory = new byte[1000000];

    private TestClassHasEvent _inject;

    public TestListener(TestClassHasEvent inject)
    {
        _inject = inject;
        _inject.YourEvent += new TestClassHasEvent.TestEventHandler(_inject_YourEvent);
    }

    void _inject_YourEvent(object sender, EventArgs e)
    {

    }
}

class Program
{
    static void DisplayMemory()
    {
        Console.WriteLine("Total memory: {0:###,###,###,##0} bytes", GC.GetTotalMemory(true));
    }

    static void Main()
    {
        DisplayMemory();
        Console.WriteLine();
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine("--- New Listener #{0} ---", i + 1);

            var listener = new TestListener(new TestClassHasEvent());
            ////listener = null; //可有可无

            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
            DisplayMemory();

        }
        Console.Read();
    }
}

运行结果：

 

没有手动注销Event handler内存泄露

上面的例子没有注销事件，也没有内存泄露。我们来改一行代码，就内存泄露了：

把下面这段：

public TestListener(TestClassHasEvent inject)
{
    _inject = inject;
    _inject.YourEvent += new TestClassHasEvent.TestEventHandler(_inject_YourEvent);
}

改成：

public TestListener(TestClassHasEvent inject)
{
    SystemEvents.DisplaySettingsChanged += new EventHandler(SystemEvents_DisplaySettingsChanged);
}

void SystemEvents_DisplaySettingsChanged(object sender, EventArgs e)
{

}

这样就内存泄露了，看看运行结果：

加个Dispose手动注销事件，然后使用Using关键字，就没有问题了，不会内存泄露了：

class TestListener : IDisposable
{
    byte[] m_ExtraMemory = new byte[1000000];

    private TestClassHasEvent _inject;

    public TestListener(TestClassHasEvent inject)
    {
        SystemEvents.DisplaySettingsChanged += new EventHandler(SystemEvents_DisplaySettingsChanged);
    }

    void SystemEvents_DisplaySettingsChanged(object sender, EventArgs e)
    {

    }

    #region IDisposable Members

    public void Dispose()
    {
        SystemEvents.DisplaySettingsChanged -= new EventHandler(SystemEvents_DisplaySettingsChanged);
    }

    #endregion
}

class Program
{
    static void DisplayMemory()
    {
        Console.WriteLine("Total memory: {0:###,###,###,##0} bytes", GC.GetTotalMemory(true));
    }

    static void Main()
    {
        DisplayMemory();
        Console.WriteLine();
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine("--- New Listener #{0} ---", i + 1);

            using (var listener = new TestListener(new TestClassHasEvent()))
            {
                //do something
            }
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
            DisplayMemory();

        }
        Console.Read();
    }
}

 

上面两个例子一个内存泄露，一个没有内存泄露，我想你应该知道原因了，根本区别在于后者有个SystemEvents.DisplaySettingsChanged事件，来看看这个静态Static事件的定义：

// Type: Microsoft.Win32.SystemEvents
// Assembly: System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089
// Assembly location: C:\Program Files\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.0\Profile\Client\System.dll

using System;
using System.ComponentModel;

namespace Microsoft.Win32
{
    public sealed class SystemEvents
    {
        public static IntPtr CreateTimer(int interval);
        public static void InvokeOnEventsThread(Delegate method);
        public static void KillTimer(IntPtr timerId);
        public static event EventHandler DisplaySettingsChanging;
        public static event EventHandler DisplaySettingsChanged;
        public static event EventHandler EventsThreadShutdown;
        public static event EventHandler InstalledFontsChanged;

        [EditorBrowsable(EditorBrowsableState.Never)]
        [Obsolete("This event has been deprecated. http://go.microsoft.com/fwlink/?linkid=14202")]
        [Browsable(false)]
        public static event EventHandler LowMemory;

        public static event EventHandler PaletteChanged;
        public static event PowerModeChangedEventHandler PowerModeChanged;
        public static event SessionEndedEventHandler SessionEnded;
        public static event SessionEndingEventHandler SessionEnding;
        public static event SessionSwitchEventHandler SessionSwitch;
        public static event EventHandler TimeChanged;
        public static event TimerElapsedEventHandler TimerElapsed;
        public static event UserPreferenceChangedEventHandler UserPreferenceChanged;
        public static event UserPreferenceChangingEventHandler UserPreferenceChanging;
    }
}

 

注意Static，注意Singleton

这种static的东西生命周期很长，永远不会被GC回收，一旦被他给引用上了，那就不可能释放了。上面的例子就是SystemEvents.DisplaySettingsChanged += new EventHandler(SystemEvents_DisplaySettingsChanged);那就意味着这个类被SystemEvents.DisplaySettingsChanged 引用了，通过它的函数。另外一个要注意的是Singleton单例模式实现的类，他们也是static的生命周期很长，要注意引用链，你的类是否被它引用上，如果在它的引用链上，就内存泄露了。

 

注意永远不释放的东西

还有一种情况，既不是你的对象被static对象而不能释放，也不是Singleton，而是你的对象被一个永远不释放的对象引用着，这个对象或许不是static的。这种类型很多，比如你的界面有个MainForm，嘿嘿，这个MainForm永远不会关闭和释放的，被它引用了那就不会释放了。看个例子：

MainForm里面有个public event，MainForm里面打开Form2，然后关闭，看看Form2能不能释放：

public partial class MainForm : Form
{
    public event PropertyChangedEventHandler PropertyChanged;

    protected virtual void OnPropertyChanged(string propertyName)
    {
        PropertyChangedEventHandler handler = PropertyChanged;

        if (handler != null)
            handler(this, new PropertyChangedEventArgs(propertyName));
    }

    public MainForm()
    {
        InitializeComponent();
    }

    private void button1_Click(object sender, EventArgs e)
    {
        Form2 frm = new Form2();

        this.PropertyChanged += frm.frm_PropertyChanged;
        //MainForm referenced form2, because main form is not released, therefore form2 will not released.

        DialogResult d = frm.ShowDialog();

        GC.Collect();
        ShowTotalMemory();

    }



    private void ShowTotalMemory()
    {
        this.listBox1.Items.Add(string.Format("Memory: {0:###,###,###,##0} bytes", GC.GetTotalMemory(true)));
    }
}

Form2里面有个函数：

public partial class Form2 : Form
{
    public Form2()
    {
        InitializeComponent();
    }
    public void frm_PropertyChanged(object sender, PropertyChangedEventArgs e)
    {

    }
}

所以这种情况下，你的Event handler没有手动注销，那就肯定内存泄露了。

 

WeakReference就能解决问题吗？

和强引用对应的，有个弱引用（WeakReference），和Event handler对应的还有WeakEventHdnler。甚至还有WeakPropertyChangedListener。都是号称可以一劳永逸的东东，也就是说用了这些东西，内存肯定不会泄露，即使你没有手动去注销Event handler。看起来似乎问题解决了。几个问题：

• WeakReference和强引用在创建和调用的时候有几十倍的性能差（40-50倍），而且WeakRefence有专门的对象管理器来贮存这些弱引用对象，扫描它们是否还用得着，维护这个列表也需要开销。
• 引用链上的情况很复杂：假设A弱引用b，而从b –> c –> d这条引用链条上有内存泄露，还是一样，内存泄露。也就是说：b不会释放，尽管它是弱引用的。

 

深入思考和继续阅读

通常.NET程序的内存泄露原因：

• Static references
• Event with missing unsubscription
• Static event with missing unsubscription
• Dispose method not invoked
• Incomplete Dispose method

有关如何避免.NET程序的内存泄露，请仔细阅读MSDN这两篇文章，详细讲述了<如何检测.NET程序内存泄露>以及<如何写高性能的托管程序>

• How to detect and avoid memory and resources leaks in .NET applications
• Writing High-Performance Managed Applications : A Primer

有关.NET的自动内存管理机制、GC机制，垃圾回收原理等深层次内容，请仔细阅读下面的内容：

• 买书《CLR Via C#(3rd Edition)》，里面有《Memory Management》这一章专门讲述了.NET CLR的自动内存管理和垃圾回收机制
• CodeProject上的文章《Memory Management Misconceptions》有助你深入理解Root, Generation 0, 1…

参考：园子里Artech关于Event handler问题的文章：

• 关于CLR内存管理一些深层次的讨论[上篇]
• 关于CLR内存管理一些深层次的讨论[下篇]