События в си шарп

События и делегаты

В Заметке о консольных и оконных (Windows Forms) приложениях мы отметили существенную разницу между ними. Консольное приложение реализует концепцию императивного (процедурного) программирования, а управление Windows-приложением основано на понятии события (event). События могут создаваться как пользователем, так и возникать в процессе выполнения приложения. Начнем с простых вещей.

Создадим оконное приложение и запустим его на выполнение. С пустой формой мы можем выполнить только несколько стандартных действий: изменить размер, свернуть, свернуть в окно/развернуть и закрыть приложение.

Для изменения размеров формы подведем указатель мыши (1 событие) к любой ее границе (указатель изменит свою форму), перетянем ее в нужном направлении (2 событие) и отпустим кнопку (3 событие). Последние три действия с формой выполняются после клика мышью (событие 4) на кнопках формы.

Ясно, что такое приложение нам не слишком интересно, тем не менее, очевидна связь между событиями и действиями.

Перенесем с Панели элементов на форму объект «Кнопка» (по умолчанию – button1 класса Button). На вкладке «Конструктор» кнопка видна, на вкладке «Код» о ней нет никакой информации. Однако раскрыв файл Form1.Designer.cs, мы увидим в описании класса Form1 поле:

private System.Windows.Forms.Button button1;

которое задает этот объект, а в методе private void InitializeComponent() обнаружим описание его свойств (имя, местоположение, размер, надпись и т.п.).

Запустим программу снова на выполнение. Нажатие на кнопку (событие) не влечет за собой никаких действий (кроме того, что между нажатием и отпусканием кнопки она подсвечивается).

Смотрим книгу «для чайников». В ней написано: чтобы связать это событие с каким-либо действием необходимо всего лишь выполнить двойной клик на кнопке, в окне кода появится заготовка для метода – обработчика события Click:

private void button1_Click(object sender, EventArgs e)
<
…
>

Увеличим ширину кнопки примерно в три раза. Вставим в тело метода между фигурными скобками оператор:
button1.Text = DateTime.Now.ToString();
Теперь при нажатии кнопки непосредственно на ней мы можем прочитать текущие дату и время нажатия на кнопку.

«Выдающийся» результат! Есть событие, есть реакция на него (обработка события). Как Вам такая автоматизация программирования!

Заметим, что в панели Свойства для объекта button1 на закладке События (щелчок на «желтой молнии») напротив события Click появился метод button1_Click. В окне кода добавили всего один метод с одним оператором в его теле. Что же еще изменилось? Посмотрим содержимое файла Form1.Designer.cs. В нем добавилась загадочная строка:

this.button1.Click += new System.EventHandler(this.button1_Click);

Расшифруем ее. Ключевое слово this – это ссылка на текущий объект Form1 (забавно, что имя объекта совпадает с именем класса). Объект button1 размещен на форме Form1. А Click – очевидно это событие, клик на кнопке. EventHandler – делегат (delegate), представляет метод, который будет обрабатывать событие, не имеющее данных (объявлен в библиотеке System). Тип события обязательно должен совпадать с типом делегата. В скобках указывается имя этого метода button1_Click.
Переведем смысл оператора на русский язык:
Объект.Событие += new Делегат(Метод_обработки);
Символ + определяет подписку обработчика события.
Очевидный вывод: Подписка на событие с использованием делегата приводит к вызову метода при возникновении события.

Возможен ли разрыв связи между событием и методом его обработки? И нет ли у вас ощущения статичности таких связей? Можно ли то же самое достичь программным путем?

Реализуем второй вариант действий:
1) поместим кнопку button1 на форме Form1;
2) в конструктор формы добавим один оператор, тогда:
public Form1()
<
InitializeComponent();
button1.Click += new System.EventHandler(button1_Click);
>
3) в описание класса добавим метод:
private void button1_Click(object sender, EventArgs e)
<
button1.Text = DateTime.Now.ToString();
>
4) запустим программу на выполнение, сравним результаты;
5) появился ли оператор подключения в файле FormDesigner.cs ?

Заметим, что этот файл Form1.Designer.cs является текстовым описанием формы и размещенных на ней элементов после запуска программы, что позволяет отобразить ее в режиме конструктора.

Далее многое можно изменять программным путем.

