Как сгенерировать событие c

# Events

An event is a notification that something has occurred (such as a mouse click) or, in some cases, is about to occur (such as a price change).

Classes can define events and their instances (objects) may raise these events. For instance, a Button may contain a Click event that gets raised when a user has clicked it.

Event handlers are then methods that get called when their corresponding event is raised. A form may contain a Clicked event handler for every Button it contains, for instance.

# Declaring and Raising Events

# Declaring an Event

You can declare an event on any class or struct using the following syntax:

There is an expanded syntax for declaring events, where you hold a private instance of the event, and define a public instance using add and set accessors. The syntax is very similar to C# properties. In all cases, the syntax demonstrated above should be preferred, because the compiler emits code to help ensure that multiple threads can safely add and remove event handlers to the event on your class.

# Raising the Event

Note that events can only be raised by the declaring type. Clients can only subscribe/unsubscribe.

For C# versions before 6.0, where EventName?.Invoke is not supported, it is a good practice to assign the event to a temporary variable before invocation, as shown in the example, which ensures thread-safety in cases where multiple threads execute the same code. Failing to do so may cause a NullReferenceException to be thrown in certain cases where multiple threads are using the same object instance. In C# 6.0, the compiler emits code similar to that shown in the code example for C# 6.

# Creating cancelable event

A cancelable event can be raised by a class when it is about to perform an action that can be canceled, such as the FormClosing

To create such event:

Create a new event arg deriving from CancelEventArgs

Example

In the below example, we create a PriceChangingEventArgs event for Price property of a class. The event data class contains a Value which let the consumer know about the new . The event raises when you assign a new value to Price property and lets the consumer know the value is changing and let them to cancel the event. If the consumer cancels the event, the previous value for Price will be used:

PriceChangingEventArgs

Product

# Event Properties

If a class raises a large the number of events, the storage cost of one field per delegate may not be acceptable. The .NET Framework provides event properties

(opens new window) for these cases. This way you can use another data structure like EventHandlerList

(opens new window) to store event delegates:

This approach is widely used in GUI frameworks like WinForms where controls can have dozens and even hundreds of events.

Note that EventHandlerList is not thread-safe, so if you expect your class to be used from multiple threads, you will need to add lock statements or other synchronization mechanism (or use a storage that provides thread safety).

# Standard Event Declaration

Event handler declaration:

Subscribing to the event:

Dynamically:

Through the Designer:

1. Click the Events button on the control’s properties window (Lightening bolt)
2. Double-click the Event name:

1. Visual Studio will generate the event code:

Invoking the method:

# Anonymous Event Handler Declaration

Event handler declaration using lambda operator =>

(opens new window) and subscribing to the event:

Event handler declaration using delegate

(opens new window) anonymous method syntax:

Declaration & subscription of an event handler that does not use the event’s parameter, and so can use the above syntax without needing to specify parameters:

Invoking the event:

# Non-Standard Event Declaration

Events can be of any delegate type, not just EventHandler and EventHandler<T> . For example:

This is used similarly to standard EventHandler events:

It is possible to declare multiple events of the same type in a single statement, similar to with fields and local variables (though this may often be a bad idea):

This declares three separate events ( Event1 , Event2 , and Event3 ) all of type EventHandler .
Note: Although some compilers may accept this syntax in interfaces as well as classes, the C# specification (v5.0 §13.2.3) provides grammar for interfaces that does not allow it, so using this in interfaces may be unreliable with different compilers.

# Creating custom EventArgs containing additional data

Custom events usually need custom event arguments containing information about the event. For example MouseEventArgs

(opens new window) which is used by mouse events like MouseDown or MouseUp events, contains information about Location or Buttons which used to generate the event.

When creating new events, to create a custom event arg:

Create a class deriving from EventArgs

Example

In the below example, we create a PriceChangingEventArgs event for Price property of a class. The event data class contains a CurrentPrice and a NewPrice . The event raises when you assign a new value to Price property and lets the consumer know the value is changing and let them to know about current price and new price:

PriceChangingEventArgs

Product

You can enhance the example by allowing the consumer to change the new value and then the value will be used for property. To do so it’s enough to apply these changes in classes.

Change the definition of NewPrice to be settable:

Change the definition of Price to use e.NewPrice as value of property, after calling OnPriceChanging :

# Parameters

# Remarks

When raising an event:

Always check if the delegate is null . A null delegate means the event has no subscribers. Raising an event with no subscribers will result in a NullReferenceException .

Copy the delegate (e.g. EventName ) to a local variable (e.g. eventName ) before checking for null / raising the event. This avoids race conditions in multi-threaded environments:

Wrong:

Right:

Use the null-conditional operator (?.) for raising the method instead of null-checking the delegate for subscribers in an if statement: EventName?.Invoke(SenderObject, new EventArgsT());

