Утечки памяти на основе событий С#

Ответ 1

События сложны, потому что, когда A подписывается на B, оба заканчивают связь друг с другом. В вашем примере это не проблема, поскольку утечки нет (созданный B и является единственным объектом для хранения ссылки на B, поэтому оба A и B умрут, когда A умрет).

Для реальных проблем с событиями, что бы решить проблему, это понятие "слабые события". К сожалению, единственный способ получить слабые события на 100% - это поддержка CLR. Microsoft, похоже, не заинтересована в предоставлении этой поддержки.

Я рекомендую вам "слабые события Google в С#" и начинаю читать. Вы найдете много разных подходов к решению проблемы, но вы должны знать об их ограничениях. Нет 100% -ного решения.

Ответ 2

Как реализовать хороший старый IDisposable?

        class TestMemoryLeak : IDisposable
        {
              public event EventHandler AnEvent;
              private bool disposed = false;

           internal TestMemoryLeak()
           {
                 AnEventListener leak = new AnEventListener();
                 this.AnEvent += (s, e) => leak.OnLeak();
                AnEvent(this, EventArgs.Empty);
           }

           protected virtual void Dispose(bool disposing)
           {
              if (!disposed)
               {
                 if (disposing)
                 {
                      this.AnEvent -= (s, e) => leak.OnLeak();
                 }
                 this.disposed = true;
                }

            }

           public void Dispose() 
           {
                this.Dispose(true);
                GC.SupressFinalize(this);
           }

    }

Ответ 3

Я бы рекомендовал использовать профилировщик .NET памяти, чтобы понять суть этого вопроса, есть несколько - лично я использовал Red Gate ANTS профайлер памяти в прошлом, у которого есть 14-дневная бесплатная пробная версия:

http://www.red-gate.com/products/ants_memory_profiler/walkthrough.htm

Ответ 4

Расширение идеи IDisposable, которую предложил @Max Малыгин:

В приведенном ниже коде показано, как проверить выдающиеся обработчики на событии.

Класс имеет событие Tick, которое срабатывает один раз в секунду. Когда вызывается Dispose, код перечисляет обработчики в списке вызовов (если они есть) и выводит имя класса и метода, все еще подписанное на событие.

Программа создает экземпляр объекта, прикрепляет обработчик события, который записывает "галочку" при каждом запуске события, а затем спит в течение 5 секунд. Затем он удаляет объект без отмены подписки на обработчик событий.

using System;
using System.Diagnostics;
using System.Threading;

namespace testo
{
    public class MyEventThing : IDisposable
    {
        public event EventHandler Tick;
        private Timer t;

        public MyEventThing()
        {
            t = new Timer((s) => { OnTick(new EventArgs()); }, null, 1000, 1000);
        }

        protected void OnTick(EventArgs e)
        {
            if (Tick != null)
            {
                Tick(this, e);
            }
        }

        ~MyEventThing()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        private bool disposed = false;
        private void Dispose(bool disposing)
        {
            if (!disposed)
            {
                if (disposing)
                {
                    t.Dispose();
                    // Check to see if there are any outstanding event handlers
                    CheckHandlers();
                }

                disposed = true;
            }
        }

        private void CheckHandlers()
        {
            if (Tick != null)
            {
                Console.WriteLine("Handlers still subscribed:");
                foreach (var handler in Tick.GetInvocationList())
                {
                    Console.WriteLine("{0}.{1}", handler.Method.DeclaringType, handler.Method.Name);
                }
            }
        }

    }

    class Program
    {
        static public long Time(Action proc)
        {
            Stopwatch sw = Stopwatch.StartNew();
            proc();
            return sw.ElapsedMilliseconds;
        }

        static int Main(string [] args)
        {
            DoIt();
            Console.WriteLine();
            Console.Write("Press Enter:");
            Console.ReadLine();
            return 0;
        }

        static void DoIt()
        {
            MyEventThing thing = new MyEventThing();
            thing.Tick += new EventHandler(thing_Tick);
            Thread.Sleep(5000);
            thing.Dispose();
        }

        static void thing_Tick(object sender, EventArgs e)
        {
            Console.WriteLine("tick");
        }
    }
}

Вывод:

Handlers still subscribed:
testo.Program.thing_Tick

Ответ 5

Вы можете попробовать это на WinDbg

• Dump Target Obj, чтобы получить таблицу методов: ! dumpobj 01e19248
• Таблица методов дампа, чтобы найти в нем 0040C060: ! dumpmt -md 0ced1910
• Если нет совпадения, Dump память, которая начинается с адреса _methodPtr: ! u 0040C060
• Найдите инструкцию JMP или MOVE и дамп их адрес, например: ! u 0cf54930

Посетите здесь для более подробной информации: http://radheyv.blogspot.com/2011/04/detecting-memory-leaks-in-silverlight.html