Итак, событие – это сообщение другим объектам программы, что произошло какое-то действие. Действие может быть инициировано пользователем (нажатие клавиши) или же в результате выполнения какого-то фрагмента программы (по условию).

Объект, который вызывает событие, называется отправителем (sender) сообщения, а объект, который сообщение получает – получателем. Роль «почтальона» выполняет делегат. Получатель сообщения имеет метод, который автоматически выполняется в ответ на исходное событие. В нашем примере отправителем и получателем сообщения является объект button1 («makes himself»).

Платформа .NET Framework поддерживает простое программирование событий, из-за чего начинающие программисты часто не вникают в работу событий.

Событием в языке C# называется сущность, предоставляющая две возможности: сообщать об изменениях, а для его пользователей — реагировать на них. В объявлениях классов визуальных компонентов мы найдем большое количество событий, которые могут быть вам полезны. Подсчитайте, сколько событий связано с формой? У меня получилось – 76. А для кнопки – 58, не мало? Если же вам необходимо создать собственное событие, то вы можете его просто объявить:

public event EventHandler myEvent;

Рассмотрим, из чего состоит объявление. Сначала идут модификаторы события, затем ключевое слово event, после него — тип события, который обязательно должен быть типом-делегатом, и идентификатор события, то есть его имя myEvent. Ключевое слово event сообщает компилятору о том, что это не публичное поле, а специальным образом раскрывающаяся конструкция, скрывающая от программиста детали реализации механизма событий (пока это замечание пропустите).

В C# разрешается формировать какие угодно разновидности событий. Но ради совместимости программных компонентов со средой .NET Framework следует придерживаться рекомендаций, которые по существу, сводятся к следующему требованию: у обработчиков событий должны быть два параметра. Первый из них — ссылка на объект, формирующий событие, второй — параметр типа EventArgs, содержащий любую дополнительную информацию о событии, которая требуется обработчику. То есть:

void обработчик(object отправитель, EventArgs е)

Как правило, отправитель — это параметр, передаваемый вызывающим кодом с помощью ключевого слова this. Параметр е типа EventArgs содержит дополнительную информацию о событии и может быть проигнорирован, если он не нужен.
Отметим, что и в первом примере с кнопкой автоматически сгенерировался заголовок метода, обеспечивающего обработку клика мышкой:
private void button1_Click(object sender, EventArgs e)
Сам класс EventArgs не содержит полей, которые могут быть использованы для передачи дополнительных данных обработчику, он служит в качестве базового класса, от которого получается производный класс, содержащий все необходимые поля. Тем не менее, в классе EventArgs имеется одно поле Empty типа static, которое представляет собой объект типа EventArgs без данных.
В среде .NET Framework предоставляется встроенный обобщенный делегат под названием EventHandler . В данном случае тип TEventArgs обозначает тип аргумента, передаваемого параметру EventArgs события.
Для обработки многих событий параметр типа EventArgs оказывается ненужным. Поэтому с целью упрощения создания кода в подобных ситуациях в среду .NET Framework и был внедрен необобщенный делегат типа EventHandler, используемый для объявления обработчиков событий, которым не требуется дополнительная информация о событиях (см. наш первый пример).

Читать еще: Модуль math паскаль

Пример использования обобщенного делегата EventHandler

Обобщенный делегат EventHandler используется для
объявления события Ez:

public event EventHandler Ez;

Аргументы, передаваемые в метод, задаются в классе MyEA, который наследуется от класса EventArgs.

Постановка задачи «Управление размерами и цветом формы»

Набор цветов: Red, Green, Blue, Yellow + исходный (добавляйте любые!)
Размеры: 500х150, 550×200, 600×250, 650×300

Элементы управления:
Кнопка button1 — Разрешение/Запрет изменение свойств формы
Кнопка button2 — Перекраска формы в желтый цвет без ограничений
Элемент comboBox1 — для выбора цвета: Red, Green, Blue, прежний
Метка label1 — подсказка: «Выберите цвет закраски формы» к comboBox1.

Начальная форма может выглядеть так:

Создаются два класса:
1) Класс Моих Событий Аргументы:

2) Мой класс Обработка события:

Далее приводится текст файла Form1.cs с комментариями:

Вид формы после перекраски:

Примеры

Другой пример применения делегатов рассмотрен в посте «Делегаты и методы».

События

Дата изменения: 07.10.2017

События C# представляют собой инструмент автоматического уведомления одного класса или объекта о произошедших изменениях в других.

Событие объявляется в классе (являются членами класса), в котором должно произойти событие, этот класс называется издателем. Класс, который информируется о произошедшем событии называется подписчиком.

Что такое события

Событием могут быть любые изменения переменных класса, но чаще всего события применяются в интерфейсе программы. В части взаимодействия с пользователем: нажатие на кнопку, ввод значения в поле, нажатие контрольных клавиш на клавиатуре, выбор пункта меню.

Один подписчик может быть принимать события от нескольких издателей. Обратное тоже верно: один издатель может информировать о событии нескольких подписчиков.

На класс издатель возлагаются функция определение момента возникновения события, на класс подписчик – инструкции, которые должны быть выполнены при его возникновении.

Создание событий

События создаются в три этапа:

объявление события в классе-издателе, то есть создание делегата по сигнатуре методов, которые будут вызваны;

создание методов, которые будут вызваны при возникновении событий в классах подписчиках;

подписка на события, то есть связывание события и делегата (а соответственно и методов).

Если событие в классе объявлено, но не связано подпиской с членами другого класса, оно никогда не возникнет.

По сути разработка событий – это организация обратного вызова метода с помощью делегата. А сам объект события – это делегат со ссылкой на метод. Метод класса подписчика называется обрабочкиком событий.

Для описания событий в .NET Framework описан класс EventArgs и делегат EventHandler.

Объявление события

События объявляются в блоке видимости класса с помощью ключевого слова event (по-английски событие) типа делегата и модификаторов доступа:

В предыдущем примере объявлен делегат, принимающий ссылку на метод с одним параметром типа string и возвращающий значение типа void. В строке ниже делегат ассоциируется с событием. Тип делегата задает событие. Слово Anounesment задает имя события.

Код легко сократить, если использовать встроенный тип делегата Action .

Для простоты примера модификатором доступа к делегату и событию были выбран public, который делает событие доступным вне класса. Модификатор может быть любым, в зависимости от задач программиста. Следует учитывать, что, если модификатор доступа не указан, он неявно прописывается как private.

Теперь реализуем метод, который будет вызывать событие, дополнив класс соответствующим методом:

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

Для того чтобы этот код сработал требуется (возникло событие) нужно: определить обработчик события, то есть метод, вызванный по возникновению события и добавить ссылку на метод в делегат.

Обработка событий

Для добавления и удаления ссылок на методы в события используются пара операторов: += и -=. Первый – добавляет, второй удаляет метод из таблицы ссылок в событии (делегате). Процедура добавления ссылки называется оформлением подписки, а удаления – удалением подписки.

В предыдущем примере в качестве обработчика событий использован именованный статический метод Show_String, его легко заменить на анонимный метод или лямбда-выражение. Запись в таком случае стане заметно лаконичнее:

Шаблон делегата событий

В предыдущих разделах, для хранения ссылки на метод обработки событий мы использовали один из шаблонных делегатов библиотеки типов .NET framework – Action . Однако, на практике гораздо чаще встречается применение шаблонного делегата событий EventHandler.

Вот его определение:

Как видно из определения EventHandler – void-делегат с двумя параметрами. Первый – типа object, ссылка на объект, который вызвал событие. Второй типа EventArgs хранит служебную информацию о конкретном событии.

WPF содержит несколько сотен специализированных делегатов, соответствующих своему элементу интерфейса. Каждый из этих делегатов вторым параметром содержит класс, производный от EventArgs.

Сам класс EventArgs не несет в себе никаких полезных свойств или методов и является потомком Object. Он создан для того, чтобы программисты придерживались его объявления при объявлении собственных событий.

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

Также необходимо создать класс-потомок EventArgs, который будет информировать обработчик события о событии:

Использование измененного класса:

Использование шаблонного делегата удобно при разработке приложения большой группой программистов, поскольку они универсально, и опытные программисты обычно ожидают, что делегаты будут реализованы именно в такой форме. Будет проще понять замысел в коде программиста, если он придерживался рекомендаций MSDN, то есть использовал шаблонные делегаты.