When using Action<> to declare delegate types, the anonymous method / event handler signature must be the same as the declared anonymous delegate type in the event declaration.

События и делегаты в С# и C++

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

В данной статье речь зайдет о том, что такое event. Примеры будут разобраны на языках СИ-семейства – C# и C++. Это одни из самых перспективных ЯП в сфере объектно-ориентированного программирования.

Термины – базовые понятия

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

Каждый разработчик должен помнить следующие определения:

1. Алгоритм – набор операций и инструкций, а также указаний, с помощью которого удается решать поставленные изначально задачи.
2. API — интерфейс прикладного программирования. Представлен правилами и инструкциями, помогающими создавать утилиты.
3. Аргументы – значения, передаваемые в команды и функции.
4. Оператор – то, что манипулирует компонентами кода через операнды.
5. Операнд – объект, которым можно управлять через операторы.
6. Переменная – именованная ячейка памяти, которая зарезервирована системой. Хранилище данных в программе.
7. Объект – связанные между собой переменные, структурные единицы и константы, которые выбираются совместно, а также обрабатываются.
8. Класс – набор связанных объектов. У них должны быть общие свойства.
9. Тип данных – классификация электронных материалов определенного вида.
10. Массив – множество информации. Списки и группы схожих типов данных, которые предварительно проходят стадию группировки.
11. Итерация – один проход через заданный набор операций в коде.
12. Ключевое слово – зарезервированное синтаксисом ЯП слово. Помогает обозначать операции и функции. Ключевое слово не может выступать в качестве имени класса, переменной или иного компонента.
13. Указатели – переменные, содержащие адреса мест в памяти.

Также стоит обратить внимание на раскрытие понятия «метод». Это в объектно-ориентированном программировании – функция/процедура, которая относится к тому или иному классу, объекту. Включает в себя операторы и входные аргументы.

Событие – это…

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

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

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

Отдельное внимание стоит уделить типу, в котором прописано то или иное событие. Оно должно удовлетворять некоторым «условиям».

О типах и их возможностях

Тип, в котором было определено событие, позволяет:

1. Производить регистрацию обработчика событий. К ним относят статические или экземплярные методы, которые заинтересованы в получении уведомления о событии. Выполняют в ответ на event конкретные операции.
2. Отменять регистрацию компонента под названием «обработчик событий».
3. Уведомлять обработчик (если их несколько – все) о том, что операция произошла.

Стоит обратить внимание на то, что в C++ нет событий. При необходимости разработчику предстоит создать соответствующие «компоненты» на библиотечном уровне. Чуть позже будет рассмотрен один такой вариант, который предусматривает несколько классов. К ним относят Delegate и Event.

Делегаты

Модель event в C# базируется на делегатах. Аналогичным образом ситуация обстоит с .NET. Делегат – это тип, который содержит ссылку на метод. Он:

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

Для того, чтобы объявить делегат, достаточно определить его класс. В .NET соответствующий компонент имеет широкую область применения, как и в C#.

Вот пример объявления делегата в C#:

Public delegate void ThresholdReachedEventHander(object sender, ThresholdReachedEventArgs e);

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

События – ключевые моменты

Стоит обратить внимание на то, как правильно осуществлять работу с events. Далее будет представлена информация, помогающая обрабатывать «сообщения системы», объявлять их и корректировать при необходимости.

Определение и вызов

События в классе будут объявляться при помощи ключевого слова – event. После него требуется указать тип делегата, который представляет «происшествие».

1. Есть public class.
2. В самом начале осуществляется определение делегата AccountHandler. Он будет принимать один параметр вида string.
3. При помощи ключевого слова происходит создание некоторого event с именем Notify. Оно представляет delegate.
4. Название события может выступать в качестве произвольного. Оно обязательно представляет тот или иной делегат.

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

Можно вызвать event через метод Invoke(). Для этого предстоит передать в него желаемые значения для параметров.

А вот программа, которая послужит примером реализации рассмотренных операций:

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

Как добавить обработчик

В программировании можно добавлять один или несколько обработчиков. Это – то, что будет выполняться при вызове «происшествия». Часто это не классы, а методы. Каждый обработчик событий по списку заданных параметров и возвращаемому типу будет соответствовать делегату, которые представляет событие. Для того, чтобы добавить обработчик, нужно применить операцию «+=».

1. Используется метод DisplayMessage. Он соответствует delegate AccountHandler.
2. При вызове данных события будет обрабатываться соответствующий метод. Для параметра message передается строчка, встречающаяся в event.
3. В DisplayMessage осуществляется вывод полученного сообщения. При желании можно определить здесь совершенно любую логику.

После этого можно выделить самостоятельный класс Account в качестве библиотеки классов. После – использовать в своих проектах.

