- •Введение Обзор .Net. Основные понятия
- •Программа на c#
- •Основы языка Пространство имён
- •Система типов
- •Класс и Структура. Первое приближение
- •Литералы. Представление значений
- •Арифметические литералы
- •Логические литералы
- •Символьные литералы
- •Символьные escape-последовательности
- •Строковые литералы
- •Операции и выражения
- •Приоритет операций
- •Приведение типов
- •Особенности выполнения арифметических операций
- •Особенности арифметики с плавающей точкой
- •Константное выражение
- •Переменные элементарных типов. Объявление и инициализация
- •Константы
- •Перечисления
- •Объявление переменных. Область видимости и время жизни
- •Управляющие операторы
- •Синтаксис объявления метода
- •Вызов метода
- •Перегрузка методов
- •Способы передачи параметров при вызове метода
- •Передача параметров. Ссылка и ссылка на ссылку как параметры
- •Сравнение значений ссылок
- •This в нестатическом методе
- •Свойства
- •Обработка исключений
- •Массив. Объявление
- •Инициализация массивов
- •Примеры инициализации массивов
- •Два типа массивов: Value Type and Reference Type
- •Встроенный сервис по обслуживанию простых массивов
- •Реализация сортировки в массиве стандартными методами
- •Подробнее о массивах массивов (jagged array)
- •Массивы как параметры
- •Спецификатор params
- •Main в классе. Точка входа
- •Создание объекта. Конструктор
- •Операция new
- •В управляемой памяти нет ничего, что бы создавалось без конструктора
- •Кто строит конструктор умолчания
- •This в контексте конструктора
- •Перегрузка операций
- •Синтаксис объявления операторной функции
- •Унарные операции. Пример объявления и вызова
- •Бинарные операции
- •Определение операций конъюнкция и дизъюнкции
- •И вот результат…
- •Пример. Свойства и индексаторы
- •Explicit и implicit. Преобразования явные и неявные
- •Наследование
- •Наследование и проблемы доступа
- •Явное обращение к конструктору базового класса
- •Кто строит базовый элемент
- •Переопределение членов базового класса
- •Наследование и new модификатор
- •Полное квалифицированное имя. Примеры использования
- •Прекращение наследования. Sealed спецификатор
- •Абстрактные функции и абстрактные классы
- •Ссылка на объект базового класса
- •Операции is и as
- •Виртуальные функции. Принцип полиморфизма
- •Интерфейсы
- •Делегаты
- •События
- •События и делегаты. Различия
- •Атрибуты, сборки, рефлексия Рефлексия (отражение) типов
- •Реализация отражения. Type, InvokeMember, BindingFlags
- •Атрибуты
- •Сборка. Класс Assembly
- •Класс сборки в действии
- •Разбор полётов
- •Класс System.Activator
- •Версия сборки
- •Файл конфигурации приложения
- •Общедоступная сборка
- •Игры со сборками из gac
- •Динамические сборки
- •Динамическая сборка: создание, сохранение, загрузка, выполнение
- •Ввод-вывод Базовые операции
- •Потоки: байтовые, символьные, двоичные
- •Предопределённые потоки ввода-вывода
- •Функция ToString()
- •Консольный ввод-вывод. Функции-члены класса Console
- •Консольный вывод. Форматирование
- •Функции вывода. Нестандартное (custom) форматирование значений.
- •Консольный ввод. Преобразование значений
- •Файловый ввод-вывод
- •Потоки Процесс, поток, домен
- •Домен приложения
- •Обзор пространства имён System.Threading
- •Многопоточность
- •Виды многопоточности
- •А кто в домене живёт…
- •Класс Thread. Общая характеристика
- •Именование потока
- •Игры с потоками
- •Характеристики точки входа дополнительного потока
- •Запуск вторичных потоков
- •Приостановка выполнения потока
- •Отстранение потока от выполнения
- •Завершение потоков
- •Метод Join()
- •Состояния потока (перечисление ThreadState)
- •Одновременное пребывание потока в различных состояниях
- •Фоновый поток
- •Приоритет потока
- •Передача данных во вторичный поток
- •Извлечение значений (данных) с помощью Callback методов
- •Организация взаимодействия потоков
- •1. Посредством общедоступных (public) данных
- •2. Посредством общедоступных (public) свойств
- •3. Посредством общедоступных очередей
- •Состязание потоков
- •Блокировки и тупики
- •Очереди. Основа интерфейса взаимодействия
- •Безопасность данных и критические секции кода
- •Пример организации многопоточного приложения
- •Очередь как объект синхронизации
- •Синхронизация работы потоков при работе с общими ресурсами
- •1. Организация критических секций
- •2. Специальные возможности мониторов
- •Рекомендации по недопущению блокировок потоков
- •Форма Класс Form
- •Форма: управление и события жизненного цикла
- •Форма: контейнер как элемент управления
- •Разница между элементами управления и компонентами.
- •Свойства элементов управления. Anchor и Dock
- •Extender providers. Провайдеры дополнительных свойств
- •Validating и Validated элементов управления
- •Управление посредством сообщений
- •Стандартный делегат
- •Делегат EventHandler
- •Класс Application
- •События класса Application
- •Примеры перехвата сообщений
- •Метод WndProc
- •Пример переопределения WndProc
- •Контекст приложения
- •Применение классов GraphicsPath и Region. Круглая форма
- •Собственные элементы управления
- •Литература
Управление посредством сообщений
Когда ещё при программировании Windows-приложений не прибегали к помощи MFC, когда ещё не было карт сообщений, оконная процедура WinMain определялась явным образом, и в ней содержался ЦИКЛ, который обеспечивал непрерывное “прослушивание” системы и интерпретацию перехватываемых сообщений.
И вся работа приложения фактически сводилась к тому, что между распознанным в этом цикле сообщением и соответствующей функцией приложения устанавливалось посредством тривиального оператора выбора взаимнооднозначное соответствие.
Естественно, при этом производился вызов соответствующей функции с возможной передачей этой функции параметров. При этом попадание в этот цикл обеспечивалось достаточно тривиальной стандартной последовательностью операторов. С появлением MFC этот цикл достаточно простой стандартной серией макроопределений скрывался от разработчика приложения за картой сообщений.
Обсуждение реальных механизмов работы приложения рядовыми программистами не предполагалось.
Обеспечить реакцию приложения на одно из множества стандартных сообщений (событие), приходящих от операционной системы можно было путём простой модификации соответствующего макроопределения, добавляя к этому макроопределению указатель (ссылку, делегат, событие) на функцию-обработчик события.
Стандартный делегат
Существует соглашение, по которому обработчик событий в .NET Framework не возвращает значений (тип возвращаемого значения void) и принимает два параметра.
Первый параметр – ссылка на источник события (объект-издатель), второй параметр – ссылка на объект, производный от класса EventArgs. Сам по себе базовый класс НЕ НЕСЁТ никакой “полезной” информации о конкретных событиях. Назначение данного класса заключается в поддержке универсального стандартного механизма реализации событий (в том числе и передачи параметров). Забота о представлении информации о событии возлагается на разработчика производного класса.
Делегат EventHandler
Представляет метод со стандартной сигнатурой, предназначенный для обработки события, не содержащего дополнительной информации.
Объявляется следующим образом:
public delegate void EventHandler(object sender, EventArgs e);
Параметры
object sender //Представляет ссылку на объект-источник события.
EventArgs e // Таким образом кодируется информация о событии.
Замечание
Модель событий в .NET Framework основывается на механизме ссылок на функции (events – разновидности класса-делегата), которые обеспечивают стандартную стыковку события с обработчиком. Для возбуждения события необходимы два элемента:
Класс-носитель информации о событии. Должен наследовать от базового класса EventArgs.
Делегат, настроенный на метод, обеспечивающий реакцию на данное событие. Когда создаётся делегат-представитель класса-делегата EventHandler, прежде всего, определяется соответствующий метод, выполнение которого обеспечивает реакцию на событие.
Таким образом, для реализации перехвата события достаточно использовать:
1. для идентификации события. Базовый класс EventArgs, если уведомление о произошедшем событии не связано с генерацией дополнительной информации или производный от данного класса класс, если необходимо передавать дополнительную информацию, связанную с событием,
2. предопределённый класс EventHandler для реализации ссылки на метод-обработчик события.
Пример
using System;
namespace Events00
{
// Однопоточное приложение, в котором для реализации механизма
// реакции на события используется стандартный класс-делегат
// System.EventHandler.
// Объявляется класс события, производный от System.EventArgs.
//===================================================================
class EventPosition:System.EventArgs
{
// Дополнительная информация о событии.
public int X;
// Конструктор...
public EventPosition(int key)
{
X = key;
}
}
//===================================================================
/// <summary>
///Базовый класс действующих в приложении объектов.
///Содержит ВСЁ необходимое для того, чтобы объекты производных классов
/// могли адекватно реагировать на заложенные в базовом классе события.
/// </summary>
class BaseClass
{
// Ссылка на это событие идентифицируется как xEvent.
// Это «стандартное» событие.
// xEvent стыкуется со стандартным классом-делегатом System.EventHandler.
public static event System.EventHandler xEvent;
// Статическая переменная-носитель дополнительной информации.
static int xPosition = 0;
// Статическая функция. Это модель процесса непрерывного сканирования.
// Аналог цикла обработки сообщений приложения.
public static void XScaner()
{
while (true)
{//=================================================================
while(true)
{//================================================================
// Источником события является вводимая с клавиатуры
// последовательность символов, соответствующая целочисленному
// значению 50. При получении этого значения просходит уведомление
// подписанных на событие объектов.=============================
try
{
Console.WriteLine(“new xPosition, please: “);
xPosition = Int32.Parse(Console.ReadLine());
break;
}
catch
{
Console.WriteLine(“Incorrect value of xPosition!”);
}
}//================================================================
if (xPosition < 0) break; // Отрицательные значения являются сигналом
// к прекращению выполнения , а при получении 50 - возбуждается событие!
if (xPosition == 50) xEvent(new BaseClass(), new EventPosition(xPosition));
}//=================================================================
}
}
//===================================================================
// Важное обстоятельство! В этом приложении событие возбуждается
// ПРЕДКОМ, а реагирует на него объект-представитель класса ПОТОМКА!
//===================================================================
/// <summary>
/// Объявление первого производного класса.
/// Надо сделать дополнительные усилия для того чтобы объекты этого класса
/// стали бы реагировать на события.
/// </summary>
class ClassONE:BaseClass
{
public void MyFun(object obj, System.EventArgs ev)
{
Console.Write(“{0} - “,this.ToString());
Console.WriteLine
(“{0}:YES! {1}”,((BaseClass)obj).ToString(),((EventPosition)ev).X.ToString());
}
}
/// <summary>
/// Второй класс чуть сложнее. Снабжён конструктором, который позволяет классу
/// самостоятельно «поднисаться» на «интересующее» его событие.
/// </summary>
class ClassTWO:BaseClass
{
public ClassTWO()
{
BaseClass.xEvent += new System.EventHandler(this.MyFun);
}
public void MyFun(object obj, System.EventArgs ev)
{
Console.Write(“{0} - “,this.ToString());
Console.WriteLine
(“{0}:YES! {1}”, ((BaseClass)obj).ToString(), ((EventPosition)ev).X.ToString());
}
}
//==================================================================================
class mainClass
{
static void Main(string[] args)
{
Console.WriteLine(«0______________________________»);
// Создали первый объект и подписали его на получение события.
ClassONE one = new ClassONE();
BaseClass.xEvent += new System.EventHandler(one.MyFun);
// Второй объект подписался сам.
ClassTWO two = new ClassTWO();
// Запустили цикл прослушивания базового класса.
BaseClass.XScaner();
// При получении отрицательного значения цикл обработки
// сообщений прерывается.
Console.WriteLine(«1______________________________»);
// Объект - представитель класса ClassONE перестаёт
// получать уведоомление о событии.
BaseClass.xEvent -= new System.EventHandler(one.MyFun);
// После чего повторно запусткается цикл прослушивания,
// который прекращает выполняться после повторного
// получения отрицательного значения.
BaseClass.XScaner();
Console.WriteLine(“2______________________________”);
}
}
//==================================================================================
}