Event C# | События и делегаты C#

События C# в программировании чем-то похожи на события в повседневной жизни. Рождение, первый шаг, первый день в школе и тому подобное. Разумеется, для программы значимые события выглядят немного иначе. К примеру, загрузилась форма, изменилось значение поля или был создан объект. Понимать события крайне полезно. Но в первую очередь необходимо изучить делегаты C#.

Читать еще: Графический режим паскаль

Делегаты C#

Итак, механика событий достаточно проста. Предположим, для класса Character, рассмотренного ранее, мы хотим создать событие. У персонажа могут меняться любые параметры. Для начала обработаем изменение имени персонажа. Персонаж в данном случае является издателем события. Другие классы могут подписаться на получение этого event. Чтобы издатель смог вызвать метод подписчика, зарегистрированный на события, методы должны иметь определенный формат.

И вот мы вплотную подошли к делегатам. По сути своей, это тип, определяющий полную сигнатуру метода события. К примеру, так описывается делегат, не имеющий параметров.

На самом деле, подобное описание делегатов не обязательно. Однако рекомендуется использовать общепринятое соглашение: первый параметр — издатель, второй — объект с параметрами. Класс EventArgs не содержит данных по событию. При необходимости передать что-либо подписчику, необходимо унаследовать этот класс и наделить потомка необходимыми свойствами.

События C# и их вызовы

Делегат, в первую очередь, описывает метод подписчика. Также делегат сообщает издателю, какой метод будет вызван. Делегаты одного класса могут использоваться в разных событиях и издателях. Итак, добавим событие с именем NameChanged класса EventHandler.

Обязательно нужно указывать модификатор public, чтобы к событию был доступ извне. Для генерации event нужно просто вызвать его, как обычный метод.

Далее, рассмотрим, как может выглядеть свойство Name.

И, соответственно, рассмотрим пример использования в консольном приложении.

Для того, чтобы добавить обработчик события, используется +=. Если же нужно обработчик удалить, используется -=. Первое время делегаты выглядят сложно и запутанно, однако спустя пару опытов, жизнь становится значительно проще.

Анонимные методы

Рассмотренный ранее вариант обработки событий прекрасен. Однако когда для реализации делегата достаточно пары строк, писать подобный код нерационально. Да и скучно, если таких событий множество. Для подобных ситуаций есть анонимные метод, позволяющие обрабатывать event. Рассмотрим обработку изменения имени при помощи анонимного метода.

После ключевого слова delegate в скобках указаны параметры, передаваемые обработчику события. Реализация обработки события описывается в круглых скобках. Анонимным метод зовется потому, как не имеет явно указанного имени.

Полагаю, это достаточный минимум для начала работы с событиями и делегатами. Удачных вам экспериментов, коллеги.

Кроме того, рекомендую прочитать статью Переменные C#. А также подписывайтесь на группу ВКонтакте, Telegram и YouTube-канал. Там еще больше полезного и интересного для программистов.

BestProg

События и делегаты. Понятие события. Взаимодействие между событиями

Содержание

1. Что такое событие в C#? Какая целесообразность использования событий в языке C#?

Событие – это автоматическое сообщение о том, что в программе состоялось некоторое действие.

На выполнение того или другого события программа может соответственно реагировать. Реакция на событие осуществляется с помощью так называемых обработчиков события. Обработчик события – это обычный метод, который выполняет некоторые действия в программе, в случае если состоялось (сгенерировалось) событие.

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

На рисунке 1 схематично отображена работа события MyEvent .

Рис. 1. Вызов цепи методов для события MyEvent

⇑

2. Какая общая форма объявления события? Ключевое слово event . Пример

Объявление события осуществляется на основе ранее объявленного типа делегата. Общая форма объявления события:

делегат_события – имя типа делегата, который используется для объявления события;
имя_события – конкретное имя объекта (переменной) типа «событие».

Пример. Объявление события с именем MyEvent на основе типа делегата MyDelType .

Более подробно об объявлении типа делегата и объявлении переменной делегата описывается в теме:

⇑

3. Какие требования к делегату, который будет использоваться для обработки события?

Для того, чтобы можно было обрабатывать (запускать) списки обработчиков события, делегат не должен возвращать значение. То есть, делегат может возвращать тип void .

