Object sender c что это
Для взаимодействия с пользователем в Windows Forms используется механизм событий. События в Windows Forms представляют стандартные события на C#, только применяемые к визуальным компонентам и подчиняются тем же правилам, что события в C#. Но создание обработчиков событий в Windows Forms все же имеет некоторые особенности.
Прежде всего в WinForms есть некоторый стандартный набор событий, который по большей части имеется у всех визуальных компонентов. Отдельные элементы добавляют свои события, но принципы работы с ними будут похожие. Чтобы посмотреть все события элемента, нам надо выбрать этот элемент в поле графического дизайнера и перейти к вкладке событий на панели форм. Например, события формы:
Чтобы добавить обработчик, можно просто два раза нажать по пустому полю рядом с названием события, и после этого Visual Studio автоматически сгенерирует обработчик события. Например, нажмем для создания обработчика для события Load :
И в этом поле отобразится название метода обработчика события Load. По умолчанию он называется Form1_Load .
Если мы перейдем в файл кода формы Form1.cs, то увидим автосгенерированный метод Form1_Load:
public partial class Form1 : Form < public Form1() < InitializeComponent(); >private void Form1_Load(object sender, EventArgs e) < >>
И при каждой загрузке формы будет срабатывать код в обработчике Form1_Load.
Как правило, большинство обработчиков различных визуальных компонентов имеют два параметра: sender — объект, инициировавший событие, и аргумент, хранящий информацию о событии (в данном случае EventArgs e ).
Но это только обработчик. Добавление же обработчика, созданного таким образом, производится в файле Form1.Designer.cs:
namespace HelloApp < partial class Form1 < private System.ComponentModel.IContainer components = null; protected override void Dispose(bool disposing) < if (disposing && (components != null)) < components.Dispose(); >base.Dispose(disposing); > private void InitializeComponent() < this.SuspendLayout(); this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; this.ClientSize = new System.Drawing.Size(284, 261); this.Name = "Form1"; // добавление обработчика this.Load += new System.EventHandler(this.Form1_Load); this.ResumeLayout(false); >> >
Для добавления обработчика используется стандартный синтаксис C#: this.Load += new System.EventHandler(this.Form1_Load)
Поэтому если мы захотим удалить созданный подобным образом обработчик, то нам надо не только удалить метод из кода формы в Form1.cs, но и удалить добавление обработчика в этом файле.
Однако мы можем добавлять обработчики событий и програмно, например, в конструкторе формы:
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Windows.Forms; namespace HelloApp < public partial class Form1 : Form < public Form1() < InitializeComponent(); this.Load += LoadEvent; >private void Form1_Load(object sender, EventArgs e) < >private void LoadEvent(object sender, EventArgs e) < this.BackColor = Color.Yellow; >> >
Кроме ранее созданного обработчика Form1_Load здесь также добавлен другой обработчик загрузки формы: this.Load += LoadEvent; , который устанавливает в качестве фона желтый цвет.
Обзор обработчиков событий (Windows Forms)
Обработчик событий — это метод, привязанный к событию. При возникновении события выполняется код в обработчике событий. Каждый обработчик событий предоставляет два параметра, которые позволяют правильно обрабатывать событие. В следующем примере показан обработчик событий для события Click элемента управления Button.
Private Sub button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles button1.Click End Sub private void button1_Click(object sender, System.EventArgs e)
private: void button1_Click(System::Object ^ sender, System::EventArgs ^ e)
Первый параметр ( sender ) предоставляет ссылку на объект, вызвавший событие. Второй параметр ( e в приведенном выше примере) передает объект, относящийся к обрабатываемому событию. Ссылаясь на свойства объекта (а иногда и его методы), можно получить такие сведения, как расположение мыши для событий мыши или данные, передаваемые в событиях перетаскивания.
Обычно каждое событие создает обработчик событий с другим типом объекта события для второго параметра. Некоторые обработчики событий, например для событий MouseDown и MouseUp, имеют один и тот же тип объекта для своего второго параметра. Для этих типов событий можно использовать один и тот же обработчик событий для обработки обоих событий.
Можно также использовать один и тот же обработчик событий для обработки одного и того же события в разных элементах управления. Например, если у вас в форме есть группа элементов управления RadioButton, можно создать один обработчик событий для события Click и привязать событие Click каждого элемента управления к этому обработчику событий. Дополнительные сведения см. в разделе Практическое руководство. Подключение нескольких событий к одному обработчику событий в Windows Forms.
См. также
- Создание обработчиков событий в Windows Forms
- Общие сведения о событиях
Совместная работа с нами на GitHub
Источник этого содержимого можно найти на GitHub, где также можно создавать и просматривать проблемы и запросы на вытягивание. Дополнительные сведения см. в нашем руководстве для участников.
Обработка событий в среде .NET Framework
В C# разрешается формировать какие угодно разновидности событий. Но ради совместимости программных компонентов со средой .NET Framework следует придерживаться рекомендаций, установленных для этой цели корпорацией Microsoft. Эти рекомендации, по существу, сводятся к следующему требованию: у обработчиков событий должны быть два параметра. Первый из них — ссылка на объект, формирующий событие, второй — параметр типа EventArgs, содержащий любую дополнительную информацию о событии, которая требуется обработчику. Таким образом, .NET-совместимые обработчики событий должны иметь следующую общую форму:
void обработчик(object отправитель, EventArgs е) < //. >
Как правило, отправитель — это параметр, передаваемый вызывающим кодом с помощью ключевого слова this. А параметр е типа EventArgs содержит дополнительную информацию о событии и может быть проигнорирован, если он не нужен.
Сам класс EventArgs не содержит полей, которые могут быть использованы для передачи дополнительных данных обработчику. Напротив, EventArgs служит в качестве базового класса, от которого получается производный класс, содержащий все необходимые поля. Тем не менее в классе EventArgs имеется одно поле Empty типа static, которое представляет собой объект типа EventArgs без данных.
В среде .NET Framework предоставляется встроенный обобщенный делегат под названием EventHandler . В данном случае тип TEventArgs обозначает тип аргумента, передаваемого параметру EventArgs события.
Для обработки многих событий параметр типа EventArgs оказывается ненужным. Поэтому с целью упростить создание кода в подобных ситуациях в среду .NET Framework внедрен необобщенный делегат типа EventHandler. Он может быть использован для объявления обработчиков событий, которым не требуется дополнительная информация о событиях.
Ниже приведен пример программы, в которой формируется .NET-совместимое событие:
// Реализуем программу реагирующую на события // нажатия клавиш - вызывающих специализированные команды консоли using System; namespace ConsoleApplication1 < // Производный класс от EventArgs class MyEventArgs : EventArgs < public char ch; >class KeyEvent < // Создадим событие, используя обобщенный делегат public event EventHandlerKeyDown; public void OnKeyDown(char ch) < MyEventArgs c = new MyEventArgs(); if (KeyDown != null) < c.ch = ch; KeyDown(this, c); >> > class Program < static void Main() < KeyEvent evnt = new KeyEvent(); evnt.KeyDown += (sender, e) => < switch (e.ch) < case 'C': < MyColor(true); break; >case 'B': < MyColor(false); break; >case 'S': < Console.Write("\nВведите длину: "); try < int Width = int.Parse(Console.ReadLine()) / 8; Console.Write("Введите ширину: "); int Height = int.Parse(Console.ReadLine()) / 8; Console.WindowWidth = Width; Console.WindowHeight = Height; Console.WriteLine(); >catch (FormatException) < Console.WriteLine("Неверный формат!"); >catch (ArgumentOutOfRangeException) < Console.WriteLine("Окно настолько не растянется!"); >break; > case 'T': < Console.Write("\nВведите новый заголовок: "); string s = Console.ReadLine(); Console.Title = s; Console.WriteLine(); break; >case 'R': < Console.ForegroundColor = ConsoleColor.White; Console.BackgroundColor = ConsoleColor.Black; Console.WriteLine(); break; >case 'E': < Console.Beep(); break; >default: < Console.WriteLine("\nТакая команда не найдена!"); break; >> >; ConsoleTitle(); char ch; do < Console.Write("Введите комманду: "); ConsoleKeyInfo key; key = Console.ReadKey(); ch = key.KeyChar; evnt.OnKeyDown(key.KeyChar); >while (ch != 'E'); > // Несколько вспомогательных методов static void ConsoleTitle() < CC(ConsoleColor.Green); Console.WriteLine("***************************\n\nПрограмма настройки консоли" + "\n___________________________\n"); CC(ConsoleColor.Yellow); Console.WriteLine("Управляющие команды: \n"); Command("C", "Поменять цвет текста"); Command("B", "Поменять цвет фона"); Command("S", "Поменять размер окна"); Command("T", "Поменять заголовок"); Command("R", "Сбросить изменения"); Command("E", "Выход"); Console.WriteLine(); >static void CC(ConsoleColor color) < Console.ForegroundColor = color; >static void Command(string s1, string s2) < CC(ConsoleColor.Red); Console.Write(s1); CC(ConsoleColor.White); Console.Write(" - " + s2+"\n"); >static void MyColor(bool F_or_B) < link1: Console.Write("\nВведите цвет: "); string s = Console.ReadLine(); switch (s) < case "Black": < if (F_or_B) Console.ForegroundColor = ConsoleColor.Black; else Console.BackgroundColor = ConsoleColor.Black; break; >case "Yellow": < if (F_or_B) Console.ForegroundColor = ConsoleColor.Yellow; else Console.BackgroundColor = ConsoleColor.Yellow; break; >case "Green": < if (F_or_B) Console.ForegroundColor = ConsoleColor.Green; else Console.BackgroundColor = ConsoleColor.Green; break; >case "Red": < if (F_or_B) Console.ForegroundColor = ConsoleColor.Red; else Console.BackgroundColor = ConsoleColor.Red; break; >case "Blue": < if (F_or_B) Console.ForegroundColor = ConsoleColor.Blue; else Console.BackgroundColor = ConsoleColor.Blue; break; >case "Gray": < if (F_or_B) Console.ForegroundColor = ConsoleColor.Gray; else Console.BackgroundColor = ConsoleColor.Gray; break; >case "White": < if (F_or_B) Console.ForegroundColor = ConsoleColor.White; else Console.BackgroundColor = ConsoleColor.White; break; >default: < Console.WriteLine("Такой цвет я не знаю :("); goto link1; >> Console.WriteLine("Цвет изменился!"); > > > 
Как видите, данный пример наглядно демонстрирует создание пользовательского события нажатия клавиш, при этом обработчик события, реализованный с помощью лямбда-выражения содержит целый набор команд, для работы с консолью.
Object sender c что это
События сигнализируют системе о том, что произошло определенное действие. И если нам надо отследить эти действия, то как раз мы можем применять события.
Например, возьмем следующий класс, который описывает банковский счет:
class Account < // сумма на счете public int Sum < get; private set; >// в конструкторе устанавливаем начальную сумму на счете public Account(int sum) => Sum = sum; // добавление средств на счет public void Put(int sum) => Sum += sum; // списание средств со счета public void Take(int sum) < if (Sum >= sum) < Sum -= sum; >> >
В конструкторе устанавливаем начальную сумму, которая хранится в свойстве Sum. С помощью метода Put мы можем добавить средства на счет, а с помощью метода Take, наоборот, снять деньги со счета. Попробуем использовать класс в программе — создать счет, положить и снять с него деньги:
Account account = new Account(100); account.Put(20); // добавляем на счет 20 Console.WriteLine($"Сумма на счете: "); account.Take(70); // пытаемся снять со счета 70 Console.WriteLine($"Сумма на счете: "); account.Take(180); // пытаемся снять со счета 180 Console.WriteLine($"Сумма на счете: ");
Сумма на счете: 120 Сумма на счете: 50 Сумма на счете: 50
Все операции работают как и положено. Но что если мы хотим уведомлять пользователя о результатах его операций. Мы могли бы, например, для этого изменить метод Put следующим образом:
public void Put(int sum) < Sum += sum; Console.WriteLine($"На счет поступило: "); >
Казалось, теперь мы будем извещены об операции, увидев соответствующее сообщение на консоли. Но тут есть ряд замечаний. На момент определения класса мы можем точно не знать, какое действие мы хотим произвести в методе Put в ответ на добавление денег. Это может вывод на консоль, а может быть мы захотим уведомить пользователя по email или sms. Более того мы можем создать отдельную библиотеку классов, которая будет содержать этот класс, и добавлять ее в другие проекты. И уже из этих проектов решать, какое действие должно выполняться. Возможно, мы захотим использовать класс Account в графическом приложении и выводить при добавлении на счет в графическом сообщении, а не консоль. Или нашу библиотеку классов будет использовать другой разработчик, у которого свое мнение, что именно делать при добавлении на счет. И все эти вопросы мы можем решить, используя события.
Определение и вызов событий
События объявляются в классе с помощью ключевого слова event , после которого указывается тип делегата, который представляет событие:
delegate void AccountHandler(string message); event AccountHandler Notify;
В данном случае вначале определяется делегат AccountHandler, который принимает один параметр типа string. Затем с помощью ключевого слова event определяется событие с именем Notify, которое представляет делегат AccountHandler. Название для события может быть произвольным, но в любом случае оно должно представлять некоторый делегат.
Определив событие, мы можем его вызвать в программе как метод, используя имя события:
Notify("Произошло действие");
Поскольку событие Notify представляет делегат AccountHandler, который принимает один параметр типа string — строку, то при вызове события нам надо передать в него строку.
Однако при вызове событий мы можем столкнуться с тем, что событие равно null в случае, если для его не определен обработчик. Поэтому при вызове события лучше его всегда проверять на null. Например, так:
if(Notify !=null) Notify("Произошло действие");
Notify?.Invoke("Произошло действие");
В этом случае поскольку событие представляет делегат, то мы можем его вызвать с помощью метода Invoke() , передав в него необходимые значения для параметров.
Объединим все вместе и создадим и вызовем событие:
class Account < public delegate void AccountHandler(string message); public event AccountHandler? Notify; // 1.Определение события public Account(int sum) =>Sum = sum; public int Sum < get; private set; >public void Put(int sum) < Sum += sum; Notify?.Invoke($"На счет поступило: "); // 2.Вызов события > public void Take(int sum) < if (Sum >= sum) < Sum -= sum; Notify?.Invoke($"Со счета снято: "); // 2.Вызов события > else < Notify?.Invoke($"Недостаточно денег на счете. Текущий баланс: "); ; > > >
Теперь с помощью события Notify мы уведомляем систему о том, что были добавлены средства и о том, что средства сняты со счета или на счете недостаточно средств.
Добавление обработчика события
С событием может быть связан один или несколько обработчиков. Обработчики событий — это именно то, что выполняется при вызове событий. Нередко в качестве обработчиков событий применяются методы. Каждый обработчик событий по списку параметров и возвращаемому типу должен соответствовать делегату, который представляет событие. Для добавления обработчика события применяется операция += :
Notify += обработчик события;
Определим обработчики для события Notify, чтобы получить в программе нужные уведомления:
Account account = new Account(100); account.Notify += DisplayMessage; // Добавляем обработчик для события Notify account.Put(20); // добавляем на счет 20 Console.WriteLine($"Сумма на счете: "); account.Take(70); // пытаемся снять со счета 70 Console.WriteLine($"Сумма на счете: "); account.Take(180); // пытаемся снять со счета 180 Console.WriteLine($"Сумма на счете: "); void DisplayMessage(string message) => Console.WriteLine(message);
В данном случае в качестве обработчика используется метод DisplayMessage, который соответствует по списку параметров и возвращаемому типу делегату AccountHandler. В итоге при вызове события Notify?.Invoke() будет вызываться метод DisplayMessage, которому для параметра message будет передаваться строка, которая передается в Notify?.Invoke() . В DisplayMessage просто выводим полученное от события сообщение, но можно было бы определить любую логику.
Если бы в данном случае обработчик не был бы установлен, то при вызове события Notify?.Invoke() ничего не происходило, так как событие Notify было бы равно null.
Консольный вывод программы:
На счет поступило: 20 Сумма на счете: 120 Со счета снято: 70 Сумма на счете: 50 Недостаточно денег на счете. Текущий баланс: 50 Сумма на счете: 50
Теперь мы можем выделить класс Account в отдельную библиотеку классов и добавлять в любой проект.
Добавление и удаление обработчиков
Для одного события можно установить несколько обработчиков и потом в любой момент времени их удалить. Для удаления обработчиков применяется операция -= . Например:
Account account = new Account(100); account.Notify += DisplayMessage; // добавляем обработчик DisplayMessage account.Notify += DisplayRedMessage; // добавляем обработчик DisplayRedMessage account.Put(20); // добавляем на счет 20 account.Notify -= DisplayRedMessage; // удаляем обработчик DisplayRedMessage account.Put(50); // добавляем на счет 50 void DisplayMessage(string message) => Console.WriteLine(message); void DisplayRedMessage(string message) < // Устанавливаем красный цвет символов Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine(message); // Сбрасываем настройки цвета Console.ResetColor(); >
На счет поступило: 20 На счет поступило: 20 На счет поступило: 50
В качестве обработчиков могут использоваться не только обычные методы, но также делегаты, анонимные методы и лямбда-выражения. Использование делегатов и методов:
Account acc = new Account(100); // установка делегата, который указывает на метод DisplayMessage acc.Notify += new Account.AccountHandler(DisplayMessage); // установка в качестве обработчика метода DisplayMessage acc.Notify += DisplayMessage; // добавляем обработчик DisplayMessage acc.Put(20); // добавляем на счет 20 void DisplayMessage(string message) => Console.WriteLine(message);
В данном случае разницы между двумя обработчиками никакой не будет.
Установка в качестве обработчика анонимного метода:
Account acc = new Account(100); acc.Notify += delegate (string mes) < Console.WriteLine(mes); >; acc.Put(20);
Установка в качестве обработчика лямбда-выражения:
Account account = new Account(100); account.Notify += message => Console.WriteLine(message); account.Put(20);
Управление обработчиками
С помощью специальных акссесоров add/remove мы можем управлять добавлением и удалением обработчиков. Как правило, подобная функциональность редко требуется, но тем не менее мы ее можем использовать. Например:
class Account < public delegate void AccountHandler(string message); AccountHandler? notify; public event AccountHandler Notify < add < notify += value; Console.WriteLine($"добавлен"); > remove < notify -= value; Console.WriteLine($"удален"); > > public Account(int sum) => Sum = sum; public int Sum < get; private set; >public void Put(int sum) < Sum += sum; notify?.Invoke($"На счет поступило: "); // 2.Вызов события > public void Take(int sum) < if (Sum >= sum) < Sum -= sum; notify?.Invoke($"Со счета снято: "); // 2.Вызов события > else < notify?.Invoke($"Недостаточно денег на счете. Текущий баланс: "); ; > > >
Теперь опредление события разбивается на две части. Вначале просто определяется переменная делегата, через которую мы можем вызывать связанные обработчики:
AccountHandler notify;
Во второй части определяем акссесоры add и remove. Аксессор add вызывается при добавлении обработчика, то есть при операции +=. Добавляемый обработчик доступен через ключевое слово value . Здесь мы можем получить информацию об обработчике (например, имя метода через value.Method.Name) и определить некоторую логику. В данном случае для простоты просто выводится сообщение на консоль:
add < notify += value; Console.WriteLine($"добавлен"); >
Блок remove вызывается при удалении обработчика. Аналогично здесь можно задать некоторую дополнительную логику:
remove < notify -= value; Console.WriteLine($"удален"); >
Внутри класса событие вызывается также через переменную notify. Но для добавления и удаления обработчиков в программе используется как раз Notify:
Account acc = new Account(100); acc.Notify += DisplayMessage; // добавляем обработчик DisplayMessage acc.Put(20); // добавляем на счет 20 acc.Notify -= DisplayMessage; // удаляем обработчик DisplayMessage acc.Put(20); // добавляем на счет 20 void DisplayMessage(string message) => Console.WriteLine(message);
Консольный вывод программы:
DisplayMessage добавлен На счет поступило: 20 DisplayMessage удален
Передача данных события
Нередко при возникновении события обработчику события требуется передать некоторую информацию о событии. Например, добавим и в нашу программу новый класс AccountEventArgs со следующим кодом:
class AccountEventArgs < // Сообщение public string Message// Сумма, на которую изменился счет public int Sum public AccountEventArgs(string message, int sum) < Message = message; Sum = sum; >>
Данный класс имеет два свойства: Message — для хранения выводимого сообщения и Sum — для хранения суммы, на которую изменился счет.
Теперь применим класс AccoutEventArgs, изменив класс Account следующим образом:
class Account < public delegate void AccountHandler(Account sender, AccountEventArgs e); public event AccountHandler? Notify; public int Sum < get; private set; >public Account(int sum) => Sum = sum; public void Put(int sum) < Sum += sum; Notify?.Invoke(this, new AccountEventArgs($"На счет поступило ", sum)); > public void Take(int sum) < if (Sum >= sum) < Sum -= sum; Notify?.Invoke(this, new AccountEventArgs($"Сумма снята со счета", sum)); > else < Notify?.Invoke(this, new AccountEventArgs("Недостаточно денег на счете", sum)); >> >
По сравнению с предыдущей версией класса Account здесь изменилось только количество параметров у делегата и соответственно количество параметров при вызове события. Теперь делегат AccountHandler в качестве первого параметра принимает объект, который вызвал событие, то есть текущий объект Account. А в качестве второго параметра принимает объект AccountEventArgs, который хранит информацию о событии, получаемую через конструктор.
Теперь изменим основную программу:
Account acc = new Account(100); acc.Notify += DisplayMessage; acc.Put(20); acc.Take(70); acc.Take(150); void DisplayMessage(Account sender, AccountEventArgs e) < Console.WriteLine($"Сумма транзакции: "); Console.WriteLine(e.Message); Console.WriteLine($"Текущая сумма на счете: "); >
По сравнению с предыдущим вариантом здесь мы только изменяем количество параметров и их использования в обработчике DisplayMessage. Благодаря первому параметру в методе можно получить информацию об отправителе события — счете, с которым производится операция. А через второй параметр можно получить инфомацию о состоянии операции.