Управления по событиям – это попытка моделирования реального мира, в котором возникают постоянно какие-то события и нужно находить решения и реагировать на эти события.
Например: – наступил четверг. Вам надо идти на лекцию по информатике; – пришел Я, поздоровался с Вами, Вам надо встать, успокоиться, помолчать. После того как Я с Вами поздороваюсь, Вам надо сесть и слушать, что Я расскажу. Все это события.
Раньше, в эпоху больших ЭВМ преобладал пакетный режим работы, при котором машине давалось задание, она его выполняла и выдавала результат. Программа выполнялась "сверху-вниз" и состояла из последовательности команд. Это процедурное программирование. Принципы построения таких программ выражает научный подход под названием структурное программирование. Именно этот режим реализован в консольных приложениях.
С появлением персональных ЭВМ реальностью стал режим диалога, в котором появилась возможность во время выполнения программы управлять ее работой извне. Возникло программирование с управлением по событиям.
Это стало следующим этапом моделирования реального мира в программировании, что значительно продвинуло использование РС в жизни. При такой организации работы в программе предусматривался цикл, который ждал появления событий, например – нажатия клавиши ENTER, или других. Если это событие происходило, программа выполняла вполне определенные действия. Однако при ожидании события программа все равно не прерывала свою работу: в ней выполнялся итеративный цикл, то есть цикл, который заканчивается по некоторому условию, и процессор был загружен выполнением именно этой программы.
Windows и другие операционные системы сделали персональный компьютер многозадачным. Стало возможным запустить на выполнение не одну программу (приложение), как это было раньше, а сразу несколько. Выполняются и занимают процессор эти приложения по очереди. Очередью можно управлять, задавая приоритеты выполнения приложений. В такой ситуации прежние принципы построения программ уже не устраивали, появилась необходимость разработки новых принципов организации работы программ. Эти принципы изложены в парадигме "поймай крота" или «демоны за столом». Суть ее в следующем: программа представляется как некоторый стол. В столе проделаны отверстия, каждое из которых соответствует некоторому событию. За столом сидят «демоны» и ждут появления события. Как только появляется событие, оно выскакивает из соответствующей дырки, «демон», которому это событие интересно, захватывает его и обрабатывает. На этом может все закончиться, а может это событие будет передано другому «демону» для обработки. После того как событие обработано, «демоны» продолжают ждать новых событий. Если событий долго нет, «демоны» ничего не делают и управление передается другой программе.
Иными словами, событийно-управляемая программа есть бесконечный цикл, смысл которого состоит в том, чтобы ждать появления событий. Если событие появилось, программа выдает сообщение об этом. Это сообщение просматривают обработчики сообщений. Если какому-нибудь из них оно "понравится", то этот обработчик его обработает, т.е. выполнит вполне определенные заданные действия. Если же у программы нет ожидающих обработку сообщений, она может передать управление другой программе.
Управление по событиям не заменило процедурного подхода, типичным примером которого служит консольный режим – оно дополнило его средствами, позволяющими гораздо лучше разделять интерфейс пользователя и специфическую обработку данных. Среда с управлением по событиям позволяет реагировать на конкретные события (нажатие клавиши, щелчок мыши и т.д.) и дает возможность сразу перейти к выполнению логически обусловленных операций, которые программист свяжет с этими событиями.
Технически это реализовано в объектно-ориентированном программировании. В ООП обработчики событий находятся внутри объектов и при таком подходе управляемая программа больше похожа на множество объектов с определенными отношениями между ними, а не на набор последовательных команд, которые выполняются одна за другой, как было в процедурном программировании.
Визуальное программирование это тот инструмент (или, если угодно, средство), который облегчает процесс собственно написания (позволяет автоматизировать) исходного кода программ для оконных приложений, реализующих принципы событийного программирования. Суть его в следующем. Как известно, среда разработки Visual Studio .NET основана на платформе .NET Framework, в которую входит набор базовых классов. Этот набор базовых классов представляет собой иерархию классов в виде дерева, основанием которого является класс object. Для целей визуального программирования созданы классы, которые можно представить как листья этого дерева, то есть вершины иерархии, у которых уже нет наследников. Экземпляры этих классов (объекты) представляют собой визуальные компоненты, и их можно легко поместить на форму. В качестве примеров визуальных компонентов следует привести кнопки (Button), редакторы (TextBox), списки строк (ListBox), надписи (Label) и большое количество других. Форма - это специальный визуальный компонент класса Forms, представленный в виде окна и обладающий некоторыми специфическими свойствами окна: используя мышь, у окна можно изменить размер, его можно схлопнуть в иконку, перемещать по экрану и другие.
У всех визуальных компонентов есть свойства, отвечающие за поля, в которых лежат данные, относящиеся к конкретному визуальному компоненту. Ну, например, у всех визуальных компонентов есть высота, ширина, цвет фона. У тех, которые лежат на форме, есть координаты левого верхнего угла относительно формы и так далее.
Кроме этого у всех визуальных компонентов есть обработчики событий, на которые они могут реагировать. Например, обработчик события нажатия клавиши Enter (Click), обработчик события загрузки компонента (Load), обработчики, связанные с манипуляциями мышью (MouseUp, MouseDoun) и много других. Эти обработчики как методы соответствующих объектов доступны на этапе проектирования и вызываются при наступлении соответствующих событий. Программисту остается только связать выполнение конкретной программы или её части с одним или несколькими обработчиками событий. Получается, что сама визуальная среда разработки приложения берет на себя огромную часть рутинной работы, связанной с инициализацией формы и её компонентов, их прорисовкой, организацией обработки событий и многого другого, фокусируя усилия программиста на написании исходного кода собственно решающего конкретную задачу. Более того, использование визуального программирования не требует глубокого знания принципов работы оконных приложений. Это существенно ускоряет и упрощает процесс создания таких приложений.
Пора начать процесс создания Windows-приложения.
Пример решения задачи про углы в Windows -приложении
В качестве задачи для Windows-приложения возьмем задачу из примера 2.6 про углы треугольника. В Лекции 4 решение этой задачи было оформлено в виде класса и написано консольное приложение для её реализации (пример 4.3).
Пора создать Windows-приложение для реализации решения этой задачи. Можно ли использовать при этом уже созданный класс из примера 4.3? Почему нет? В полях и методах этого класса нет каких-то особенных средств, характерных именно для Windows-приложения. Что, по сути, изменится при оконной реализации решения этой задачи? Изменится лишь заполнение полей с исходными данными и выдача результатов на экран. Ведь для чтения с клавиатуры в Widows -приложении не используются методы типа Console.ReadLine() и для выдачи на экран не используются методы типа Console.WriteLine(). А как это можно сделать – смотрите пример 5.1.
Итак, начнем.
Для этого надо найти на рабочем столе компьютера иконку Microsoft Visual Studio и запустить среду. Откроется главное окно, которое состоит из нескольких панелей (рис. 5.1).
Рис. 5.1. Фрагмент главного окна среды VS
В Visual Studio любая программа заключается в проект. Проект – это папка для файлов. Для создания нового проекта выберите в меню File | New | Project (Файл|Новый|Проект). Откроется окно New Project (Новый проект), как на рис. 5.2.
Рис. 5.2а. Фрагмент окна «Создать проект» среды VS
В левом окне выберите язык C#, в правом окне выберите тип проекта –Windows Forms Application. Внизу есть еще один или два однострочных редактора, в которых надо (или можно) выбрать имя проекта (Name) и расположение папки проекта (Location). Обратите внимание на расположение папки проекта. С использованием кнопки Обзор (View) следует расположить эту папку в удобном месте.
Рис. 5.2б. Другой фрагмент окна «Создать проект» среды VS
И смело жмите Ok.
Среда VS может быть будет такой, как на рис. 5.3.
Рис. 5.3а. Фрагмент среды VS в Windows-приложении
Если это не так, то окно Панель элементов ( Toolbox ) можно открыть, используя пункт главного меню Вид( View). В этом окне представлен набор элементов, которые можно разместить на форме.
В окне среды VS в Windows-приложении есть возможность открыть окно Свойство( Properties). Если оно не открылось, его можно открыть из пункта главного меню Вид( View).
Рис. 5.3б. Фрагмент среды VS в Windows-приложении с окном Свойства
В этом окне отображаются свойства и обработчики событий сфокусированного оконного элемента. Сейчас (на рис. 5.3) здесь отображаются свойства формы Form1. Что такое свойство? Это некая конструкция языка C#, с помощью которой можно добраться до полей соответствующего объекта, в данном случае объекта For m 1. Пока так, более четко и формально о свойствах смотри в Лекции 6.
По центру окна находится Конструктор форм ( Design ), позволяющий реализовать графический интерфейс приложения.
Сделаем так: исходные данные будем считывать из трех редакторов TextBox, тексты которых лежат в их свойствах Text. Саму задачу будем запускать в обработчике события Click кнопки Button, а результаты будем выводить тоже в редакторы класса TextBox. В дальнейшем, может быть, вывод изменим.
Поместим три редактора класса TextBox на форму Form1. Для этого надо кликнуть мышью на соответствующий пункт Панели элементов (Toolbox) и далее кликнуть мышью на форме. VS предлагает дать им имена textBox1, textBox2, textBox3. Эти имена можно изменить, но не будем спорить с VS. Во время выполнения программы из них будут считываться значения сторон треугольника. На этапе проектирования поместим в них по «1». Для этого в окне Свойство(Properties) каждого из редакторов в маленькое окно свойства Text запишем «1».
Далее поместим на форму кнопку Button. У нее будет имя button1. В окне Свойство(Properties) этой кнопки напишем «Решение задачи».
И наконец, на форме следует разместить еще три редактора с именами textBox4, textBox5, textBox6. В них будем скидывать результаты.
И еще, разместим на форме кнопку в текстом «Выход», а в свойстве Text самой формы Form1 напишем «Задача об углах треугольника».
Первый пользовательский интерфейс закончили. Может, он будет в дальнейшем дорабатываться.
Рис. 5.4. Оконная форма в задаче про углы
Надо заниматься содержательной частью приложения.
Дважды кликните по кнопке button1. На месте Конструктора форм (Design) откроется редактор кода файла Form1.cs (пример 5.1).
Пример 5.1. Окно редактора кода с «пустым» обработчиком события Button1_Click()
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
}
}
}
На что надо обратить внимание? Здесь есть описание класса Form1. Этот класс является наследником класса Form. В описании класса Form1 используется слово partial. Это означает, что это часть описания класса. Следовательно, где-то есть еще другая часть описания. Дальше идет описание конструктора класса Form1. В нем вызывается метод InitializeComponent(). Судя по имени, в нем происходит инициализация компонентов, находящихся на форме. Ну и наконец, в этом файле есть обработчик события Click компонента button1 с именем button 1_ Click. Пока это просто заглушка, то есть метод, который ничего не делает.
Вернитесь в конструктор формы и дважды кликните по кнопке «Выход». В редакторе кода появится еще один обработчик события. Напишите туда Close(); (пример 5.2).
Пример 5.2
private void button2_Click(object sender, EventArgs e)
{
Close();
}
Теперь откомпилируйте приложение и запустите его на выполнение.
Что оно может делать? Окно можно перемещать по экрану, менять размер, «схлопнуть» в иконку, раскрыть на весь экран, и, наконец, нажав на кнопку «Выход» закончить выполнение приложения. Это много, даже очень много, причем для этого почти ничего не пришлось писать. Но не хватает собственно решения задачи.
Посмотрите пример 4.3. Проанализируем его. В нем есть класс CLUgli. В этом классе есть поля для хранения исходных данных, есть методы, которые эти исходные данные могут переводить в результаты и есть поля, в которых будут лежать эти результаты. Далее, есть метод Main, в котором происходит инициализация объекта класса CLUgli, затем заполняются поля с исходными данными. Эти данные вводятся с клавиатуры. После этого вызываются методы, которые решают задачу и заполняют поля с результатами. Далее значения этих полей выводятся на экран. Сделаем то же самое, но не в методе Main, а в обработчике события кнопки button1. Для этого перенесем описание класса CLUgli в исходном коде в файл Form1.cs. Единственно, что надо сказать, этот код следует поместить ниже описания класса Form1.
А далее, написать аналог тела метода Main в теле обработчика события Click компонента button1. Исходные данные надо брать как строку из свойства Text соответствующего редактора и скидывать результаты надо тоже в соответствующие редакторы, как строки.
Пример 5.3
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void button1_Click(object sender, EventArgs e)
{
CLUgli ugli1 = new CLUgli();
ugli1.a = Convert.ToDouble(textBox1.Text);
ugli1.b = Convert.ToDouble(textBox2.Text);
ugli1.c = Convert.ToDouble(textBox3.Text);
ugli1.ua = ugli1.ugol(ugli1.a, ugli1.b, ugli1.c);
ugli1.ub = ugli1.ugol(ugli1.b, ugli1.a, ugli1.c);
ugli1.uc = ugli1.ugol(ugli1.c, ugli1.a, ugli1.b);
textBox4.Text = Convert.ToString(ugli1.ua);
textBox5.Text = Convert.ToString(ugli1.ub);
textBox6.Text = Convert.ToString(ugli1.uc);
}
private void button2_Click(object sender, EventArgs e)
{
Close();
}
}
class CLUgli
{
public double a, b, c;
public double ua, ub, uc;
public double ugol(double a, double b, double c)
{
double aa;
aa = (b * b + c * c - a * a) / (2 * b * c);
aa = Math.Acos(aa);
aa = Rad_v_Drad(aa); //новое
return aa;
}
private double Rad_v_Drad(double x) //новое
{
return 180 * x / Math.PI;
}
}
}
}
Используем компоненты Label для того, чтобы пользовательский интерфейс стал более понятным. Поместим их левее редакторов и изменим их свойства Text в окне Свойство(Properties) cоответственно на “a=”, “b=”, “c=”,” ua=”,”ub=”,”uc=”.
После этого запуск приложения даст результаты, представленные на рис. 5.5.
Рис. 5.5. Форма с исходными данными и результатами задачи про углы
Лекция 6. Windows-приложение, режим пошаговой отладки. Продолжение ООП
Режим пошагового выполнения
Продолжим изучение Windows-приложения языка C#.
Ну хорошо: запустили приложение, увидели окно, нажали кнопку, получили результаты. Вроде все понятно? А как же фраза, сказанная в лекции 1: « Приложение представляет собой набор пространств имен. Каждое пространство имен может включать в себя другие пространства имен и набор классов. Каждый класс представляет собой набор данных и методов обработки этих данных. В одном из классов должен находиться метод с именем Main. Вот с него все и начинается. После того как приложение будет запущено на выполнение, вызывается метод Main и стартует процесс выполнения операторов в том порядке, в котором они, операторы, записаны в методе Main». Где же сейчас этот Main, или все это становится неправдой в оконном режиме? Конечно, можно прямо указать на то место в проекте, где находится метод Main, но можно пойти другим путем: в VS есть режим пошагового выполнения приложения – режим Debug.
Чтобы запустить этот режим, надо войти в пункт главного меню Debug и выбрать один из двух режимов Step Into или Step Over (рис. 6.1). При этом будет реализовываться пошаговый режим работы приложения.
Рис. 6.1. Запуск режима пошагового выполнения программы (Debug)
После нажатия F8 или Shift-F8 откроется окно с файлом Program.cs (рис. 6.2), и каждое следующее нажатие клавиши F8 или Shift-F8 приведет к продвижению приложения на выполнение следующего фрагмента исходного кода. Нажимайте F8.
Рис. 6.2. Программа в режиме Debug
Программа начинает работу с того, что находит класс, в котором есть метод Main, и вызывает его. Значит, все, что говорилось в лекции 1, остается справедливым и для Windows-приложения!
Где же находится этот метод, что же в нем записано и кто это написал? Этот метод находится в файле Program.cs. Текст файла Program.cs приведен в примере 6.1.
Пример 6.1
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
namespace WindowsFormsApplication1
{
static class Program
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
}
}
Разберем его. Кто это все написал? Этот исходный код автоматически создан средой VS. Здесь есть полное соответствие аналогичному файлу Program.cs, созданному автоматически в консольном режиме (см. рис. 1.3). В обоих файлах есть пространство имен (namespace WindowsFormsApplication1 и namespace ConsoleApplication1), в обоих файлах есть класс Program (static class Program). В обоих файлах есть метод Main. В консольном режиме сначала это просто заглушка, тело которой нужно наполнить содержанием, в оконном режиме тело метода Main уже написано. Что же в нем написано?
Не вдаваясь в подробности, разберем содержание метода Main. В методе Main оконного режима используется класс Application из пространства имен System . Windows . Forms . В первой строке вызывается статический метод EnableVisualStyles, который, по-видимому, устанавливает, что визуальные компоненты будут отрисовываться в стиле Windows XP, во второй строке, судя по имени (SetCompatibleTextRenderingDefault), вызывается статический метод, в котором делаются кое-какие необходимые установки.
А вот в третьей строке вызывается статический метод Run , которому в качестве фактического аргумента передается объектное выражение new Form 1(). При вычислении этого выражения создается первый объект – экземпляр класса Form 1. Этот объект становится текущим. Для создания объекта вызывается конструктор класса. В процессе работы конструктора осуществляется вызов метода InitializeComponent. Целью этого вызова является текущий объект – уже созданный объект класса Form 1. Ни в конструкторе, ни в вызванном методе новые объекты не создаются. По завершении работы конструктора объект класса Form 1 передается методу Run в качестве аргумента.
Метод Run класса Application – это знаменитый метод. Во-первых, он открывает форму – видимый образ объекта класса Form 1, с которой теперь может работать пользователь. Но главная его работа состоит в том, что он создает настоящее Windows-приложение, запуская цикл обработки сообщений о происходящих событиях. Поступающие сообщения обрабатываются операционной системой согласно очереди и приоритетам, вызывая обработчиков соответствующих событий.
Напомним, что такое статический метод. Это метод, который может быть вызван без инициализации объекта соответствующего класса. Для его вызова используют точечную индексацию: перед именем метода пишется имя класса.
Могут быть и статические поля класса. Перед их именами также пишется через точку имя класса. Есть одна особенность таких полей - их значения одинаковы для всех объектов класса. И еще, если класс содержит только статические элементы, экземпляр класса создавать не требуется. Чтобы поле или метод стал статическим, следует использовать модификатор st a tic. Ранее, в консольных приложениях это делалось постоянно.
Продолжим использование режима пошагового выполнения приложения. На рис. 6.2 программа находится в точке, предваряющей вызов метода Run. Продолжайте нажимать F8 до тех пор, пока не попадете в файл Form1.cs как на рис. 6.3.
Рис. 6.3. Программа в режиме Debug
В этот момент программа остановлена в точке вызова конструктора класса Form1. Продолжайте нажимать F8. При этом попадем в тело конструктора Form1(), а дальше есть два варианта: нажимать F8, то попадать внутрь метода InitializeComponent(), или нажимать Shift-F8, тогда метод InitializeComponent() будет вызван, но его пошаговое выполнение будет обойдено. А дальше? А дальше откроется окно и нажатие кнопки button1 приведет к пошаговому вызову метода button1_Click. И так далее.
Таким образом, освоили режим Debug, который часто используется в режиме отладки приложения. Посмотрите пункт главного меню Debug. Там есть и другие возможности отладки.
Кроме этого, с использованием этого режима стала понятна структура программы, написанной в оконном режиме. Действительно, все начинается с вызова метода Main, находящегося в файле Program.cs. Это место в программе называют точкой входа, а для большей убедительности часто говорят о «точке большего взрыва», имея в виду то, что с этого начинается Вселенная, то есть программа.
Как правило, никаких изменений вносить в этот код не требуется, его даже не открывают в окне редактора кода. Но забывать о нем не следует.
Дата: 2019-11-01, просмотров: 194.