Если делегат возвращает значение, то вызывается последний метод (обработчик) из сформированного списка методов.

⇑

4. Какие требования относятся к методу, который может быть обработчиком некоторого события?

Основное требование – метод может иметь точно такую же сигнатуру как и делегат, на основе которого объявлено событие.

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

⇑

5. Как осуществляется регистрация метода в событии? Пример

Чтобы зарегистрировать метод для обработки данного события нужно использовать операторы ‘=’ или ‘+=’ .

Пример.

Пусть в теле некоторого класса объявляется:

событие с именем MyEvent ;
метод обработки события (обработчик события) MyMethod1() ;
обработчик события MyMethod2() ;
обработчик события MyMethod3() .

Методы имеют точно такую же сигнатуру, как и тип делегата, на основе которого объявлено событие MyEvent . Чтобы зарегистрировать методы MyMethod1() , MyMethod2() , MyMethod3() для события MyEvent нужно написать следующий программный код:

В этом случае образуется список (цепочка) из трех методов. Методы в списке идут в той же последовательности, в которой они были зарегистрированы (добавлены) в событие.

Если методы не возвращают никакого значения, то при вызове события будут выполняться все методы с списке в порядке их добавления. Если методы возвращают значение, то при вызове события будет выполняться последний метод из списка.

⇑

6. Какая последовательность шагов в программе для организации списка обработчиков событий, которые будут вызваться при вызове (запуске) события

Чтобы организовать список обработчиков события (методов) нужно выполнить такую последовательность шагов:

Объявить тип делегата в классе.
Объявить событие в данном классе или создать другой класс, который содержит объявления события.
В некотором методе (программном коде) создать список обработчиков (методов), которые будут вызываться при вызове данного события. Это осуществляется с помощью операторов ‘=’ и ‘+=’ . Создание списка означает регистрацию обработчиков для данного события.
Вызвать событие (запустить на выполнение) из этого метода.

⇑

7. Пример использования события для случая если методы и события объявлены в одном классе

⇑

8. Пример использования события, которое объявлено в отдельном классе. Обработчики события объявлены в другом классе

Пусть в модуле CalcFigures.cs объявлен класс, содержащий следующее описание

Читать еще: Паскаль изучение с нуля

В другом модуле Form1.cs объявлен класс, который демонстрирует использование методов из класса CalcFigures . Листинг модуля Form1.cs следующий:

События в си шарп

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

Событие – это сообщение другим объектам программы, что произошло какое-то действие. Действие может быть вызвано пользователем, например нажатие мыши, или же другими элеметами программы. Объект, который вызывает событие называется отправитель сообщения, а объект, который сообщение получает – получатель. Получатель сообщения имеет метод, который автоматически выполняется в ответ на событие.

Платформа .NET Framework поддерживает простое программирование событий. Это настолько просто, что очень часто программисты не знают закулисную работу событий. Всё что нужно знать: если вы хотите получить событие от контрола, вы должны подписать обработчик события:

К примеру, если вы хотите подписаться к нажатию на кнопку button1 и чтобы это событие обрабатывал метод button1_Click, необходимо написать следующее:

После этого вы должны определить метод-обработчик следующим образом:

Метод не обязательно должен быть скрытым (private), но он должен принимать два аргумента:
объекты типа Object и EventArgs. Теперь давайте рассмотрим создание наших собственных событий.

Предположим мы хотим создать событие MyEvent для элемента MyControl унаследованого от UserControl:

1. Первое что необходимо сделать – определить открытый делегат, который будет принимать два параметра: sender типа object и e типа MyEventArgs:

2. MyEventArgs – это объет содержащий данные, которые будут пересылаться от отправителя к получателю. MyEventArgs должен быть унаследован от System.EventArgs класса. Определим в нашем простанстве имен новый класс:

3. Определим событие MyEvent в классе нашего контрола:

4. Теперь, в классе нашего контрола (MyControl) необходимо определить метод с именем которое соостоит из приставки On и названия нашего события. Поскольку наше событие мы назвали MyEvent, то метод будет называться OnMyEvent. Обратите внимание, что метод имеет один аргумент типа MyEventArgs. Внутри этого метода мы будем вызывать событие. В C# вызов события достигается путем вызова имени события:

5. Теперь, все что осталось сделать, это вызвать OnMyEvent из любого места. Откуда именно это сделать, зависит от того, что именно должно вызвать событие.

Теперь перейдем к практике. Мы создадим элемент управления, который будет похож на доску (10 х 10) в которой пользователь может вводить текст. Кроме того, существует курсор, который показывает текущую позицию редактирования. Пользователь может использовать комбинации клавиш, как например Ctrl+R, Ctrl+G, Ctrl+B чтобы изменять фоновый цвет элемента и Ctrl+Alt+R, Ctrl+Alt+G, Ctrl+Alt+B чтобы изменять цвет текста. Мы усовершенствуем наш элемент двумя событиями:

ClineChanged – событие будет возникать, когда будет изменяться вертикальная позиция курсора
ColumnChanged – при изменении гризонтальной позиции

После этого мы будем перехватывать эти события для динамического обновления метки, которая показывает текущее положение курсора. Дальше идет краткое описание нашего эелемента:

Элемент содержит двумерный массив, который в свою очередь содержит символы вводимые пользователем. В конструкторе класса все элементы массива устанавливаются в пробелы.
В методе OnPaint будут рисоваться символы в элементе строка за строкой, символ за символом.
Курсор рисуется в отдельном потоке caretThread. Данный поток запускается в конструкторе класса и завязан на метод ShowsCaret. Этот метод содержит замкнутый цыкл, который показывает и прячет курсор каждые 350 милисекунд
Поток caretThread завершается, когда удаляется элемент управления. Нами будет усовершенствован метод Dispose
KeyPressed и ProcessDialogKey

отслеживают нажатия клавиш

Определим всего два свойства CaretX и CaretY которые могут быть использованы для получения и изменения позиции курсора

Начнем с добавления событий нашему элементу управления: LineChanged и ColumnChanged. Определим два делегата для наших событий:

Определим и реализуем LineEventArgs и ColumnEventArgs:

У обеих классов конструкторы принимают два целочисленных значения: старое и новое. Оба класса имеют свойства доступные только для чтения. У класса LineEventArgs события OldLine и NewLine, а у класса ColumnEventArgs – OldColumn и NewColumn.

Теперь определим наши события LineChanged и ColumnChanged:

Следующим шагом будет создание двух вирутальных методов с модификатором доступа protected: OnLineChanged и OnColumnChanged. В OnLineChanged мы вызываем событие LineChanged и в OnColumnChanged – ColumnChanged:

Теперь неоходимо вызвать методы OnLineChanged и OnColumnChanged из класса нашего элемента управления. Событие LineChanged срабатывает, когда изменяется вертиальная координата курсора, т.е. при изменении значеня свойства CaretY. Похоже происходит и с событием ColumnChanged. Оно происходит при изменении начения свойства CaretX. Определим эти свойтсва:

С событиями разобрались теперь перейдем к внешнему виду нашего элемента управления.
Для начала определим поля:

В контрукторе класса заполним массив пробелами, подишемся на событие нажатия клавиш и создадим поток, который будет отображать курсор:

Метод, который будет отображать и скрывать курсор:

Переопределим метод OnPaint который будет отрисовывать наш элемент:

Теперь займемся обработкой нажатия клавиш. Здесь будут использоваться два ообработчика события: ProcessDialogKey и KeyPressed:

Осталось изменить метод Dispose – удаление объекта. Для этого, открываем файл MyControl.Designer.cs и в нем изменяем метод Dispose

Теперь, после сборки проекта, мы можем использовать наш элемент управления. Для этого, создадим Windows Forms Application в нашем решении (рис. 1). Я назвал приложение MyControlTest:

Рис.1 Добавление проекта для теста

Для того, чтобы добавить наш элемент управления: Tools -> Choose Toolbbox Item. В появившемся окне на влкадке .NET Framework Components жмем Browse (Рис. 2).

Рис. 2 Добавить элемент управления

Далее выбираем наш контрол. В моем случае, он находится в папке с проектом MyControl в подпаке Debug (у Вас может находится в папке Release). После добавления на панели компонентов должен появиться наш элемент управления (Рис. 3) (о том, как изменить стандартную иконку на свою, читайте здесь).