Обрабатывает утечку (тип события) в приложении .NET.

События являются основным источником утечек памяти в .Net, а AutoResetEvent и ManualResetEvent имеют очень плохие имена. Они не являются причиной.

Когда вы видите что-то вроде этого:

myForm.OnClicked += Form_ClickHandler

Именно о таком событии идет речь. Когда вы регистрируете обработчик событий, источник события (например, OnClicked) сохраняет ссылку на обработчик. Если вы создаете и регистрируете новые обработчики, вы ДОЛЖНЫ отменить регистрацию события (например, myForm.OnClicked -= Form_ClickHandler), иначе использование вашей памяти будет продолжать расти.

Для получения дополнительной информации:

• Почему и как избежать утечек памяти обработчика событий?
• Утечка памяти событий C#

Этот ответ немного запоздал, но я только что наткнулся на этот вопрос, исследуя очень похожую проблему в некотором моем коде, и нашел ответ, поместив точку останова в системный вызов при дизассемблировании CreateEvent. Надеюсь, этот ответ будет полезен другим людям, даже если уже слишком поздно для вашего конкретного случая использования.

Ответ заключается в том, что .NET создает объекты ядра Event для различных примитивов потоковой передачи, когда возникает конкуренция. Примечательно, что я сделал тестовое приложение, которое может показать, что они создаются при использовании оператора «lock», хотя, по-видимому, любой из примитивов потоковой передачи Slim будет выполнять подобное ленивое создание.

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

Я вставил свой тестовый код ниже, который продемонстрирует утечку в небольшом масштабе (около 100 просочившихся дескрипторов событий на моей тестовой машине — ваш пробег может отличаться).

Несколько конкретных интересных моментов:

• После очистки списка и запуска GC.Collect() все созданные дескрипторы будут очищены.

• Установка для ThreadCount значения 1 предотвратит создание любых дескрипторов событий.

• Аналогично, комментирование оператора lock не приведет к созданию дескрипторов.

• Удаление ThreadCount из вычисления index (строка 72) резко уменьшит конкуренцию и, таким образом, предотвратит создание почти всех дескрипторов.

• Независимо от того, как долго вы позволяете ему работать, он никогда не создаст более 200 дескрипторов (кажется, что .NET по какой-то причине создает 2 для каждого объекта).

using System.Collections.Generic;
using System.Threading;

namespace Dummy.Net
{
    public static class Program
    {
        private static readonly int ObjectCount = 100;
        private static readonly int ThreadCount = System.Environment.ProcessorCount - 1;

        private static readonly List<object> _objects = new List<object>(ObjectCount);
        private static readonly List<Thread> _threads = new List<Thread>(ThreadCount);

        private static int _currentIndex = 0;
        private static volatile bool _finished = false;
        private static readonly ManualResetEventSlim _ready = new ManualResetEventSlim(false, 1024);

        public static void Main(string[] args)
        {
            for (int i = 0; i < ObjectCount; ++i)
            {
                _objects.Add(new object());
            }

            for (int i = 0; i < ThreadCount; ++i)
            {
                var thread = new Thread(ThreadMain);
                thread.Name = $"Thread {i}";
                thread.Start();
                _threads.Add(thread);
            }

            System.Console.WriteLine("Ready.");

            Thread.Sleep(10000);

            _ready.Set();
            System.Console.WriteLine("Started.");

            Thread.Sleep(10000);

            _finished = true;

            foreach (var thread in _threads)
            {
                thread.Join();
            }

            System.Console.WriteLine("Finished.");

            Thread.Sleep(3000);

            System.Console.WriteLine("Collecting.");

            _objects.Clear();
            System.GC.Collect();

            Thread.Sleep(3000);

            System.Console.WriteLine("Collected.");

            Thread.Sleep(3000);
        }

        private static void ThreadMain()
        {
            _ready.Wait();

            while (!_finished)
            {
                int rawIndex = Interlocked.Increment(ref _currentIndex);
                int index = (rawIndex / ThreadCount) % ObjectCount;
                bool sleep = rawIndex % ThreadCount == 0;

                if (!sleep)
                {
                    Thread.Sleep(10);
                }

                object obj = _objects[index];
                lock (obj)
                {
                    if (sleep)
                    {
                        Thread.Sleep(250);
                    }
                }
            }
        }
    } 
}