Удаление

В любой момент программист может провести создание или удаление обработчиков. Для удаления необходимо использовать операцию «-=».

Выше – то, как будет выглядеть соответствующий код.

Управление

Обработка events при помощи аксессоров может управляться разработчиком. Для этого используется add или remove. Такая функциональность встречается на практике редко. Здесь можно увидеть, как происходит удаление и добавление обработчика подобным образом.

Можно также передавать некоторые данные об events. Пример – добавление в программы, указанные выше, new класс AccountEventArgs. Он будет содержать такой код:

Этот класс обладает двумя свойствами:

• Message – хранение выводимого сообщения;
• Sum – содержит сумму, на которую изменился баланс.

Теперь можно применить класс AccountEventArgs, откорректировав класс Account:

Основная программа должна выглядеть так:

Как быть с C++

Обработка events в C++ — это более сложное понятие. Связано это с тем, что обработчиков у этого языка программирования нет. Предстоит работать с различными классами. Пример – Delegate и Event.

Класс Delegate

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

Класс Delegate дает существенное преимущество – ему можно передавать динамически указатели на методы и изменять поведение приложения. Перекомпиляция здесь не нужна. Софт будет оставаться в неведении о манипуляциях.

Выше – пример использования класса Delegate.

Класс Event

Событие – способ для класса относительно оповещения клиентов о том, что что-то произошло. Можно использовать Event в C++ для реализации рассматриваемого «компонента».

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

Выше – пример использования класса Event в C++ для обработки событий. А вот – видео-урок по рассмотренной теме в C#. Чтобы надписи типа static void, eventargs e, delegate и другие не вызывали трудности, стоит закончить специализированные дистанционные компьютерные курсы. В течение года с нуля пользователя там научат писать коды на выбранных языках. Есть как предложения для новичков, так и для опытных разработчиков.

C#: события (Events)

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

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

• регистрировать обработчики событий — статические или экземплярные методы, заинтересованные в получении уведомления о событии и выполняющие в ответ на это событие определенные действия;
• отменять регистрацию обработчиков событий;
• уведомлять зарегистрированные обработчики о том, что событие произошло.

Модель событий в C# основана на делегатах. По сути, событие — член типа, который ссылается на экземпляр любого объявленного ранее типа делегата. Регистрация обработчиков события осуществляется путем добавления методов-обработчиков в этот делегат. Отмена регистрации — путем удаления методов-обработчиков из делегата. А уведомление зарегистрированных обработчиков о наступлении события происходит путем вызова этого делегата.

Событие, как член типа, объявляется с помощью ключевого слова event . Событию также назначается область видимости с помощью одного из модификаторов доступа, тип — любой ранее объявленный тип делегата, и имя — любой допустимый идентификатор. При возникновении события нужно просто вызвать член-событие объекта, ссылающийся на делегат с обработчиками:

Особенность члена-события состоит в том, что даже если он объявлен с модификатором public вызван как делегат он может быть только внутри родительского типа, т.к. только родительский тип может генерировать событие. Внешние объекты могут только добавлять и удалять из члена-события свои обработчики с помощью операторов += и -= , как в обычный делегат.

Члены события могут быть виртуальными (virtual), переопределенными (overridden), абстрактными (abstract), запечатанными (sealed), а также статическими (static).

Стандартный шаблон события

.NET Framework предусматривает стандартный шаблон написания событий. Он предусматривает несколько моментов. Рассмотрим их по порядку на следующем примере:

Тип для хранения информации о событии

При возникновении события объект, в котором оно возникло, должен передать дополнительную информацию о событии объектам-получателям уведомления. Эта информация инкапсулируется в отдельный класс. По соглашению этот класс наследуется от типа System.EventArgs , а имя его должно заканчиваться суффиксом EventArgs .

Класс System.EventArgs содержит всего один член (статическое поле Empty ) и служит базовым классом для новых типов, посредством которых передается информация о событии. Выглядит он примерно так:

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

Определение члена-события

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

Типом для члена-события выступает предопределенный в .NET Framework обобщенный делегат System.EventHandler<TEventArgs> :

Делегат принимает два параметра. В качестве первого параметра source в делегат передается сам объект, в котором произошло событие, т.е. при вызове делегата в него передается this . В целях поддержки наследования передается он с базовым типом object , а не с конкретным типом, как это сделано для второго параметра.

Второй параметр — это объект с информацией о событии (класс которого создавался на первом этапе). Ему уже указывается конкретный тип, который передается в качестве параметра типа в делегат ( TEventArgs ). По соглашению в делегате и в методе-обработчике этот параметр называется e .

Делегат EventHandler возвращает void , соответственно методы-обработчики тоже должны возвращать void .

Метод, вызывающий член-событие

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

