Первое приложение с .NET CLI
Последнее обновление: 11.11.2022
Для создания графических интерфейсов с помощью платформы .NET применяются разные технологии — Window Forms, WPF, UWP.
Однако наиболее простой и удобной платформой до сих пор остается Window Forms или сокращенно WinForms. Данное руководство ставит своей целью дать понимание принципов создания графических интерфейсов с помощью технологии WinForms
и работы основных элементов управления.
Создадим первое приложение на C# и Windows Forms. Что нам для этого потребуется? Прежде всего необходим текстовый редактор для написания кода программы.
Можно взять любой понравившийся текстовый редактор, например, Visual Studio Code
Также для компиляции и запуска программы нам потребуется .NET SDK. Для его установки перейдем на официальный сайт по ссылке
.NET SDK
После установки .NET SDK для первого проекта определим какую-нибудь папку. Например, в моем случае это будет папка C:\dotnet\winforms\helloapp.
Откроем терминал/командную строку и перейдем к созданной папке проекта с помощью команды cd
cd C:\dotnet\winforms\helloapp
В данном случае мы для создания и запуска проекта мы будем использовать встроенную инфраструктуру .NET CLI, которая устанавливается вместе с .NET SDK.
Для создания проекта в .NET CLI применяется команда dotnet new, после которой указывается тип проWindows Formsекта. Для создания проекта
Windows Forms применяется шаблон — winforms. Поэтому введем в терминале команду
После выполнения этой команды у нас будет создан следующий проект:
Структура проекта Windows Forms
Рассмотрим базовую структуру простейшего стандартного проекта Windows Forms:
-
helloapp.csproj: стандартный файл проекта C#, который соответствует назанию проекта (по умолчанию названию каталога) и описывает все его настройки.
-
helloapp.csproj.user: дополнительный файл проекта C#, который хранит специфичные для текущего пользователя настройки.
-
Form1.cs: содержит класс формы, которая по умолчанию запускается при старте приложения
-
Form1.Designer.cs: он содержит определение компонентов формы, добавленных
на форму в графическом дизайнере (графический дизайнер Windows Forms на данный момент официально доступен только в Visual Studio) -
Program.cs: определяет класс Program, который запускается при старте приложения и запускает форму Form1
Например, посмотрим на содержимое файла helloapp.csproj
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>WinExe</OutputType>
<TargetFramework>net7.0-windows</TargetFramework>
<Nullable>enable</Nullable>
<UseWindowsForms>true</UseWindowsForms>
<ImplicitUsings>enable</ImplicitUsings>
</PropertyGroup>
</Project>
Для компиляции приложения Windows Forms указаны следующие настройки:
-
OutputType: определяет выходной тип проекта. Должен иметь значение WinExe — то есть выполняемое приложение с
расширением exe под Windows -
TargetFramework: определяет применяемую для компиляции версию фреймворка .NET. Поскольку при создании проекта
была выбрана версия .NET 7, а сам проект зависит от компонентов Windows, то здесь должно быть значение net7.0-windows -
Nullable: подключает в проект функционалность ссылочных nullable-типов
-
UseWindowsForms: указывает, будет ли проект использовать Windows Forms (для этого устанавливается значение
true) -
ImplicitUsings: подключает в проект функциональность неявно подключаемых глобальных пространств имен
Запуск проекта
Проект по умолчанию не представляет какой-то грандиозной функциональности, тем не менее этот проект мы уже можем запустить. Итак, запустим проект. Для этого выполним команду
При запуске запускается графическая форма, код которой определяет класс Form1:
Запуск приложения
Файл Program.cs определяет точку входа в приложение:
namespace helloapp;
static class Program
{
[STAThread]
static void Main()
{
ApplicationConfiguration.Initialize();
Application.Run(new Form1());
}
}
Метод Main снабжен атрибутом [STAThread]. Этот атрибут, грубого говоря,
необходим для корректной работы компонентов Windows. В самом методе сначала вызывается метод
ApplicationConfiguration.Initialize()
который устанавливает некоторую базовую конфигурацию приложения
Затем вызывается метод
Application.Run(new Form1());
в который передается объект отображаемой по умолчанию на экране формы.
То есть, когда мы запустим приложение, сработает метод Main, в котором будет вызван метод Application.Run(new Form1()),
благодаря чему мы увидим форму Form1 на экране.
Определение формы
Теперь посмотрим на определение формы и немного изменим его. Для этого откроем файл Form1.cs в текстовом редакторе. По умолчанию он выглядит следующим образом:
namespace helloapp;
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
}
Класс формы — Form1 представляет графическую форму — фактически то окно, которое мы увидим на экране при запуске проекта.
Этот класс определяется как частичный (с модификатором partial) и наследуется от встроенного класса Form,
который содержит базовую функциональность форм.
В самом классе Form1 определен по умолчанию только конструктор, где вызывается метод InitializeComponent(), который выполняет инициализацию компонентов формы из файла дизайнера
Form1.Designer.cs. По сути именно код этого файла передается выше через вызов InitializeComponent()
Теперь изменим его код следующим образом:
namespace helloapp;
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
// определяем кнопку
Button button = new Button();
// текст кнопки
button.Text ="Click";
// положение кнопки
button.Location = new Point(50, 50);
// размер кнопки
button.Size = new Size { Width = 80, Height = 30 };
// обработчик нажатия кнопки
button.Click += (o, e) => MessageBox.Show("Hello METANIT.COM!");
// добавление кнопки на форму
this.Controls.Add(button);
}
}
В данном случае на форму добавляется кнопка, и у нее настраиваются различные свойства, как текст, положение на форме, размер, а также обработчик нажатия.
Заново запустим проект, и нам отобразится та же форма, которая теперь будет содержать кнопку. И по нажатию на кнопку появится маленькое окно с сообщением.
О чем статья
Введение
В данной лекции мы будем изучать приложения Windows Forms – один из основных способов создания графических пользовательских интерфейсов (GUI) в операционной системе Windows. Windows Forms предоставляет набор компонентов и инструментов для создания интерактивных приложений, которые могут взаимодействовать с пользователем через кнопки, текстовые поля, списки и другие элементы управления.
Нужна помощь в написании работы?
Мы — биржа профессиональных авторов (преподавателей и доцентов вузов). Наша система гарантирует сдачу работы к сроку без плагиата. Правки вносим бесплатно.
Цена работы
Определение приложений Windows Forms
Приложения Windows Forms – это тип приложений, которые разрабатываются с использованием Windows Forms, одной из технологий разработки пользовательского интерфейса в Microsoft .NET Framework. Они предоставляют удобный способ создания графического интерфейса для Windows-приложений.
Windows Forms предоставляет набор готовых элементов управления, таких как кнопки, текстовые поля, списки и другие, которые можно использовать для создания интерактивных пользовательских интерфейсов. Они позволяют пользователям взаимодействовать с приложением, вводить данные, просматривать информацию и выполнять различные действия.
Приложения Windows Forms могут быть разработаны на языках программирования, поддерживаемых .NET Framework, таких как C# или Visual Basic. Они могут быть запущены на компьютерах под управлением операционных систем Windows и обеспечивают высокую степень совместимости и надежности.
Основными компонентами приложений Windows Forms являются формы (Form), элементы управления (Control) и события (Event). Формы представляют собой окна приложения, на которых размещаются элементы управления. Элементы управления представляют собой интерактивные объекты, с которыми пользователь может взаимодействовать. События – это действия, которые могут происходить с элементами управления, например, щелчок на кнопке или изменение значения в текстовом поле.
Создание приложений Windows Forms включает в себя проектирование пользовательского интерфейса, добавление элементов управления, написание кода для обработки событий и тестирование приложения. Они могут быть использованы для разработки различных типов приложений, включая игры, утилиты, бизнес-приложения и другие.
Основные компоненты приложений Windows Forms
Приложения Windows Forms состоят из различных компонентов, которые обеспечивают функциональность и взаимодействие с пользователем. Вот основные компоненты, которые вы найдете в приложениях Windows Forms:
Форма (Form)
Форма представляет собой главное окно приложения, на котором размещаются другие элементы управления. Она может содержать заголовок, меню, панели инструментов и другие элементы интерфейса. Форма является контейнером для других элементов управления и определяет внешний вид и поведение приложения.
Элементы управления (Controls)
Элементы управления представляют собой интерактивные объекты, с которыми пользователь может взаимодействовать. Некоторые из наиболее распространенных элементов управления включают кнопки, текстовые поля, метки, списки, таблицы и т. д. Они позволяют пользователю вводить данные, выбирать опции, выполнять команды и просматривать информацию.
Меню (Menu)
Меню предоставляет пользователю доступ к различным командам и функциям приложения. Оно может содержать пункты меню, подменю и команды, которые выполняют определенные действия. Меню обычно располагается в верхней части формы и может быть статическим или выпадающим.
Панель инструментов (Toolbar)
Панель инструментов представляет собой набор кнопок и других элементов управления, которые предоставляют быстрый доступ к наиболее часто используемым командам и функциям приложения. Она обычно располагается под меню и может содержать кнопки для открытия файлов, сохранения данных, печати и других операций.
Диалоговые окна (Dialogs)
Диалоговые окна используются для взаимодействия с пользователем и получения информации или подтверждения. Они могут быть модальными, что означает, что пользователь не может взаимодействовать с другими частями приложения, пока диалоговое окно открыто, или немодальными, что позволяет пользователю продолжать работу с другими частями приложения.
События (Events)
События представляют собой действия, которые могут происходить с элементами управления или формой. Например, щелчок на кнопке, изменение значения в текстовом поле или закрытие формы. Обработка событий позволяет приложению реагировать на действия пользователя и выполнять соответствующие действия или операции.
Это основные компоненты, которые вы найдете в приложениях Windows Forms. Используя их в сочетании, вы можете создавать интерактивные и функциональные приложения, которые удовлетворят потребности пользователей.
Создание приложений Windows Forms
Создание приложений Windows Forms – это процесс разработки графических приложений для операционной системы Windows с использованием технологии Windows Forms. Windows Forms предоставляет набор инструментов и компонентов для создания пользовательского интерфейса и обработки событий.
Шаги создания приложений Windows Forms:
- Создание нового проекта: В Visual Studio выберите “Создать новый проект” и выберите шаблон “Windows Forms приложение”. Задайте имя проекта и место сохранения.
- Разработка пользовательского интерфейса: В окне дизайнера формы вы можете добавлять элементы управления, такие как кнопки, текстовые поля, списки и другие. Вы можете изменять их свойства, такие как размер, положение, цвет и шрифт.
- Настройка свойств элементов управления: Для каждого элемента управления вы можете настроить свойства, такие как текст, изображение, доступность, видимость и другие. Это позволяет вам настроить внешний вид и поведение элементов управления.
- Добавление обработчиков событий: Вы можете добавить обработчики событий для элементов управления, чтобы реагировать на действия пользователя. Например, вы можете добавить обработчик события “Click” для кнопки, чтобы выполнить определенное действие при ее нажатии.
- Написание кода: Вы можете написать код для обработки событий, выполнения операций и взаимодействия с данными. В коде вы можете использовать методы, свойства и события элементов управления, а также другие классы и библиотеки .NET Framework.
- Отладка и тестирование: После написания кода вы можете запустить приложение в режиме отладки, чтобы проверить его работу и исправить ошибки. Вы также можете провести тестирование приложения, чтобы убедиться, что оно работает правильно и соответствует требованиям.
- Сборка и развертывание: После завершения разработки вы можете собрать приложение в исполняемый файл или установочный пакет. Это позволит вам развернуть приложение на других компьютерах и предоставить его пользователям.
Создание приложений Windows Forms позволяет вам создавать интерактивные и функциональные приложения для операционной системы Windows. Вы можете использовать различные элементы управления, настраивать их свойства, добавлять обработчики событий и писать код для реализации требуемой функциональности.
Работа с элементами управления
Элементы управления в приложениях Windows Forms представляют собой графические объекты, которые позволяют пользователю взаимодействовать с приложением. В этом разделе мы рассмотрим основные типы элементов управления и способы работы с ними.
Текстовые поля
Текстовые поля позволяют пользователю вводить текстовую информацию. Вы можете добавить текстовое поле на форму с помощью элемента управления TextBox. Чтобы получить доступ к тексту, введенному пользователем, вы можете использовать свойство Text элемента TextBox.
Кнопки
Кнопки позволяют пользователю выполнить определенное действие. Вы можете добавить кнопку на форму с помощью элемента управления Button. Чтобы добавить обработчик события для кнопки, вы можете использовать событие Click. В обработчике события вы можете написать код, который будет выполняться при нажатии на кнопку.
Списки
Списки позволяют пользователю выбрать один или несколько элементов из предложенного списка. Вы можете добавить список на форму с помощью элемента управления ListBox или ComboBox. Чтобы получить выбранный элемент из списка, вы можете использовать свойство SelectedItem или SelectedItems.
Флажки и переключатели
Флажки и переключатели позволяют пользователю выбрать один или несколько вариантов из предложенного списка. Вы можете добавить флажки и переключатели на форму с помощью элементов управления CheckBox и RadioButton. Чтобы получить выбранный вариант, вы можете использовать свойство Checked элемента CheckBox или RadioButton.
Метки
Метки представляют собой простой текст, который используется для отображения информации или инструкций для пользователя. Вы можете добавить метку на форму с помощью элемента управления Label. Чтобы изменить текст метки, вы можете использовать свойство Text элемента Label.
Изображения
Изображения позволяют отображать графическую информацию в приложении. Вы можете добавить изображение на форму с помощью элемента управления PictureBox. Чтобы загрузить изображение, вы можете использовать свойство Image элемента PictureBox.
Это лишь некоторые из основных элементов управления, доступных в приложениях Windows Forms. Вы можете комбинировать их, настраивать свойства и добавлять обработчики событий, чтобы создать интерактивные и функциональные пользовательские интерфейсы.
Обработка событий в приложениях Windows Forms
События в приложениях Windows Forms представляют собой действия, которые могут происходить в пользовательском интерфейсе, такие как нажатие кнопки, выбор элемента списка или изменение текста в поле ввода. Обработка событий позволяет приложению реагировать на эти действия и выполнять определенные действия в ответ.
Создание обработчиков событий
Для обработки событий в приложениях Windows Forms необходимо создать обработчики событий. Обработчик события – это метод, который будет вызываться при возникновении определенного события. Обработчик события должен соответствовать определенной сигнатуре, которая зависит от типа события.
Для создания обработчика события можно использовать среду разработки Visual Studio. Для этого необходимо выбрать элемент управления, на котором нужно обработать событие, перейти в режим редактирования кода и дважды щелкнуть на элементе управления. В результате Visual Studio автоматически создаст обработчик события и откроет его в редакторе кода.
Привязка обработчиков событий
После создания обработчика события необходимо привязать его к соответствующему элементу управления. Для этого можно использовать свойство “Событие” элемента управления в режиме редактирования формы или привязать обработчик события программно в коде.
Пример привязки обработчика события в коде:
“`csharp
button1.Click += new EventHandler(button1_Click);
“`
В данном примере обработчик события button1_Click будет вызываться при нажатии на кнопку button1.
Работа с аргументами событий
Некоторые события могут передавать дополнительную информацию в обработчик события через аргументы события. Аргументы события содержат информацию о событии, такую как источник события, параметры и т.д. Для доступа к этой информации в обработчике события необходимо использовать аргументы события.
Пример работы с аргументами событий:
“`csharp
private void button1_Click(object sender, EventArgs e)
{
Button button = (Button)sender;
MessageBox.Show(“Нажата кнопка ” + button.Text);
}
“`
В данном примере обработчик события button1_Click получает информацию о нажатой кнопке через аргументы события. Затем он использует эту информацию для отображения сообщения с текстом кнопки.
Обработка событий является важной частью разработки приложений Windows Forms, поскольку позволяет создавать интерактивные и отзывчивые пользовательские интерфейсы. Правильная обработка событий позволяет приложению реагировать на действия пользователя и выполнять нужные действия в ответ.
Макетирование и расположение элементов управления
Макетирование и расположение элементов управления являются важными аспектами разработки приложений Windows Forms. Они определяют, как элементы управления будут размещены на форме и как они будут взаимодействовать друг с другом.
Контейнеры и компоновщики
Для управления расположением элементов управления на форме в Windows Forms используются контейнеры и компоновщики. Контейнеры – это специальные элементы управления, которые могут содержать другие элементы управления. Компоновщики – это классы, которые определяют, как элементы управления будут размещены внутри контейнера.
Некоторые из наиболее часто используемых контейнеров в Windows Forms:
- Form: основной контейнер, представляющий главное окно приложения.
- Panel: контейнер, который может содержать другие элементы управления и обеспечивает группировку и управление ими.
- GroupBox: контейнер, который группирует элементы управления в рамках рамки с заголовком.
- TabControl: контейнер, который позволяет размещать элементы управления на разных вкладках.
Компоновщики определяют, как элементы управления будут размещены внутри контейнера. Некоторые из наиболее часто используемых компоновщиков в Windows Forms:
- FlowLayoutPanel: компоновщик, который автоматически располагает элементы управления в одну строку или столбец.
- TableLayoutPanel: компоновщик, который располагает элементы управления в виде таблицы с ячейками.
- SplitContainer: компоновщик, который разделяет контейнер на две области, которые можно изменять в размере.
Автоматическое и ручное расположение
В Windows Forms можно выбрать между автоматическим и ручным расположением элементов управления.
Автоматическое расположение позволяет компоновщику автоматически определить размер и позицию элементов управления на основе их свойств и настроек компоновщика. Это удобно, когда требуется быстро создать простой макет.
Ручное расположение позволяет разработчику явно задать размер и позицию элементов управления. Это дает большую гибкость и контроль над макетом, но требует более тщательного управления и обновления при изменении размеров формы или элементов управления.
Свойства элементов управления для макетирования
У элементов управления в Windows Forms есть различные свойства, которые можно использовать для управления их расположением и внешним видом:
- Location: определяет позицию элемента управления на форме.
- Size: определяет размер элемента управления.
- Anchor: определяет, как элемент управления будет изменять свой размер при изменении размеров формы.
- Dock: определяет, как элемент управления будет привязан к краям формы или другим элементам управления.
- Margins: определяет отступы вокруг элемента управления.
Использование этих свойств позволяет точно настроить расположение и внешний вид элементов управления на форме.
Макетирование и расположение элементов управления являются важными аспектами разработки приложений Windows Forms. Правильное использование контейнеров, компоновщиков и свойств элементов управления позволяет создавать эффективные и удобные пользовательские интерфейсы.
Работа с данными в приложениях Windows Forms
Работа с данными является важной частью разработки приложений Windows Forms. В приложениях Windows Forms можно использовать различные способы работы с данными, включая привязку данных, использование баз данных и работу с файлами.
Привязка данных
Привязка данных – это механизм, который позволяет связать элементы управления с источником данных, таким как база данных или коллекция объектов. Привязка данных позволяет автоматически обновлять значения элементов управления при изменении данных и сохранять изменения обратно в источник данных.
Для привязки данных в приложениях Windows Forms используется класс BindingSource, который представляет источник данных, и классы Binding, которые связывают элементы управления с полями или свойствами источника данных.
Работа с базами данных
Приложения Windows Forms могут использовать различные типы баз данных, такие как Microsoft SQL Server, MySQL, SQLite и другие. Для работы с базами данных в приложениях Windows Forms используются ADO.NET и LINQ to SQL.
ADO.NET предоставляет набор классов и методов для работы с базами данных. С помощью ADO.NET можно выполнять запросы к базе данных, получать и обновлять данные, а также управлять транзакциями.
LINQ to SQL – это технология, которая позволяет выполнять запросы к базе данных с использованием языка запросов LINQ. LINQ to SQL предоставляет удобный способ работы с данными и автоматически генерирует классы, представляющие таблицы базы данных.
Работа с файлами
Приложения Windows Forms могут также работать с файлами, включая чтение и запись данных в файлы. Для работы с файлами в приложениях Windows Forms используются классы из пространства имен System.IO.
С помощью класса StreamReader можно читать данные из текстовых файлов, а с помощью класса StreamWriter можно записывать данные в текстовые файлы. Классы BinaryReader и BinaryWriter позволяют работать с двоичными файлами.
Кроме того, в приложениях Windows Forms можно использовать классы для работы с XML-файлами, такие как XmlReader и XmlWriter, а также классы для работы с JSON-файлами, такие как JsonSerializer и JsonDeserializer.
Работа с данными в приложениях Windows Forms предоставляет широкие возможности для работы с различными источниками данных и обеспечивает удобный и эффективный способ работы с информацией.
Отладка и тестирование приложений Windows Forms
Отладка и тестирование приложений Windows Forms являются важными этапами в разработке программного обеспечения. Они позволяют выявить и исправить ошибки, проверить работоспособность приложения и убедиться в его качестве перед выпуском.
Отладка приложений Windows Forms
Отладка приложений Windows Forms предоставляет инструменты для поиска и исправления ошибок в коде. Один из основных инструментов отладки – это отладчик, который позволяет пошагово выполнять код, проверять значения переменных, анализировать стек вызовов и многое другое.
Отладчик позволяет установить точки останова в коде, чтобы при выполнении программы остановиться на определенном месте и проанализировать текущее состояние приложения. Это помогает выявить ошибки, проверить правильность работы алгоритмов и устранить проблемы.
Кроме отладчика, в приложениях Windows Forms можно использовать различные инструменты для отладки, такие как логирование, вывод сообщений об ошибках, использование условных операторов для проверки определенных условий и многое другое.
Тестирование приложений Windows Forms
Тестирование приложений Windows Forms включает в себя проверку функциональности, надежности, производительности и удобства использования приложения.
Функциональное тестирование проверяет, выполняет ли приложение все заданные функции и работает ли оно правильно. В процессе функционального тестирования проверяются различные сценарии использования приложения, вводятся различные данные и проверяется правильность работы приложения в различных ситуациях.
Надежность тестирования проверяет, насколько надежно работает приложение. В процессе надежности тестирования проверяется, как приложение обрабатывает ошибки, как оно восстанавливается после сбоев и как оно обрабатывает некорректные данные.
Тестирование производительности проверяет, насколько быстро и эффективно работает приложение. В процессе тестирования производительности измеряется время выполнения различных операций, объем используемой памяти и другие параметры производительности.
Тестирование удобства использования проверяет, насколько удобно и интуитивно понятно приложение для пользователей. В процессе тестирования удобства использования проверяется, насколько легко пользователи могут найти нужные функции, какие возникают сложности при работе с приложением и какие улучшения можно внести для улучшения пользовательского опыта.
Все эти виды тестирования помогают выявить и исправить ошибки, улучшить качество и надежность приложения, а также улучшить пользовательский опыт.
Особенности разработки приложений Windows Forms
Разработка приложений Windows Forms предлагает ряд особенностей, которые делают ее привлекательной для разработчиков. Вот некоторые из них:
Простота использования
Windows Forms предоставляет простой и интуитивно понятный способ создания графического интерфейса пользователя. Разработчики могут использовать готовые элементы управления, такие как кнопки, текстовые поля, списки и другие, чтобы создать интерактивные приложения без необходимости писать сложный код с нуля.
Быстрая разработка
Windows Forms предлагает инструменты и функциональность, которые позволяют разработчикам быстро создавать приложения. Благодаря графическому дизайнеру, разработчики могут визуально создавать интерфейс приложения, добавлять элементы управления и настраивать их свойства без необходимости писать много кода вручную.
Широкий выбор элементов управления
Windows Forms предлагает богатый набор элементов управления, которые можно использовать для создания различных типов приложений. Это включает в себя кнопки, текстовые поля, списки, таблицы, вкладки и многое другое. Разработчики могут выбирать из этого набора элементов управления, чтобы создать интерфейс, который наилучшим образом соответствует потребностям и требованиям их приложения.
Гибкость и настраиваемость
Windows Forms предоставляет разработчикам гибкость и возможность настраивать элементы управления и поведение приложения. Разработчики могут настраивать свойства элементов управления, добавлять обработчики событий, создавать пользовательские элементы управления и многое другое. Это позволяет создавать приложения, которые полностью соответствуют требованиям и предпочтениям пользователей.
Интеграция с другими технологиями Microsoft
Windows Forms хорошо интегрируется с другими технологиями Microsoft, такими как базы данных SQL Server, ASP.NET, WPF и другие. Это позволяет разработчикам создавать приложения, которые могут взаимодействовать с другими системами и использовать их функциональность.
В целом, разработка приложений Windows Forms предлагает простой и эффективный способ создания графического интерфейса пользователя. Она обладает множеством возможностей и инструментов, которые помогают разработчикам создавать интерактивные и настраиваемые приложения.
Сравнительная таблица приложений Windows Forms
| Компонент | Описание | Примеры |
|---|---|---|
| Форма | Окно приложения, на котором размещаются элементы управления | Окно входа, главное окно, окно настроек |
| Элементы управления | Графические объекты, с помощью которых пользователь взаимодействует с приложением | Кнопка, текстовое поле, список, таблица |
| События | Действия, которые могут происходить с элементами управления и вызывать определенные реакции | Нажатие кнопки, изменение значения в поле ввода |
| Макетирование | Организация расположения элементов управления на форме | Выравнивание по центру, группировка элементов |
| Работа с данными | Обработка и отображение данных в приложении | Загрузка данных из базы данных, отображение таблицы с данными |
| Отладка и тестирование | Проверка и исправление ошибок в приложении | Использование отладчика, написание модульных тестов |
| Особенности разработки | Уникальные особенности и возможности при разработке приложений Windows Forms | Использование готовых компонентов, создание пользовательских элементов управления |
Заключение
В данной лекции мы рассмотрели основы создания приложений Windows Forms. Мы изучили основные компоненты и элементы управления, научились обрабатывать события и работать с данными. Также мы рассмотрели макетирование и расположение элементов управления, а также особенности разработки и отладки приложений Windows Forms. Теперь вы готовы приступить к созданию своих собственных приложений с использованием Windows Forms!
Аннотация: В данной лабораторной работе рассматриваются некоторые воможности интегрированной среды разработки программного обеспечения (IDE — Integrated Development Environment) Visual Studio.NET 2005. Установка пароля на главное окно приложения. Добавление списка для запуска упражнений. Смайлики. Краткое описание части компонентов панели Toolbox. Простой калькулятор. Применение коллекций для предотвращения повторных запусков формы. Встраивание COM-объекта «Windows Media Player» в свое приложение. Добавление к форме других элементов управления.
Ключевые слова: разработка программного обеспечения, IDE, integrator, co-development, environment, корпорация, язык программирования, Си, FCL, class library, Basic, browsing, элементы управления, редактор кода, member, диалоговое окно, развертывание, autosizing, Toolbox, flow, ‘padding’, внутренний отступ, dock, fill, commonality, anchor, margin, значение, abort, cancellation, ignore, retry, пользователь, locking, интерфейс, класс, конструктор, event, приложение, список, меню, layout, графический режим, оболочка, предметной области, идентификатор объекта, resource, размер шрифта, bold, BorderStyle, manual, startup, автоматизация, pointer, checkbox, группа пользователей, выборка данных, GroupBox, связывание, полоса прокрутки, detailed, антивирусная защита, открытый файл, bitmap, JPEG, metafile, icon, splitter, относительный размер, Timer, таймер, tooltip, slider, TreeView, вещественное число, calculation, ReadOnly, код программы, CMB, DataGrid, DAT, LBL, PICS, RAD, keypresses, keyboard, keypad, параметр, поле, программа, system, string, псевдоним, адресация, исключение, арифметическая операция, операции, diagnostics, debug, release, преобразование типов, мера, группа, массив, тип коллекции, STL, standard, templates, library, программирование, прикладная программа, ICollection, цикла, последовательный перебор, ArrayList, файл, методы класса, конец файла, restart, мультимедиа, объект, component, object model, объектная модель, choose, компонент, OCX, player, rating, filename, muting, ‘volume’, duration, ‘bottom’, play, rewind, этапы проектирования, Графический редактор, Filtered, испытание, AVI, обработка исключений, конструктор класса, операция присваивания, ‘widows’, minimum, захват, шкала, maximum, целый тип, orientation, horizontal, handling, scroll, индикатор, MIN, appearance, tick
Файлы к лабораторной работе Вы можете скачать 
здесь.
В данной лабораторной работе мы рассмотрим некоторые возможности
интегрированной среды разработки программного обеспечения
( IDE — Integrated Development
Environment ) Visual Studio.NET 2005. Мы будем
использовать разработанный корпорацией Microsoft самый красивый
и современный язык программирования C# (Си-шарп). Мы будем
опираться на мощную библиотеку классов .NET Framework ( FCL —
Framework Class Library, она же BCL —
Basic Class Library).
Создание заготовки приложения
-
Выполните
команду File/New/Project оболочки для создания нового проекта
Выполните
-
В
диалоговом окне New Project выберите кнопкой Browse папку
для размещения проекта, задайте тип, шаблон и имя проекта WinFormsApp
После щелчка на кнопке OK мастер создаст
заготовку приложения и выведет в режиме дизайна пустую форму,
которая при запуске приложения будет представлять окно. Стандартный
размер сгенерированной формы равен 300×300.
Сделаем эту форму стартовой и разместим на ней элементы управления
для вызова дочерних форм, реализующих отдельные упражнения
данной работы.
-
Откройте
панель Solution Explorer оболочки и переименуйте файл Form1.cs в файл Start.cs
-
Щелкните
на форме правой кнопкой мыши и выполните команду контекстного
меню View Em, чтобы вызвать представление файла Start.cs в режиме редактора кода
-
В
режиме кода вызовите комбинацией клавиш Ctrl-F
окно Find and Replace для замены всех
вхождений Form1 на Start.
После заполнения полей поиска и замены щелкните на кнопке Replace All
-
В
раскрывающемся списке Members выделите функцию InitializeComponent(),
чтобы быстро позиционироваться в соответствующее место
кода
-
Отредактируйте
в функции InitializeComponent() код
установки заголовка окна в режиме выполнения
private void InitializeComponent()
{
this.components = new System.ComponentModel.Container();
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.Text = "Lab38 - Снетков";
}
Листинг
25.1.
Замена кода установки заголовка окна в режиме выполнения
Установка пароля на главное окно приложения
Теперь давайте добавим к главной форме Start код
поддержки пароля при запуске приложения. Для этого нам потребуется
диалоговое окно с текстовым полем. Сконструируем его. Создание
диалогового окна будет состоять из трех шагов:
- Создание самой формы диалогового окна (класс InputPassword )
- Размещение на форме интерфейсных элементов пользователя
- Создание кода, управляющего диалоговым окном
-
В
панели Solution Explorer выделите корневой
узел проекта и командой Add/Windows Form добавьте
в проект файл формы с именем InputPassword.cs
| Свойство | Значение | Пояснения |
|---|---|---|
| StartPosition | CenterScreen | Открывать в центре экрана |
| FormBorderStyle | FixedDialog | Запретить пользователю менять размер |
| MaximizeBox | false | Отключить системную кнопку развертывания |
| MinimizeBox | falseStandardDialogs | Отключить системную кнопку свертывания |
| ShowInTaskbar | false | Запретить появление в панели задач |
| AutoSize | true | Подстраиваться под содержимое |
| AutoSizeMode | GrowAndShrink | Подстраиваться под содержимое (расширяться и сжиматься) |
| Text | Пусто | Заголовок окна |
-
Из
свитка Containers панели инструментов Toolbox поместите
на форму компоновочную панель FlowLayoutPanel и
настройти ее в соответствии с таблицей
| Свойство | Значение | Пояснения |
|---|---|---|
| Name | flow | Имя компоновочной панели |
| AutoSize | true | Подстраиваться под содержимое |
| FlowDirection | TopDown | Размещать сверху вниз |
| WrapContents | false | Не переносить дочерние элементы в следующий столбец |
| Padding.All | 8 | Внутренний отступ дочерних элементов по периметру окна |
| Dock | Fill | Распахнуть на всю клиентскую область родителя (формы) |
Эта панель будет автоматически следить за размещением своих
дочерних элементов в соответствии с настройками.
-
Выделите
на форме компоновочную панель flow, чтобы
именно она принимала дочерние элементы, поместите в нее
из свитка Common Controls текстовую метку Label и
настройте ее свойства в соответствии с таблицей
| Свойство | Значение | Пояснения |
|---|---|---|
| Name | lblMessage | Имя текстовой метки |
| AutoSize | true | Подстраиваться под содержимое |
| Anchor | None | Расположить посредине |
| Margin.All | 8 | Отступ по наружному периметру текстовой метки |
-
Аналогичным
образом поместите в панель flow последовательно
экземпляры компонентов TextBox и Button,
которые настройте так
| Свойство | Значение | Пояснения |
|---|---|---|
| Name | txtInput | Имя текстовой метки |
| Anchor | None | Расположить посредине |
| Margin.All | 8 | Отступ по наружному периметру текстовой метки |
| PasswordChar | * | Эхо ввода в текстовом поле |
| Свойство | Значение | Пояснения |
|---|---|---|
| Name | btnOk | Имя кнопки |
| AutoSize | true | Подстраиваться под содержимое |
| Anchor | None | Расположить посредине |
| Margin.All | 8 | Отступ по наружному периметру кнопки |
| Text | OK | Надпись |
| DialogResult | OK | Назначить статус «кнопки OK» в родительской форме |
Свойству дочерних кнопок формы DialogResult можно
присвоить любое значение из перечисления System.Windows.Forms.DialogResult ( Abort, Cancel, Ignore, No, None, OK, Retry, 25_73 ).
Оно и будет возвращено функцией ShowDialog() формы,
если пользователь выберет именно эту кнопку. Если свойству DialogResult кнопки
будет присвоен статус, отличный от None,
то при щелчке пользователя на такой кнопке форма будет автоматически
закрываться.
-
Подтяните
низ формы до приемлемого размера, чтобы она стала выглядеть
примерно так
-
Откройте
файл InputPassword.cs в режиме View
Designer, щелкните на заголовке формы и выполните
команду Format/Lock Controls, чтобы защитить
интерфейс формы от случайных изменений. Это групповая команда,
которая устанавливает свойство Locked всех
дочерних визуальных элементов и самой формы в значение True.
То же самое можно сделать индивидуально для каждого элемента
через меню Properties
Мы создали сам пользовательский интерфейс класса InputPassword диалогового
окна. Теперь нужно настроить класс InputPassword,
добавив туда метод создания диалогового окна и вызова его
на экран.
-
Модифицируйте
класс InputPassword следующим образом
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;
namespace WinFormsApp
{
public partial class InputPassword : Form
{
public InputPassword()
{
InitializeComponent();
}
public InputPassword(string windowTitle, string message)
{
InitializeComponent();
this.Text = windowTitle;
lblMessage.Text = message;
}
public static string Show(string windowTitle, string message)
{
using(InputPassword inputDlg =
new InputPassword(windowTitle, message))
{
inputDlg.ShowDialog();
return inputDlg.txtInput.Text;
}
}
}
}
Листинг
25.2.
Класс диалогового окна InputPassword в файле InputPassword.cs
Мы создали параметризованный конструктор для ввода заголовков
диалогового окна в момент его создания. Мы добавили статический
метод создания диалогового окна, который возвращает значение
текстового поля после щелчка пользователем на кнопке, и такой
метод нужно вызывать по имени класса. Упаковка создания экземпляра
формы в блок using позволяет вызвать сборщик
мусора сразу после выхода из этого блока.
Теперь нужно поместить вызов окна запроса пароля в обработчик
события Load запуска формы.
-
Откройте
файл Start.cs в режиме View Designer,
выделите форму через ее заголовок, перейдите в панель Properties,
установите ее в режим Events, найдите
событие Load и создайте для него обработчик Start_Load().
Заполните обработчик события так
private void Start_Load(object sender, System.EventArgs e)
{
string password = InputPassword.Show(
"Окно аутентификации пользователя",
"Просим ввести Ваш пароль:");
if (password != "root")// Плохой способ хранения пароля
{
MessageBox.Show(
"Извините, но Вам не разрешено\n" // Сообщение
+ "пользоваться этой суперпрограммой!!!",
"Неверный пароль", // Заголовок окна
MessageBoxButtons.OK, // Кнопка OK
MessageBoxIcon.Stop);// Критическая иконка
this.Close();
}
}
Листинг
25.3.
Обработчик события начальной загрузки главной формы Start приложения
-
Запустите
приложение, диалоговое окно ввода пароля должно
выглядеть так
При неправильном пароле появляется простое диалоговое окно
сообщений
и приложение завершит свою работу.
В этом обзоре рассматриваются преимущества интеллектуальных клиентских приложений, основные возможности программирования Windows Forms, а также использование Windows Forms для разработки интеллектуальных клиентов, удовлетворяющих запросам современных предприятий и конечных пользователей.
Windows Forms и интеллектуальные клиентские приложения
Windows Forms позволяет разрабатывать интеллектуальные клиенты. Интеллектуальный клиент — это приложение с полнофункциональным графическим интерфейсом, простое в развертывании и обновлении, способное работать при наличии или отсутствии подключения к Интернету и использующее более безопасный доступ к ресурсам на локальном компьютере по сравнению с традиционными приложениями Windows.
Создание интерактивных пользовательских интерфейсов
Windows Forms — это технология разработки интеллектуальных клиентов для .NET Framework. Она представляет собой набор управляемых библиотек, упрощающих выполнение стандартных задач, таких как чтение из файловой системы и запись в нее. При использовании среды разработки, например Visual Studio, можно создавать приложения интеллектуальных клиентов Windows Forms, которые отображают информацию, запрашивают ввод от пользователей и взаимодействуют с удаленными компьютерами по сети.
Форма в Windows Forms — это визуальная поверхность, на которой выводится информация для пользователя. Обычно приложение Windows Forms строится путем помещения элементов управления на форму и написания кода для реагирования на действия пользователя, такие как щелчки мыши или нажатия клавиш. Элемент управления — это отдельный элемент пользовательского интерфейса, предназначенный для отображения или ввода данных.
При выполнении пользователем какого-либо действия с формой или одним из ее элементов управления создается событие. Приложение реагирует на эти события с помощью кода и обрабатывает события при их возникновении. Подробнее см. в разделе Создание обработчиков событий в Windows Forms.
Windows Forms включает широкий набор элементов управления, которые можно добавлять на формы: текстовые поля, кнопки, раскрывающиеся списки, переключатели и даже веб-страницы. Список всех элементов управления, которые можно использовать на форме, представлены в разделе Элементы управления для использования в формах Windows Forms. Если существующий элемент управления не удовлетворяет потребностям, в Windows Forms можно создать пользовательские элементы управления с помощью класса UserControl.
В состав Windows Forms входят многофункциональные элементы пользовательского интерфейса, позволяющие воссоздавать возможности таких сложных приложений, как Microsoft Office. Используя элементы управления ToolStrip и MenuStrip, можно создавать панели инструментов и меню, содержащие текст и рисунки, подменю и другие элементы управления, такие как текстовые поля и поля со списками.
С помощью Visual Studio и конструктора Windows Forms, можно легко создавать приложения Windows Forms путем перетаскивания элементов на формы. Достаточно выделить элемент управления курсором и поместить его в нужное место на форме. Для преодоления трудностей, связанных с выравниванием элементов управления, конструктор предоставляет такие средства, как линии сетки и линии привязки. С помощью Visual Studio или компиляции из командной строки, можно использовать элементы управления FlowLayoutPanel, TableLayoutPanel и SplitContainer для создания сложных макетов форм за короткое время.
Наконец, если нужно создать свои собственные элементы пользовательского интерфейса, пространство имен System.Drawing содержит широкий набор классов, необходимых для отрисовки линий, кругов и других фигур непосредственно на форме.
Note
Элементы управления Windows Forms не предназначены для маршалинга между доменами приложений. По этой причине технологии Майкрософт не поддерживают передачу элементов управления Windows Forms через границы AppDomain, хотя на первый взгляд базовый тип Control, класс MarshalByRefObject, подразумевает такую возможность. Приложения Windows Forms с несколькими доменами приложений поддерживаются только при условии, что элементы управления Windows Forms не передаются через границы доменов приложения.
Создание форм и элементов управления
Пошаговые инструкции по использованию этих возможностей можно найти в приведенных ниже разделах справки.
| Описание | Раздел справки |
|---|---|
| Использование элементов управления в формах | Практическое руководство. Добавление элементов управления Windows Forms |
| Использование элемента управления ToolStrip | Практическое руководство. Создание базового элемента управления ToolStrip со стандартными элементами с помощью конструктора |
| Создание графических элементов с помощью System.Drawing | Приступая к программированию графики |
| Создание пользовательских элементов управления | Практическое руководство. Наследование класса UserControl |
Отображение данных и управление ими
Во многих приложениях нужно отображать данные из базы данных, XML-файла, веб-службы XML или другого источника данных. Windows Forms предоставляет гибкий элемент управления с именем DataGridView для отображения таких табличных данных в традиционном формате строк и столбцов так, что каждый фрагмент данных занимает свою собственную ячейку. С помощью DataGridView можно, помимо прочего, настроить внешний вид отдельных ячеек, зафиксировать строки и столбцы на своем месте, а также обеспечить отображение сложных элементов управления внутри ячеек.
При использовании интеллектуальных клиентов Windows Forms можно легко подключаться к источникам данных по сети. Компонент BindingSource представляет собой соединение с источником данных и предоставляет методы для привязки данных к элементам управления, перехода к предыдущей и последующей записи, редактирования записей и сохранения изменений обратно в исходный источник. Элемент управления BindingNavigator предоставляет простой интерфейс на основе компонента BindingSource для перехода между записями.
Вы можете легко создавать элементы управления с привязкой к данным с помощью окна «Источники данных». В нем приводятся имеющиеся в проекте источники данных, такие как базы данных, веб-службы и объекты. Создавать элементы управления с привязкой к данным можно путем перетаскивания объектов из этого окна в формы проекта. Также можно связывать существующие элементы управления с данными, перетаскивая объекты из окна «Источники данных» в существующие элементы управления.
Другой тип привязки к данным в формах Windows Forms — это параметры. Большинство интеллектуальных клиентских приложений должны сохранять некоторые сведения о своем состоянии во время выполнения, такие как последние известные размеры форм, а также сохранять пользовательские предпочтения, например место сохранения файлов по умолчанию. Параметры приложения отвечает этим требованиям, предоставляя простой способ хранения обоих типов сведений на клиентском компьютере. После определения этих параметров с помощью Visual Studio или редактора кода, значения параметров сохраняются в XML и автоматически считываются обратно в память во время выполнения.
Отображение данных и управление ими
Пошаговые инструкции по использованию этих возможностей можно найти в приведенных ниже разделах справки.
| Описание | Раздел справки |
|---|---|
| Использование компонента BindingSource | Практическое руководство. Привязка элементов управления Windows Forms с компонентом BindingSource с помощью конструктора |
| Работа с источниками данных ADO.NET | Практическое руководство. Сортировка и фильтрация данных ADO.NET с помощью Windows Forms посредством компонента BindingSource |
| Использование окна «Источники данных» | Привязка элементов управления Windows Forms к данным в Visual Studio |
| Использование параметров приложения | Практическое руководство. Создание параметров приложения |
Развертывание приложений на клиентских компьютерах
После создания приложения необходимо отправить его пользователям, чтобы они могли установить и запустить его на своих клиентских компьютерах. При использовании технологии ClickOnce, можно развернуть приложения в Visual Studio с помощью нескольких щелчков и предоставить пользователям URL-адрес приложения в Интернете. ClickOnce управляет всеми элементами и зависимостями в приложении и обеспечивает его правильную установку на клиентском компьютере.
Приложения ClickOnce можно настроить так, чтобы они работали либо только при подключении к сети, либо как в сетевом, так и в автономном режиме. Если вы указываете, что приложение должно поддерживать работу в автономном режиме, то технология ClickOnce добавляет ссылку на приложение в меню Пуск пользователя. Пользователь может открыть приложение без использования URL-адреса.
Когда вы обновляете приложение, на веб-сервере публикуется новый манифест развертывания и новая копия приложения. ClickOnce обнаруживает доступное обновление и обновляет пользовательскую установку. Для обновления старых сборок написание специального кода не требуется.
Развертывание приложений ClickOnce
Общие сведения о ClickOnce можно найти в разделе Развертывание и безопасность технологии ClickOnce. Пошаговые инструкции по использованию этих возможностей можно найти в приведенных ниже разделах справки.
| Описание | Раздел справки |
|---|---|
| Развертывание приложения с помощью ClickOnce | Практическое руководство. Публикация приложения ClickOnce с помощью мастера публикации
Пошаговое руководство: Развертывание вручную приложения ClickOnce |
| Обновление приложений при развертывании через ClickOnce | Практическое руководство. Управление обновлениями для ClickOnce-приложения |
| Управление безопасностью в ClickOnce | Практическое руководство. Включение параметров безопасности ClickOnce-приложений |
Другие элементы управления и функции
В Windows Forms имеется множество других возможностей, которые упрощают и ускоряют реализацию распространных задач, таких как создание диалоговых окон, печать, добавление справки и документации, а также локализация приложений на различных языках. Кроме того, в Windows Forms применяется эффективная система безопасности .NET Framework. Благодаря ей можно создавать более надежные приложения.
Реализации других элементов управления и компонентов
Пошаговые инструкции по использованию этих возможностей можно найти в приведенных ниже разделах справки.
| Описание | Раздел справки |
|---|---|
| Печать содержимого формы | Практическое руководство. Печать графических изображений в Windows Forms
Практическое руководство. Печать многостраничных текстовых файлов в Windows Forms |
| Дополнительные сведения о безопасности в Windows Forms | Общие сведения о безопасности в Windows Forms |
См. также
- Приступая к работе с Windows Forms
- Создание новой формы Windows Forms
- Общие сведения об элементе управления ToolStrip
- Общие сведения об элементе управления DataGridView
- Общие сведения о компоненте BindingSource
- Общие сведения о параметрах приложений
- Развертывание и безопасность технологии ClickOnce
ЛЕКЦИЯ №10
ТЕМА: «ВВЕДЕНИЕ В РАЗРАБОТКУ ГРАФИЧЕСКИХ
ПОЛЬЗОВАТЕЛЬСКИХ ИНТЕРФЕЙСОВ С ИСПОЛЬЗОВАНИЕМ
ТЕХНОЛОГИИ WINDOWS FORMS»
Для Windows-приложений, ориентированных на выполнение в общеязыковой исполняющей среде (CLR), в качестве основы построения графического пользовательского интерфейса используются классы Windows
Forms из библиотек .NET Framework, т.е. Windows Forms – это набор средств для создания Windows-приложений, выполняющихся в среде CLR.
Средства Windows Forms обеспечивают быструю разработку пользовательского интерфейса, поскольку он создается из стандартных элементов, а соответствующий программный код генерируется автоматически. Затем требуется лишь доработать сгенерированный код, чтобы добиться необходимой функциональности.
Применяя Windows Forms, можно построить удобный пользовательский интерфейс, в том числе главное окно приложения, выбирая подходящие элементы управления, с которыми взаимодействует пользователь.
Чтобы создать Windows-приложение на основе Windows Forms, следует выбрать команду главного меню «Файл» (File) → «Создать» (New) →
«Проект» (Project), затем выбрать тип проекта «Рабочий стол» (Windows Desktop), а в качестве шаблона проекта указать Windows Forms Application
(Рисунок 1).
1
Рисунок 1
После этого следует ввести имя проекта, например, PR1, и указать папку для хранения проекта.
После этого Visual Studio откроет наш проект с созданными по умолчанию файлами:
Рисунок 2
Большую часть пространства Visual Studio занимает графический
дизайнер, который содержит форму будущего приложения. Пока она пуста и
2
имеет только заголовок Form1. Справа находится окно файлов решения/проекта — Solution Explorer (Обозреватель решений). Там и находятся все связанные с нашим приложением файлы, в том числе файлы формы
Form1.cs.
Внизу справа находится окно свойств — Properties. Так как в данный момент выбрана форма как элемент управления, то в этом поле отображаются свойства, связанные с формой.
Размещения элементов управления на форме
Для размещения различных элементов управления на форме используется Панель инструментов (Toolbox). Панель элементов содержит элементы управления, сгруппированные по типу. Каждую группу элементов можно свернуть, если она в настоящий момент не нужна. (Рисунок 3)
Рисунок 3
3
Чтобы добавить элементы управления на форму, необходимо щелкнуть на добавляемый элемент в панели инструментов, а затем щелкнуть в нужном месте формы. После этого элемент появится на форме (Рисунок 4).
Рисунок 4 – Форма с добавленными элементами управления (TextBox и Button)
Элемент можно перемещать по форме, схватившись за него левой кнопкой мыши. Если элемент управления позволяет изменять размеры, то на соответствующих его сторонах появятся белые кружки, ухватившись за которые и можно изменить размер. При размещении элемента управления на форме, его можно выделить щелчком мыши и получить доступ к его свойствам в окне свойств.
Размещение строки ввода
Если необходимо ввести из формы в программу или вывести в форму информацию, которая вмещается в одну строку, используют окно однострочного редактора текста, представляемого элементом управления
TextBox.
Создадим поле для ввода имени пользователя. Выберем на панели инструментов пиктограмму с названием «TextBox», щелкните мышью в том месте формы, где хотите ее разметить. После размещения элемента можно в
4
тексте программы использовать переменную textBox1, которая соответствует добавленному элементу управления. В этой переменной, в свойстве Text будет содержаться строка символов (типа string) и отображаться в соответствующем окне TextBox. С помощью окна свойств можно установить шрифт и размер символов, отражаемых в строке TextBox (свойство Font).
Размещение надписей
На форме могут размещаться пояснительные надписи. Для размещения таких надписей на форму используется элемент Label. Выберите на панели инструментов пиктограмму с названием Label, щелкните на ней мышью.
После этого в нужном месте формы щелкните мышью, появится надпись label1. Щелкнув на ней мышью, можно отрегулировать размер и, изменив свойство Text в окне свойств, введите строку, например, «Введите свое имя:»,
а также выберите размер символов (свойство Font). Добавленный элемент представлен в форме на рисунке 5.
Рисунок 5 – Форма с добавленным элементом Label
Втексте программы можно обращаться к новой переменной типа Label.
Вней хранится пояснительная строка, которую можно изменять в процессе работы программы.
Написание программы обработки события
5
С каждым элементом управления на форме и с самой формой могут происходить события во время работы программы. Например, с кнопкой может произойти событие – нажатие кнопки, а с окном, которое проектируется с помощью формы, может произойти ряд событий: создание окна, изменение размера окна, щелчок мыши на окне и т.п. Эти события могут обрабатываться программно. Для обработки таких событий используются специальные методы – обработчики событий. Создать такие методы можно двумя способами.
Первый способ – создать обработчик для события по умолчанию.
Например, при нажатии кнопки на форме таким образом создается обработчик события нажатия.
Написание программы обработки события нажатия кнопки
Поместите на форму кнопку, которая описывается элементом управления Button. С помощью окна свойств измените заголовок (Text) на слово «Привет» или другое по вашему желанию. Отрегулируйте положение и размер кнопки.
После этого два раза щелкните мышью на кнопке, появится текст программы:
private void button1_Click(object sender, EventArgs e)
{
}
Этот метод и будет являться обработчиком события нажатия кнопки. Вы можете добавлять свой код между скобками {…}. Например, наберите:
private void button1_Click(object sender, EventArgs e)
{
MessageBox.Show(«Привет » + textBox1.Text + «!»);
}
При нажатии на кнопку выведется окно с сообщением «Привет»,
которое соединено с текстом, записанным пользователем в textBox1
(Рисунок 6).
6
Рисунок 6 – Окно с сообщением, появившееся при нажатии кнопки button1
Написание программы обработки события загрузки формы
Второй способ создания обработчика события заключается в выборе соответствующего события для выделенного элемента на форме. При этом используется окно свойств и его закладка 
. Рассмотрим этот способ.
Выделите форму щелчком по ней, чтобы вокруг нее появилась рамка из точек.
В окне свойств найдите событие Load. Щелкните по данной строчке дважды мышкой. Появится метод:
private void Form1_Load(object sender, EventArgs e)
{
}
Между скобками {…} вставим текст программы:
private void Form1_Load(object sender, EventArgs e)
{
BackColor = Color.AntiqueWhite;
}
Свойство BackColor позволяет изменить цвет фона. Результат выполнения данного метода представлен на рисунке 7.
7
Рисунок 7 – Форма с измененным фоном
Каждый элемент управления имеет свой набор обработчиков событий,
однако некоторые из них присущи большинству элементов управления.
Наиболее часто применяемые события описаны ниже:
1)Load – событие, возникающее при загрузке формы. В обработчике данного события следует задавать действия, которые должны происходить в момент создания формы, например, установка начальных значений.
2)KeyPress – событие, возникающее при нажатии кнопки на клавиатуре.
Параметр e.KeyChar имеет тип char и содержит код нажатой клавиши
(например, клавиша Enter клавиатуры имеет код #13, клавиша Esc — #27 и т.д.).
Обычно это событие используется в том случае, когда необходима реакция на нажатие одной из клавиш.
3) KeyDown – событие, возникающее при нажатии кнопки на клавиатуре. Обработчик этого события получает информацию о нажатой клавише и состоянии клавиш Shift, Alt и Ctrl, а также о нажатой кнопке мыши.
Информация о клавише передается параметром e.KeyCode, который представляет собой перечисление Keys с кодами всех клавиш, а информацию
оклавишах-модификаторах Shift и др. можно узнать из параметра e.Modifiers.
4)KeyUp – является парным событием для KeyDown и возникает при отпускании ранее нажатой клавиши.
5)Click – возникает при нажатии кнопкой мыши в области элемента управления.
8
6) DoubleClick – возникает при двойном нажатии кнопки мыши в области элемента управления.
Важное примечание — если какой-то обработчик был добавлен по ошибке или больше не нужен, то для его удаления нельзя просто удалить программный код обработчика. Сначала нужно удалить строку с именем обработчика в окне свойств в закладке с событиями. В противном случае программа может перестать компилироваться и даже отображать форму в дизайнере VS.
Динамическое изменение свойств
Свойства элементов на окне могут быть изменены динамически во время выполнения программы. Например, можно изменять текст надписи или цвет формы. Изменение свойств происходит внутри обработчика события
(например, обработчика события нажатия на кнопку). Для этого используют оператор присвоения вида:
<имя элемента>.<свойство> = <значение>;
Например,
label1.Text = “Hello”;
<имя элемента> определяется на этапе проектирования формы, при размещении элемента управления на форме. Например, при размещении на форме ряда элементов TextBox, эти элемента получают имена textBox1, textBox2, textBox3 и т.д., которые могут быть заменены в окне свойств в свойстве (Name) для текущего элемента. Список свойств для конкретного элемента можно посмотреть в окне свойств.
Если требуется изменить свойства формы, то никакое имя элемента перед точкой вставлять не нужно, как и саму точку. Например, чтобы задать цвет формы, нужно просто написать:
BackColor = Color.Green;
Ввод и вывод данных в программу
Рассмотрим один из способов ввода данных через элементы,
размещенные на форме. Для ввода данных чаще всего используют элемент
9
управления TextBox, через обращение к его свойству Text. Свойство Text
хранит в себе строку введенных символов. Поэтому данные можно считать следующим образом:
private void button1_Click(object sender, EventArgs e)
{
string s = textBox1.Text;
}
Однако со строкой символов трудно производить арифметические операции, поэтому лучше всего при вводе числовых данных перевести строку в целое или вещественное число. Для этого у типов int и double существуют методы Parse для преобразования строк в числа. С этими числами можно производить различные арифметические действия. Таким образом,
предыдущий пример можно переделать следующим образом:
Перед выводом числовые данные следует преобразовать назад в строку.
Для этого у каждой переменной существует метод ToString(), который возвращает в результате строку с символьным представлением значения.
Вывод данных можно осуществлять в элементы TextBox или Label, используя свойство Text. Например,
private void button1_Click(object sender, EventArgs e)
{
string s = textBox1.Text; int a = int.Parse(s);
int b = a * a;
label1.Text = b.ToString();
}
Кнопки-переключатели
При создании программ в Visual Studio для организации разветвлений часто используются элементы управления в виде кнопок-переключателей.
Кнопки-переключатели представлены в панели инструментов как RadioButton.
Состояние такой кнопки (включено-выключено) визуально отражается на форме, а в программе можно узнать его помощью свойства Checked: если
10
Соседние файлы в папке Лекции
- #
- #
- #
- #
- #
- #
- #
- #