Метод принимает один параметр — объект с информацией о событии. Как минимум этот метод должен проверять, зарегистрированы ли в делегате члене-событии методы-обработчики, и если да, вызывать член-событие.

C# Language
События

Событие — это уведомление о том, что что-то произошло (например, щелчок мыши) или, в некоторых случаях, произойдет (например, изменение цены).

Классы могут определять события, и их экземпляры (объекты) могут создавать эти события. Например, кнопка может содержать событие Click, которое поднимается, когда пользователь щелкнул его.

Обработчики событий — это методы, которые вызываются при возникновении соответствующего события. Форма может содержать обработчик события Clicked для каждой кнопки, которая содержит, например.

параметры

замечания

При поднятии события:

• Всегда проверяйте, является ли делегат null . Нулевой делегат означает, что у события нет подписчиков. Поднятие события без подписчиков приведет к NullReferenceException .

• Скопируйте делегат (например, EventName ) в локальную переменную (например, eventName ), прежде чем проверять значение null / повышение события. Это позволяет избежать условий гонки в многопоточных средах:

Неправильно :

Справа :

• Используйте оператор с нулевым условием (?.) Для повышения метода вместо нулевой проверки делегата для подписчиков в выражении if : EventName?.Invoke(SenderObject, new EventArgsT());

• При использовании Action <> для объявления типов делегатов подпись анонимного метода / события должна быть такой же, как объявленный анонимный тип делегата в объявлении события.

Объявление и повышение активности

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

Вы можете объявить событие в любом class или struct используя следующий синтаксис:

Существует расширенный синтаксис для объявления событий, в котором вы держите частный экземпляр события и определяете открытый экземпляр, используя add и set accessors. Синтаксис очень похож на свойства C #. Во всех случаях синтаксис, продемонстрированный выше, должен быть предпочтительным, поскольку компилятор испускает код, чтобы гарантировать, что несколько потоков могут безопасно добавлять и удалять обработчики событий в событие на вашем классе.

Поднятие мероприятия

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

Для версий C # до 6.0, где EventName?.Invoke не поддерживается, рекомендуется назначить событие временной переменной перед вызовом, как показано в примере, что обеспечивает безопасность потоков в случаях, когда несколько потоков выполняют одинаковые код. В противном случае может возникнуть NullReferenceException в некоторых случаях, когда несколько потоков используют один и тот же экземпляр объекта. В C # 6.0 компилятор испускает код, подобный тому, который показан в примере кода для C # 6.

Стандартное объявление о мероприятии

Объявление обработчика события:

Подписка на событие:

1. Нажмите кнопку «События» в окне свойств элемента управления («Молниеносный болт»)
2. Дважды щелкните имя события:

1. Visual Studio создаст код события:

Объявление анонимного обработчика событий

Объявление обработчика события с помощью lambda operator => и подписки на событие:

Объявление обработчика события с использованием синтаксиса анонимного делегата делегата :

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

Нестандартная заявка на мероприятие

События могут иметь любой тип делегата, а не только EventHandler и EventHandler<T> . Например:

Это используется аналогично стандартным событиям EventHandler :

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

Это объявляет три отдельных события ( Event1 , Event2 и Event3 ) для всех типов EventHandler .
Примечание. Хотя некоторые компиляторы могут принять этот синтаксис как в интерфейсах, так и в классах, спецификация C # (v5.0 §13.2.3) предоставляет грамматику для интерфейсов, которые этого не позволяют, поэтому использование этого в интерфейсах может быть ненадежным для разных компиляторов.

Создание настраиваемых EventArg, содержащих дополнительные данные

Для пользовательских событий обычно требуются настраиваемые аргументы событий, содержащие информацию о событии. Например MouseEventArgs , который используется на события мыши , как MouseDown или MouseUp событий, содержит информацию о Location или Buttons , которые используются для генерации события.

При создании новых событий для создания настраиваемого события arg:

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

пример

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

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

Измените определение NewPrice :

Измените определение Price на использование e.NewPrice качестве значения свойства после вызова OnPriceChanging :

Создание отменяемого события

Отменное событие может быть поднято классом, когда он собирается выполнить действие, которое может быть отменено, например событие FormClosing Form .

Чтобы создать такое событие:

• Создайте новое событие arg from CancelEventArgs и добавьте дополнительные свойства для данных события.
• Создайте событие, используя EventHandler<T> и используйте созданный вами класс arg нового события cancel.

пример

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

Свойства события

Если класс вызывает большое количество событий, стоимость хранения одного поля на одного делегата может быть неприемлемым. .NET Framework предоставляет свойства событий для этих случаев. Таким образом, вы можете использовать другую структуру данных, такую ​​как EventHandlerList для хранения делегатов событий:

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

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