C# windowsform — Windows Form на c#


Содержание

C# windowsform — Windows Form на c#

Уроки Windows Forms C++/C#

Элементы button textBox и label в MVS C++/C#

В этом уроке буден показано создание первой простой, но полноценной программы. Суть которой в том, что вы пишите в текстовом поле какое-то предложение, нажимаете на копку и на форме появляется надпись – тоже самое предложение. Для тех ещё не прочитал введение, нужно знать, для того, чтобы создать проект в Windows Forms нужно запустить Microsoft Visual Studio C++\C#, нажать “Создать проект”, выбрать (слева) “CLR”, далее выберите “Приложение Windows Forms” и назовите свой проект, например, “first_lesson()”. И так, познакомимся сначала с интерфейсом компилятора: справа от вас находиться панель всевозможных инструментов (элементов), а слева, собственно, сама форма, на которую вы и будете размещать, выбранные вами, элементы.

Нажмём на “Стандартные элементы” и выберем из них – «button» «textbox» и «label, перетаскивая из поочерёдно на форму.

Нажав, например, на кнопку «button1», справа вы увидите ёё свойства, их там очень много. Для начала выберете свойство «Text» и напишите там вместо «button1»– “Копировать”. В дальнейшем большую часть свойств мы будем изменять программным кодом – так эффективней и удобней.

Так же вы наверняка уже заметели, что размер формы и элементов можно изменять. Сделайте так же как показанно здесь.

Далее щёлкните два раза по форме – перед вами раскроется новое окно с программным кодом, в котором мы и будем, собственно, писать код. В данном случае откроется событие Form_Load, где вам нужно написать label1->Text = «»; В конце урока будет показан код и на C#. Эта строка говорит о том, что, когда произойдёт запуск (загрузка) программы, текст «label1» станет равным «».

После этого нажмите наверху «Form1.h[Конструктор]». Откроется Событие «button1_Click». Напишите в нём label1->Text = textBox1->Text; Это будет говорить о том, что когда, при загрузке формы, вы нажмёте (clickните) на кнопку произойдёт описанное действие – текст, написанный, в “textBox1” скопируется в «label1». Далее приведён код на «C++» и «C#», после чего показан результат работы программы.

#pragma endregion private: System::Void Form1_Load(System::Object^ sender, System::EventArgs^ e) < label1->Text = «»; > private: System::Void button1_Click(System::Object^ sender, System::EventArgs^ e) < label1->Text = textBox1->Text; > >; >

Введение в Windows Forms — пишем первую программу

В данной статье будет рассказано о том как написать простой обработчик событий на C++ для приложения Windows Forms, работающего под управления .NET Framework. Мы создадим простейшую Windows программу, которая вычисляет факториал целого числа. Для написания данной программы Вам понадобится Visual Studio 2008 Express Edition или Professional.

Для начала создадим проект.

Откроем Visual Studio, далее жмем Файл→Создать→Проект, далее выбираем пункт CLR и отмечаем Приложение Windows Forms, даем имя проекта, к примеру factr и жмем Ok.

После того как мы создали проект, должна появиться пустая форма, которая должна выглядеть примерно так:

Справа должна появиться панель элементов, если ее нет, то можно включить ее в меню Вид→Панель Элементов или нажатием горячих клавиш — Ctrl + Alt + X.

На ней расположены различные элементы для вставки в форму, нам понадобятся только элементы Button (Кнопка), Label (Надпись) и TextBox (Текстовое поле). Перетащите на форму три элемента Label, Два элемента TextBox, и одну кнопку (Button), расставьте элементы примерно так:

Теперь нам нужно будет изменить текст надписей для элементов Label и Button и Задать подходящие имена классов для элементов TextBox. Для этого Выделите элемент label1, перейдите в Панель свойств, (обычно она находится под Панелью элементов, если панель выключена, включите ее в меню Вид -> Диспетчер свойств.) и задайте для данного элемента значение атрибута Text как показано на рисунке.

Задайте атрибут Text для всех элементов Label и Кнопки Button аналогичным образом. Наша форма должна принять примерно следующий вид:

Я сделал кнопку развернуть неактивной, так как изменение размеров данной формы испортит ее внешний вид, Вы также можете это сделать, щелкнув левой кнопкой мыши на пустом месте формы и в Панели свойств задать для атрибута MaximizeBox параметр False.

Теперь задайте для текстовых полей (TextBox) Атрибуты Name в Панели Свойств – для первого поля это будет num1, а для второго, соответственно num2. Тем самым мы изменили имена классов для полей TextBox, чуть позднее Вы поймете зачем.

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

Первым делом нужно добавить заголовочный файл fact.h в проект, для этого щелкаем правой кнопкой мыши в Обозревателе решений на папке Заголовочные файлы, далее меню Добавить -> Создать Элемент, вписываем название файла – fact.h и нажимаем Добавить. В данном файле будет содержаться прототип функции для вычисления факториала. Добавляем туда следующий исходный код.

Далее подключаем этот файл к проекту с помощью директивы #include – Открываем файл factr.cpp и добавляем после строчки #include «stdafx.h» следующий код.

Теперь наш заголовочный файл подключен к проекту, далее аналогичным образом создаем файл исходного кода fact.cpp в проект.

В него добавляем саму функцию вычисления факториала целого числа.

Теперь наш проект содержит функцию вычисления факториала, откомпилируйте его, если ошибок нет, то можно приступить к написанию обработчика событий для кнопки Button.

Открываем файл Form.h, в нем мы видим визуальное представление нашей формы. Щелкаем двойным щелчком на кнопке Button и переходим к исходному коду.

После фигурной скобки ставим абзац и приступаем к кодированию. Любой набор символов, которые мы вводим с клавиатуры в текстовое поле программы является строкой, поэтому нам нужно вытащить значение из текстового поля и привести его к целочисленному типу. Это довольно сложная процедура, но, к счастью в языке C++ уже есть множество функций, выполняющих конвертирование типов данных. Сначала нам необходимо описать и инициализировать переменную, в которой будет храниться значение числа, для которого должен быть вычислен факториал. Добавим в том место, где Вы поставили абзац следующий код:

Эта строка инициализирует переменную, которая хранит в себе число для вычисления его факториала. Далее нам нужно будет произвести вызов нашей функции fact с переменной number в качестве единственного аргумента и занести результат работы функции в новую переменную factor.

И затем преобразовать полученное значение обратно в строку и присвоить его второму текстовому полю.

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

Теперь можно скомпилировать и запустить готовую программу и проверить ее. Помните, что тип double в С++ может хранить число не превышающее !170.

Результат работы программы можно проверить в инженерном калькуляторе Windows.

C-sharp / Основы Windows Forms C# (изучаем основные формы)

За последние несколько лет Web-ориентированные приложения стали чрезвычайно популярными. Возможность размещать всю логику приложений на централизованном сервере выглядит очень привлекательной с точки зрения администратора. Развертывание программного обеспечения, базирующегося на клиенте, очень трудно, особенно, если оно основано на COM-объектах. Недостаток Web-ориентированных приложений состоит в том, что они не могут предоставить достаточно богатых возможностей пользователю.

Платформа .NET Framework позволяет разрабатывать интеллектуальные клиентские приложения с богатыми возможностями, при этом избегая проблем с развертыванием и “DLL-адом”, как это было раньше. Независимо от того, что будет выбрано — Windows Forms или Windows Presentation Foundation (см. главу 34) — разработка или развертывание клиентских приложений теперь не представляет особой сложности.

Windows Forms уже оказал влияние на разработки для Windows. Теперь, когда приложение находится на начальной стадии проектирования, принять решение о том, нужно ли строить Web-ориентированное приложение либо же полностью клиентское, стало немного труднее. Клиентские приложения Windows могут быть разработаны быстро и эффективно, при этом они предлагают пользователям гораздо более широкие возможности.

Windows Forms покажется вам знакомым, если у вас есть опыт разработки на Visual Basic. Вы создаете новые формы (также известные как окна или диалоги) в той же манере — перетаскивая и размещая элементы управления из панели инструментов на поверхность визуального дизайнера форм (Form Designer). Однако если ваш опыт в основном касается классического стиля языка C для Windows-программирования, где приходилось создавать конвейеры сообщений и отслеживать эти сообщения, или же если вы — программист, применяющий MFC, то в этом случае вы обнаружите, что и здесь при необходимости у вас есть возможность работать с низкоуровневыми деталями. Вы можете переопределить оконную процедуру (WndProc) и перехватывать сообщения, но в действительности вас удивит, что делать это придется нечасто.

В этой главе мы рассмотрим следующие аспекты Windows Forms:

иерархия классов Windows Forms;

элементы управления и компоненты, являющиеся частью пространства имен

меню и панели инструментов;

создание элементов управления;

создание пользовательских элементов управления.

Глава 31. Windows Forms 1055

Создание приложения Windows Forms

Первое, что необходимо сделать — создать приложение Windows Forms. Для примера создадим пустую форму и отобразим ее на экране. При разработке этого примера мы не будем использовать Visual Studio .NET. Наберем его в текстовом редакторе и соберем с помощью компилятора командной строки. Ниже показан код примера.

using System.Windows.Forms; namespace NotepadForms

public class MyForm : System.Windows.Forms.Form

[STAThread] static void Main()

Когда мы скомпилируем и запустим этот пример, то получим маленькую пустую форму без заголовка. Никаких реальных функций, но это — Windows Forms.

В приведенном коде заслуживают внимания две вещи. Первая — тот факт, что при создании класса MyForm используется наследование. Следующая строка объявляет

MyForm как наследника System.Windows.Forms.Form :

public class MyForm : System.Windows.Forms.Form

Класс Form — один из главных классов в пространстве имен System.Windows.Forms . Следующий фрагмент кода стоит рассмотреть более подробно:

[STAThread] static void Main()

Main — точка входа по умолчанию в любое клиентское приложение на C#. Как правило, в более крупных приложениях метод Main() не будет находиться в классе формы, а скорее в классе, отвечающем за процесс запуска. В данном случае вы должны установить имя такого запускающего класса в диалоговом окне свойств проекта. Обратите внимание на атрибут [STAThread] . Он устанавливает модель многопоточности COM в STA (однопоточный апартамент). Модель многопоточности STA требуется для взаимодействия с COM и устанавливается по умолчанию в каждом проекте Windows Forms.

Метод Application.Run() отвечает за запуск стандартного цикла сообщений приложения. Application.Run() имеет три перегрузки.

Первая из них не принимает параметров; вторая принимает в качестве параметра объект ApplicationContext . В нашем примере объект MyForm становится главной формой приложения. Это означает, что когда форма закрывается, то приложение завершается. Используя класс ApplicationContext , можно в большей степени контролировать завершение главного цикла сообщений и выход из приложения.

1056 Часть V. Презентации

Класс Application содержит в себе очень полезную функциональность. Он предоставляет группу статических методов и свойств для управления процессом запуска и останова приложения, а также обеспечивает доступ к сообщениям Windows, обрабатываемым приложением. В табл. 31.1 перечислены некоторые из этих наиболее полезных методов и свойств.

Таблица 31.1. Некоторые полезные методы и свойства класса Application

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

это БазовыйПуть\Название компании\Название продукта\Версия ,

где БазовыйПуть — C:\Documents and Settings\имя пользователя\

ApplicationData . Если путь не существует, он будет создан.

Путь и имя исполняемого файла, запускающего приложение.

, но с тем отличием, что поддерживается

True или false — в зависимости от того, существует ли цикл сообще-

ний в текущем потоке.

, с тем отличием, что имя файла не возвра-

Используется для предварительной обработки сообщений. Объект,

реализующий IMessageFilter , позволяет фильтровать сообщения в

цикле или организовать специальную обработку, выполняемую перед

тем, как сообщение попадет в цикл.

Аналогично оператору DoEvents языка Visual Basic. Позволяет обрабо-

тать сообщения в очереди.

Обеспечивает визуальный стиль Windows XP для различных визуальных

элементов приложения. Существуют две перегрузки, принимающие

информацию манифеста. Одна работает с потоком манифеста, вто-

рая — принимает полное имя и путь файла манифеста.

Exit и ExitThread

Exit завершает текущий работающий цикл сообщений и вызывает вы-

ход из приложения. ExitThread завершает цикл сообщений и закры-

вает все окна текущего потока.

А теперь как будет выглядеть это приложение, если его сгенерировать в Visual Studio 2008? Первое, что следует отметить — будет создано два файла. Причина в том, что Visual Studio 2008 использует возможность частичных ( partial ) классов и выделяет весь код, сгенерированный визуальным дизайнером, в отдельный файл. Если используется имя по умолчанию — Form1 , то эти два файла будет называться Form1.cs и Form1.Designer.cs . Если только у вас не включена опция Show All Files (Показать все файлы) в меню Project (Проект), то вы не увидите в проводнике Solution Explorer файла Form1.Designer.cs . Ниже показан код этих двух файлов, сгенерированных Visual Studio. Сначала — Form1.cs :

using System.Collections.Generic; using System.ComponentModel; using System.Data;

using System.Drawing; using System.Linq; using System.Text;

Глава 31. Windows Forms 1057

public partial class Form1 : Form

Здесь мы видим только операторы using и простой конструктор. А вот код Form1. Designer.cs :

partial class Form1

/// Required designer variable.

private System.ComponentModel.IContainer components = null;

/// Clean up any resources being used.

/// true if managed resources should be disposed; otherwise, false.

protected override void Dispose(bool disposing)

if (disposing && (components != null))

#region Windows Form Designer generated code

/// Required method for Designer support — do not modify

/// the contents of this method with the code editor.

private void InitializeComponent()

this.components = new System.ComponentModel.Container(); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; this.Text = «Form1»;

Файл, сгенерированный дизайнером форм, редко подвергается ручному редактированию. Единственным исключением может быть случай, когда необходима специальная обработка в методе Dispose() . Метод InitializeComponent мы обсудим позднее в этой главе.

Если взглянуть на этот код примера приложения в целом, то мы увидим, что он намного длиннее, чем простой пример командной строки. Здесь перед началом класса присутствует несколько операторов using , и большинство из них в данном примере не нужны. Однако их присутствие ничем не мешает. Класс Form1 наследуется от

1058 Часть V. Презентации

System.Windows.Forms.Form , как и в предыдущем, введенном в Notepad примере, но в этой точке начинаются расхождения. Во-первых, в файле Form1.Designer появляется строка:

private System.ComponentModel.IContainer components = null;

В данном примере эта строка кода ничего не делает. Но, добавляя компонент в форму, вы можете также добавить его в объект components , который представляет собой контейнер. Причина добавления этого контейнера — в необходимости правильной обработки уничтожения формы. Класс формы поддерживает интерфейс IDisposable , потому что он реализован в классе Component . Когда компонент добавляется в контейнер, то этот контейнер должен позаботиться о корректном уничтожении своего содержимого при закрытии формы. Это можно увидеть в методе Dispose нашего примера:

protected override void Dispose(bool disposing)

if (disposing && (components != null))

Здесь мы видим, что когда вызывается метод Dispose формы, то также вызывается метод Dispose объекта components , поскольку он содержит в себе другие компоненты, которые также должны быть корректно удалены.

Конструктор класса Form1 , находящийся в файле Form1.cs , выглядит так:

Обратите внимание на вызов InitializeComponent() .

Метод InitializeComponent() находится в файле Form1.Designer.cs и делает то, что следует из его наименования — инициализирует все элементы управления, которые могут быть добавлены к форме. Он также инициализирует свойства формы.

В нашем примере метод InitializeComponent() выглядит следующим образом:

private void InitializeComponent()

this.components = new System.ComponentModel.Container(); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; this.Text = «Form1»;

Как видите, здесь присутствует лишь базовый код инициализации. Этот метод связан с визуальным дизайнером Visual Studio. Когда в форму вносятся изменения в дизайнере, они отражаются на InitializeComponent() . Если вы вносите любые изменения в InitializeComponent() , то следующий раз после того, как что-то будет изменено в дизайнере, эти ручные изменения будут утеряны. InitializeComponent() повторно генерируется после каждого изменения дизайна формы. Если возникает необходимость добавить некоторый дополнительный код для формы или элементов управления и компонентов формы, это должно быть сделано после вызова InitializeComponent() . Этот метод также отвечает за создание экземпляров элементов управления, поэтому любой вызов, ссылающийся на них, выполненный до InitializeComponent() , завершится возбуждением исключения нулевой ссылки.

Глава 31. Windows Forms 1059

Чтобы добавить элемент управления или компонент в форму, нажмите комбинацию клавиш или выберите пункт меню View Toolbox (Вид Панель инструментов) в среде Visual Studio .NET. Щелкните правой кнопкой мыши на Form1.cs в проводнике Solution Explorer и в появившемся контекстном меню выберите пункт View Designer (Показать дизайнер). Выберите элемент управления Button и перетащите на поверхность формы в визуальном дизайнере. Можно также дважды щелкнуть на выбранном элементе управления, и он будет добавлен в форму. То же самое следует проделать с элементом TextBox .

Теперь, после добавления этих двух элементов управления на форму, метод InitializeComponent() расширяется и содержит такой код:

private void InitializeComponent()

this.button1 = new System.Windows.Forms.Button(); this.textBox1 = new System.Windows.Forms.TextBox(); this.SuspendLayout();

this.button1.Location = new System.Drawing.Point(77, 137); this.button1.Name = «button1»;

this.button1.Size = new System.Drawing.Size(75, 23); this.button1.TabIndex = 0;

this.button1.Text = «button1»; this.button1.UseVisualStyleBackColor = true;

this.textBox1.Location = new System.Drawing.Point(67, 75); this.textBox1.Name = «textBox1»;

this.textBox1.Size = new System.Drawing.Size(100, 20); this.textBox1.TabIndex = 1;

this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; this.ClientSize = new System.Drawing.Size(284, 264); this.Controls.Add(this.textBox1); this.Controls.Add(this.button1);

this.Name = «Form1»; this.Text = «Form1»; this.ResumeLayout(false); this.PerformLayout();

Если посмотреть на первые три строки кода этого метода, мы увидим в них создание экземпляров элементов управления Button и TextBox . Обратите внимание на имена, присвоенные им — textBox1 и button1 . По умолчанию дизайнер в качестве имен использует имя класса элемента управления, дополненное целым числом. Когда вы добавляете следующую кнопку, дизайнер называет ее button2 и т.д. Следующая строка — часть пары SuspendLayout / ResumeLayout . Метод SuspendLayout() временно приостанавливает события размещения, которые имеют место при первоначальной инициализации элемента управления. В конце метода вызывается ResumeLayout() , чтобы вернуть все в норму. В сложной форме с множеством элементов управления метод InitializeComponent() может стать достаточно большим.

Цукерберг рекомендует:  hover.css анимация для ваших кнопок

1060 Часть V. Презентации

Чтобы изменить значения свойств элемента управления, нужно либо нажать , либо выбрать пункт меню View Properties Window (Вид Окно свойств). Это окно позволяет модифицировать большинство свойств элемента управления или компонента. При внесении изменений в окне свойств метод InitializeComponent() автоматически переписывается с тем, чтобы отразить новые значения свойств. Например, изменив свойство Text на My Button в окне свойств, получим следующий код в

this.button1.Location = new System.Drawing.Point(77, 137); this.button1.Name = «button1»;

this.button1.Size = new System.Drawing.Size(75, 23); this.button1.TabIndex = 0;

this.button1.Text = «My Button»; this.button1.UseVisualStyleBackColor = true;

Даже если вы предпочитаете использовать какой-то редактор, отличный от Visual Studio .NET, то наверняка захотите включать функции вроде InitializeComponent() в свои проекты. Сохранение всего кода инициализации в одном месте обеспечит возможность его вызова из каждого конструктора.

Важность понимания иерархии становится очевидной в процессе проектирования и конструирования пользовательских элементов управления. Если такой элемент управления унаследован от конкретного библиотечного элемента управления, например, когда создается текстовое поле с некоторыми дополнительными методами и свойствами, то имеет смысл унаследовать его от обычного текстового поля и затем переопределить и добавить необходимые методы. Однако если приходится создавать элемент управления, который не соответствует ни одному из существующих в .NET Framework, то его придется унаследовать от одного из базовых классов: Control или ScrollableControl , если нужны возможности прокрутки, либо ContainerControl , если он должен служить контейнером для других элементов управления.

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

Пространство имен System.Windows.Forms включает один класс, который является базовым почти для всех элементов управления и форм — System.Windows.Forms. Control . Он реализует основную функциональность для создания экранов, которые видит пользователь. Класс Control унаследован от System.ComponentModel.Component . Класс Component обеспечивает классу Control инфраструктуру, необходимую для того, чтобы его можно было перетаскивать и помещать на поле дизайнера, а также, чтобы он мог включать в себя другие элементы управления. Класс Control предлагает огромный объем функциональности классам, наследуемым от него. Этот список слишком большой, чтобы приводить его здесь, поэтому в данном разделе мы рассмотрим только наиболее важные возможности, предоставляемые классом Control . Позднее в этой главе, когда мы будем рассматривать специфические элементы управления, основанные на Control , мы увидим эти методы и свойства в коде примеров. Следующие

Глава 31. Windows Forms 1061

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

Размер и местоположение

Размер и местоположение элементов управления определяются свойствами Height , Width , Top , Bottom , Left и Right , вместе с дополняющими их Size и Location . Отличие состоит в том, что Height , Width , Top , Bottom , Left и Right принимают одно целое значение. Size принимает значение структуры Size , а Location — значение структуры Point . Структуры Size и Point включают в себя координаты X, Y. Point обычно описывает местоположение, а Size — высоту и ширину объекта. Size и Point определены в пространстве имен System.Drawing . Обе структуры очень похожи в том, что представляют пары координат X, Y, но, кроме того — переопределенные операции, упрощающие сравнения и преобразования. Вы можете, например, складывать вместе две структуры Size . В случае структуры Point операция сложения переопределена таким образом, что можно прибавить к Point структуру Size и получить в результате Point . Это дает эффект прибавления расстояния к местоположению, чтобы получить новое местоположение, что очень удобно для динамического создания форм и элементов управления.

Свойство Bounds возвращает объект Rectangle , представляющий экранную область, занятую элементом управления. Эта область включает полосы прокрутки и заголовка. Rectangle также относится к пространству имен System.Drawing . Свойство ClientSize — структура Size , представляющая клиентскую область элемента управления за вычетом полос прокрутки и заголовка.

Методы PointToClient и PointToScreen — удобные методы преобразования, которые принимают Point и возвращают Point . Метод PointToClient принимает структуру Point , представляющую экранные координаты, и транслирует их в координаты текущего клиентского объекта. Это удобно для операций перетаскивания. Метод PointToScreen выполняет обратную операцию — принимает координаты в клиентском объекте и транслирует их в экранные координаты.

Методы RectangleToScreen и ScreenToRectangle выполняют те же операции, но со структурами Rectangle вместо Point .

Свойство Dock определяет, к какой грани родительского элемента управления должен пристыковываться данный элемент. Перечисление DockStyle задает возможные значения этого свойства. Они могут быть такими: Top , Bottom , Right , Left , Fill и None . Значение Fill устанавливает размер данного элемента управления равным размеру родительского.

Свойство Anchor (якорь) прикрепляет грань данного элемента управления к грани родительского элемента управления. Это отличается от стыковки (docking) тем, что не устанавливает грань дочернего элемента управления точно на грань родительского, а просто выдерживает постоянное расстояние между ними. Например, если якорь правой грани элемента управления установлен на правую грань родительского элемента, и если родитель изменяет размер, то правая грань данного элемента сохраняет постоянную дистанцию от правой грани родителя — т.е. он изменяет размер вместе с родителем. Свойство Anchor принимает значения из перечисления AnchorStyle , а именно: Top , Bottom , Left , Right и None . Устанавливая эти значения, можно заставить элемент управления изменять свой размер динамически вместе с родителем. Таким образом, кнопки и текстовые поля не будут усечены или скрыты при изменении размеров формы пользователем.

Свойства Dock и Anchor применяются в сочетании с компоновками элементов управления Flow и Table (о которых мы поговорим позднее в этой главе) и позволя-

1062 Часть V. Презентации

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

Свойства, имеющие отношение к внешнему виду элемента управления — это

BackColor и ForeColor , которые принимают объект System.Drawing.Color в качестве значения. Свойство BackGroundImage принимает объект графического образа как значение. Класс System.Drawing.Image — абстрактный класс, служащий в качестве базового для классов Bitmap и Metafile . Свойство BackgroundImageLayout использует перечисление ImageLayout для определения способа отображения графического образа в элементе управления. Допустимые значения таковы: Center , Tile , Stretch ,

Свойства Font и Text работают с надписями. Чтобы изменить Font , необходимо создать объект Font . При создании этого объекта указывается имя, стиль и размер шрифта.

Взаимодействие с пользователем

Взаимодействие с пользователем лучше всего описывается серией событий, которые генерирует элемент управления и на которые он реагирует. Некоторые из наиболее часто используемых событий: Click , DoubleClick , KeyDown , KeyPress ,

События, связанные с мышью — Click , DoubleClick , MouseDown , MouseUp ,

MouseEnter , MouseLeave и MouseHover — описывают взаимодействие мыши и экранного элемента управления. Если вы обрабатываете оба события — Click и DoubleClick — то всякий раз, когда перехватывается событие DoubleClick , также возбуждается и событие Click . Это может привести к нежелательным последствиям при неправильной обработке. К тому же и Click , и DoubleClick принимают в качестве аргумента EventArgs , в то время как события MouseDown и MouseUp принимают MouseEventArgs . Структура MouseEventArgs содержит несколько частей полезной информации — например, о кнопке, на которой был выполнен щелчок, количестве щелчков на кнопке, количестве щелчков колесика мыши (при условии его наличия), текущих координатах X и Y указателя мыши. Если нужен доступ к любой подобной информации, то вместо событий Click или DoubleClick потребуется обрабатывать события MouseDown и MouseUp .

События клавиатуры работают подобным образом. Объем необходимой информации определяет выбор обрабатываемых событий. Для простейших случаев событие KeyPress принимает KeyPressEventArgs . Эта структура включает KeyChar , представляющий символ нажатой клавиши. Свойство Handled используется для определения того, было ли событие обработано. Установив значение Handled в true , можно добиться того, что событие не будет передано операционной системе для совершения стандартной обработки. Если необходима дополнительная информация о нажатой клавише, то больше подойдут события KeyDown или KeyUp . Оба принимают структуру KeyEventArgs . Свойства KeyEventArgs включают признак одновременного состояния клавиш , или . Свойство KeyCode возвращает значение типа перечисления Keys , идентифицирующее нажатую клавишу. В отличие от свойства KeyPressEventArgs.KeyChar , свойство KeyCode сообщает о каждой клавише клавиатуры, а не только о буквенно-цифровых клавишах. Свойство KeyData возвращает значение типа Keys , а также устанавливает модификатор. Значение модификатора со-

Глава 31. Windows Forms 1063

провождает значение клавиши, объединяясь с ним двоичной логической операцией “ИЛИ”. Таким образом, можно получить информацию о том, была ли одновременно нажата клавиша или . Свойство KeyValue — целое значение из перечисления Keys . Свойство Modifiers содержит значение типа Keys , представляющее нажатые модифицирующие клавиши. Если было нажато более одной такой клавиши, их значения объединяются операцией “ИЛИ”. События клавиш поступают в следующем порядке:

События Val >, Val >, Enter , Leave , GotFocus и LostFocus имеют отношение к получению фокуса элементами управления (т.е. когда становятся активными) и утере его. Это случается, когда пользователь нажатием клавиши переходит к данному элементу управления либо выбирает его мышью. Может показаться, что события Enter , Leave , GotFocus и LostFocus очень похожи в том, что они делают. События GotFocus и LostFocus относятся к низкоуровневым, и связаны с событиями Windows WM_SETFOCUS и WM_KILLFOCUS . Обычно когда возможно, лучше использовать события Enter и Leave . События Val >и Val >возбуждаются при проверке данных в элементе управления. Эти события принимают аргумент CancelEventArgs . С его помощью можно отменить последующие события, установив свойство Cancel в true . Если вы разрабатываете собственный проверочный код, и проверка завершается неудачно, то в этом случае можно установить Cancel в true — тогда элемент управления не утратит фокус. Val >происходит во время проверки, а Val >— после нее. Порядок возникновения событий следующий:

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

Пространство имен System.Windows.Forms — одно из немногих, полагающихся на функциональность операционной системы Windows. Класс Control — хороший тому пример. Если выполнить дизассемблирование System.Windows.Forms.dll , то можно увидеть список ссылок на класс UnsafeNativeMethods . Среда .NET Framework использует этот класс как оболочку для всех стандартных вызовов Win32 API. Благодаря возможности взаимодействия с Win32 API, внешний вид и поведение стандартного приложения Windows можно обеспечить средствами пространства имен System. Windows.Forms .

Функциональность, которая поддерживает взаимодействие с Windows, включает свойства Handle и IsHandleCreated . Свойство Handle возвращает IntPtr , содержащий HWND (дескриптор окна) элемента управления. Дескриптор окна — это HWND , уни-

Особенности реализации MVP для Windows Forms

Постановка задачи

Придумаем простую задачу — реализовать 3 экрана:
1) экран авторизации;
2) главный экран;
3) модальный экран изменения имени пользователя.
Должно получиться что-то вроде этого:

Немного теории

MVP, как и его родитель, MVC (Model-View-Controller) придуман для удобства разделения бизнес-логики от способа ее отображения.

На просторах интернета можно встретить целое множество реализаций MVP. По способу доставки данных в представление их можно разделить на 3 категории:
— Passive View: View содержит минимальную логику отображения примитивных данных (строки, числа), остальным занимается Presenter;
— Presentation Model: во View могут передаваться не только примитивные данные, но и бизнес-объекты;
— Supervising Controller: View знает о наличии модели и сам забирает из нее данные.

Далее будет рассматриваться модификация Passive View. Опишем основные черты:
— интерфейс Представления (IView), который предоставляет некий контракт для отображения данных;
— Представление — конкретная реализация IView, которая умеет отображать саму себя в конкретном интерфейсе (будь то Windows Forms, WPF или даже консоль) и ничего не знает о том, кто ей управляет. В нашем случае это формы;
— Модель — предоставляет некоторую бизнес-логику (примеры: доступ к базе данных, репозитории, сервисы). Может быть представлена в виде класса или опять же, интерфейса и реализации;
— Представитель содержит ссылку на Представление через интерфейс (IView), управляет им, подписывается на его события, производит простую валидацию (проверку) введенных данных; также содержит ссылку на модель или на ее интерфейс, передавая в нее данные из View и запрашивая обновления.

Какие плюсы нам дает малая связанность классов (использование интерфейсов, событий)?
1. Позволяет относительно свободно менять логику любого компонента, не ломая остального.
2. Большие возможности при unit-тестировании. Поклонники TDD должны быть в восторге.
Начнем!

Как организовать проекты?

Условимся, что решение будет состоять из 4х проектов:
— DomainModel — содержит сервисы и всевозможные репозитории, одним словом — модель;
— Presentation — содержит логику приложения, не зависящую от визуального представления, т.е. все Представители, интерфейсы Представлений и остальные базовые классы;
— UI — Windows Forms приложение, содержит только лишь формы (реализацию интерфейсов Представлений) и логику запуска;
— Tests — unit-тесты.

Что писать в Main()?

Стандартная реализация запуска Windows Forms приложения выглядит так:

Но мы условились, что Представители будут управлять Представлениями, следовательно хотелось бы, чтобы код выглядел как-то так:

Попробуем реализовать первый экран:

Создать форму и реализовать в ней интерфейс ILoginView не составит труда, как и написать реализацию ILoginService. Следует только отметить одну особенность:

Это заклинание позволит нашему приложению запуститься, отобразить форму, а по закрытии формы корректно завершить приложение. Но к этому мы еще вернемся.

А тесты будут?

С момента написания представителя (LoginPresenter), появляется возможность сразу же его от-unit-тестировать, не реализуя ни формы, ни сервисы.
Для написания тестов я использовал библиотеки NUnit и NSubstitute (библиотека создания классов-заглушек по их интерфейсам, mock).

Тесты довольно глупые, как пока и само приложение. Но так или иначе, они успешно пройдены.

Кто и как запустит второй экран с параметром?

Как вы могли заметить, я не написал никакого кода при успешной авторизации. Как же мне запустить второй экран? Первое на ум приходит это:

Но мы условились, что представители ничего не знают о представлениях кроме их интерфейсов. Что же делать?
На помощь приходит паттерн Application Controller (реализован упрощенно), внутри которого содержится IoC-контейнер, знающий, как по интерфейсу получить объект реализации.
Контроллер передается каждому Представителю параметром конструктора (снова DI) и реализует примерно следующие методы:

После небольшого рефакторинга запуск приложения стал выглядеть так:

Пару слов о new ApplicationController(new LightInjectAdapder()) . В качестве IoC-контейнера я использовал библиотеку LightInject, но не напрямую, а через адаптер (паттерн Adapter), чтобы в случае, если понадобится сменить контейнер на другой, я смог написать другой адаптер и не менять логику контроллера. Все используемые методы есть в большинстве IoC-библиотек, сложностей возникнуть не должно.
Реализуем дополнительный интерфейс

Нельзя просто так взять и закрыть форму.

Один из подводных камней связан со строчкой View.Close() , после которой закрывалась первая форма, а вместе с ней и приложение. Дело в том, что Application.Run(Form) запускает стандартный цикл обработки сообщений Windows и рассматривает переданную форму как главную форму приложения. Это выражается в том, что приложение вешает ExitThread на событие Form.Closed , что и вызывает закрытие приложения после закрытия формы.
Обойти данную проблему можно несколькими способами, один из них — использовать другой вариант метода: Application.Run(ApplicationContext) , затем вовремя подменяя свойство ApplicationContext.MainForm . Передача контекста формам реализована с помощью Контроллера приложения, в котором регистрируется объект (instance) ApplicationContext и затем подставляется в конструктор формы (опять DI) во время запуска Представителя. Методы отображения первых двух экранов теперь выглядят так:

Модальное окно

Реализация модального окна не вызывает затруднений. По кнопке «Сменить имя» выполняется Controller.Run (user) . Единственное отличие этой формы от остальных — она не главная, поэтому форме для показа не требуется ApplicationContext:

Если необходимо открыть обычное окно, метод вообще не требуется определять, так как он уже реализован в классе Form.

Ну и накрутили. Как теперь ЭТО использовать?

Теперь, когда каркас готов, добавление новой формы сводится к следующим шагам:

  1. Пишем интерфейс Представления, интерфейс Модели (если требуется).
  2. Реализуем Представителя, попутно решив, будем ли мы в него передавать какие-то данные или модель.
  3. [Опционально] Пишем тесты для Представителя, убеждаемся, что все нормально.
  4. [Опционально] Реализуем Модель и тесты для нее.
  5. Накидываем формочки и реализуем интерфейс Представления.

Смена IoC-контейнера на ваш любимый происходит путем реализации простого интерфейса IContainer классом-адаптером.

Забрать демонстрационный проект можно c Github (для сборки необходимо выкачать Nuget-зависимости).

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

Бонус. Хочу еще круче, больше, сложнее!

На этом я остановлюсь, а пытливые умы могут идти дальше:
— улучшение Контроллера приложения (у меня написан немного упрощенный вариант);
— реализация агрегирования событий для обмена информацией между формами (шаблон Event Aggregator);
— дальнейшее изучение шаблона по ссылкам ниже

BestProg

Создание приложения типа Windows Forms Application
в Microsoft Visual Studio 2010

Содержание

1. Запустить Microsoft Visual Studio 2010

2. Команда создания нового проекта

В главном меню выбрать

как изображено на рисунке 1.

Рис. 1. Команда создания нового проекта

3. Выбор шаблона проекта

В открывшемся окне (рисунок 2) выбрать следующие элементы:

  • в поле « Installed Templates » выбрать Visual C# ;
  • в среднем окне шаблонов выбрать Windows Forms Application ;
  • в поле Name задается имя приложения (по умолчанию WindowsFormsApplication1 );
  • в поле Solution Name задаем имя файла решения (по умолчанию WindowsFormsApplication1 ).

Выбор шаблона нужно подтвердить нажатием на кнопке ОК .

Рис. 2. Окно выбора типа создаваемого приложения

4. Форма приложения

После выбора ОК в предыдущем окне MS Visual Studio сгенерирует программный код проекта и на экране появится окно с формой будущего приложения как изображено на рисунке 3.

Рисунок 3. Окно основной формы приложения в режиме проектирования

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

5. Запуск приложения на выполнение

Запуск приложения на выполнение осуществляется нажатием на клавише F5 или выбором соответствующего элемента меню (рис. 4).

Рис. 4. Запуск приложения через меню

Компилятор предварительно осуществляет проверку текста программы на наличие ошибок. Если ошибок нет, то загружает программу на исполнение. Программа после загрузки на исполнение имеет вид изображенный на рисунке 5. Как видно, это пустая форма, которая может реагировать на команды системного меню – свернуть, развернуть, закрыть ( Alt+F4 ). Программа реагирует также на комбинацию клавиш Alt + «пробел» с помощью которой вызывается системное меню.

Рис. 5. Выполнение программы, созданной по шаблону Windows Forms Application

Если в тексте программы есть синтаксические ошибки, то внизу экрана в окне Error List появится информация об ошибке (рис. 6).

Рис. 6. Окно панели « Error List » с информацией об ошибке

6. Рабочие файлы проекта

После создания приложения система MS Visual Studio создает несколько файлов, которые отображаются на панели Solution Explorer (рисунок 7).

Цукерберг рекомендует:  9 карьерных проблем разработчика.

Рисунок 7. Окно Solution Explorer со списком созданных файлов

Наиболее важные файлы из этого списка имеют следующее назначение:

Программирование на C, C# и Java

Уроки программирования, алгоритмы, статьи, исходники, примеры программ и полезные советы

ОСТОРОЖНО МОШЕННИКИ! В последнее время в социальных сетях участились случаи предложения помощи в написании программ от лиц, прикрывающихся сайтом vscode.ru. Мы никогда не пишем первыми и не размещаем никакие материалы в посторонних группах ВК. Для связи с нами используйте исключительно эти контакты: vscoderu@yandex.ru, https://vk.com/vscode

Калькулятор Windows Forms на языке C#

Некогда мы уже создавали подобный калькулятор, но он был довольно простенький и не имел общего TextBox’a для всех чисел.

В данной статье же мы создадим более усовершенствованный калькулятор Windows Forms. Итак, выглядеть у нас он будет вот так:

Здесь у нас 19 кнопок Button, 1 Textbox и ещё 1 пустой Label (на рисунке он выделен). Применение его будет описано ниже.

Итак, создаём такую или похожую форму. Мы увеличили ширину TextBox’a, используя MultiLine:

Также в Свойствах мы увеличили размер шрифта в TextBox’e и Label’e до 12 пт.

Теперь делаем так, чтобы при нажатии на цифровые кнопки, в TextBox’e появлялась соответствующая цифра.

Для этого дважды кликаем на кнопке “0” и в открывшемся коде пишем:

Проверяем, несколько раз нажав на кнопку “0” у нас в форме.

Работает. Делаем то же самое с остальными цифровыми кнопками:

Таким же образом кликаем дважды на кнопку “.” в форме. Она будет использоваться для создания десятичной дроби. Пишем следующий код:

Кнопки нажимаются, в TextBox’e отображаются нажатые цифры. Теперь надо научить программу производить с ними какие-либо операции. Как видно из формы, наш калькулятор сможет производить стандартные математические операции: сложение, вычитание, умножение и деление. Для начала мы создадим в самом начале программы несколько переменных, которые нам для этого понадобятся:

Первым двум переменным будут присваиваться значения, набранные пользователем в калькуляторе. В последствии с ними будут производиться нужные математические операции. Тип float – это тип с плавающей точкой, позволяющий работать с десятичными дробями, что нам, безусловно, нужно при наличии кнопки “.” .

Благодаря второй переменной мы будем давать программе указания, какую именно операцию производить с переменными, описанными выше. Здесь нам не нужна дробь, поэтому обойдёмся целочисленным типом int.

Последняя переменная znak нам понадобится для того, чтобы менять знаки у введённых чисел. Тип bool может иметь два значения – ture и false. Мы представим, что если znak имеет значение true в программе, то это означает, что у числа знак +, если false – число отрицательное и перед собой имеет знак . Изначально в калькуляторе вбиваются положительные числа, поэтому мы сразу присвоили переменной значение true.

Далее мы дважды нажимаем на кнопку “+”, обозначающую сложение, на форме и пишем следующий код:

В строке 3 мы присваиваем первой переменной a то, что будет написано в TextBox’e (а именно число, которое введёт пользователь перед тем, как нажать кнопку “+”).

Затем TextBox очищается, число, введённое пользователем, в нём пропадает (но остаётся в переменной a)

Переменной count присваивается число 1, которая потом укажет программе, что именно операцию сложения надо будет произвести с числами.

Затем в Label записывается число из переменной a (то самое, которое изначально ввёл пользователь) и знак плюса. Выглядеть в форме это будет так, как описано ниже.

Пользователь вводит какое-либо число:

Затем нажимает на кнопку “+” и после этого видит:

Кроме того, как бы не было странным с первого взгляда, мы присваиваем переменной znak значение true, хотя выше, в начале кода, мы и так присваивали это же значение. Подробнее данную переменную мы опишем ниже, но смысл в том, что мы присваиваем значение true, когда хотим сделать введённое число отрицательным, если оно положительно, а значение false, когда хотим сделать число положительным, если оно отрицательное. Изначально у нас вводятся положительные числа, сначала первое, потом второе. И если первое число мы сделаем отрицательным, то значение у znak перейдёт в false и тогда получится, что второе слагаемое как бы отрицательное (на практике, просто чтобы поставить перед ним минус, придётся нажать дважды на соответствующую кнопку, чтобы с false значение перешло в true, а затем обратно с true в false, и появился знак минуса).

Подобным образом заполняем код для кнопок “-“, “*” и “/”:

Разница лишь в значении переменной count и в том, какой знак добавляется в Label’e.

Далее нам понадобится создать функцию, которая будет применять нужные нам математические операции к числам. Назовём её calculate. Но перед этим мы кликнем дважды на кнопку “=” на форме и в коде к ней мы запишем:

То есть, при нажатии пользователем на кнопку “=”, как раз выполнится наша функция подсчёта calculate, и, заодно, очистится Label, так как результат мы в будущем коде выведем в TextBox.

Теперь-таки создаём нашу функцию calculate и пишем следующий код:

Здесь мы используем конструкцию switch-case.

Switch – это оператор управления. Он может включать в себя несколько case’ов. Case – метки, от значения которых зависит, какие операции будут происходить.

Строка switch(count) означает, что именно от значения count будет зависеть, какое действие будет происходить в коде switch’a.

Итак, если count=1 (в коде case 1:), то произойдёт следующее:

После того, как пользователь нажал “+”, он, естественно, должен ввести второе слагаемое, что он и делает по стандартному сценарию, а затем нажать кнопку “=” (и в ней, как мы помним, как раз выполнится наша функция).

Как только кнопка “=” будет нажата, программа сложит число из переменной a с тем вторым слагаемым, которое записал пользователь в TextBox, и запишет результат в переменную b (строка 6 кода функции). В строке 7 программа выведет в TextBox результат сложения – переменную b.

Оператор break (строка 8) завершает исполнение кода switch при выполнении кода метки case 1, так как больше нам в нём делать нечего.

Точно так же строится алгоритм при case 2, case 3 и case 4 с той разницей, что в них происходит не сложение, а вычитание, умножение и деление соответственно.

Оператор default срабатывает, если вдруг что-то пойдёт не по плану и count примет какое-либо иное значение, не описанное в switch. Тогда срабатывает лишь оператор break.

Львиная доля программы готова. Нам надо лишь написать код для трёх оставшихся нетронутыми до этого время кнопок.

Дважды жмём в форме на кнопку “С”. Она будет очищать все записи из TextBox’a и Label’a.

C# Windows Forms Application Tutorial with Example

So far we have seen how to work with C# to create console based applications. But in a real-life scenario team normally use Visual Studio and C# to create either Windows Forms or Web-based applications.

A windows form application is an application, which is designed to run on a computer. It will not run on web browser because then it becomes a web application.

This Tutorial will focus on how we can create Windows-based applications. We will also learn some basics on how to work with the various elements of Windows applications.

Windows Forms Basics

A Windows forms application is one that runs on the desktop computer. A Windows forms application will normally have a collection of controls such as labels, textboxes, list boxes, etc.

Below is an example of a simple Windows form application. It shows a simple Login screen, which is accessible by the user. The user will enter the required credentials and then will click the Login button to proceed.

So an example of the controls available in the above application

  1. This is a collection of label controls which are normally used to describe adjacent controls. So in our case, we have 2 textboxes, and the labels are used to tell the user that one textbox is for entering the user name and the other for the password.
  2. The 2 textboxes are used to hold the username and password which will be entered by the user.
  3. Finally, we have the button control. The button control will normally have some code attached to perform a certain set of actions. So for example in the above case, we could have the button perform an action of validating the user name and password which is entered by the user.

C# Hello World

Now let’s look at an example of how we can implement a simple ‘hello world’ application in Visual Studio. For this, we would need to implement the below-mentioned steps

Step 1) The first step involves the creation of a new project in Visual Studio. After launching Visual Studio, you need to choose the menu option New->Project.

Step 2) The next step is to choose the project type as a Windows Forms application. Here we also need to mention the name and location of our project.

  1. In the project dialog box, we can see various options for creating different types of projects in Visual Studio. Click the Windows option on the left-hand side.
  2. When we click the Windows options in the previous step, we will be able to see an option for Windows Forms Application. Click this option.
  3. We then give a name for the application which in our case is DemoApplication. We also need to provide a location to store our application.
  4. Finally, we click the ‘OK’ button to let Visual Studio create our project.

If the above steps are followed, you will get the below output in Visual Studio.

Output:-

You will see a Form Designer displayed in Visual Studio. It’s in this Form Designer that you will start building your Windows Forms application.

In the Solution Explorer, you will also be able to see the DemoApplication Solution. This solution will contain the below 2 project files

  1. A Form application called Forms1.cs. This file will contain all of the code for the Windows Form application.
  2. The Main program called Program.cs is default code file which is created when a new application is created in Visual Studio. This code will contain the startup code for the application as a whole.

On the left-hand side of Visual Studio, you will also see a ToolBox. The toolbox contains all the controls which can be added to a Windows Forms. Controls like a text box or a label are just some of the controls which can be added to a Windows Forms.

Below is a screenshot of how the Toolbox looks like.

Step 3) In this step, we will now add a label to the Form which will display «Hello World.» From the toolbox, you will need to choose the Label control and simply drag it onto the Form.

Once you drag the label to the form, you can see the label embedded on the form as shown below.

Step 4) The next step is to go to the properties of the control and Change the text to ‘Hello World’.

To go to the properties of a control, you need to right-click the control and choose the Properties menu option

  • The properties panel also shows up in Visual Studio. So for the label control, in the properties control, go to the Text section and enter «Hello World».
  • Each Control has a set of properties which describe the control.

If you follow all of the above steps and run your program in Visual Studio, you will get the following output

Output:-

In the output, you can see that the Windows Form is displayed. You can also see ‘Hello World’ is displayed on the form.

Adding Controls to a form

We had already seen how to add a control to a form when we added the label control in the earlier section to display «Hello World.»

Let’s look at the other controls available for Windows forms and see some of their common properties.

In our example, we will create one form which will have the following functionality.

  1. The ability for the user to enter name and address.
  2. An option to choose the city in which the user resides in
  3. The ability for the user to enter an option for the gender.
  4. An option to choose a course which the user wants to learn. There will make choices for both C# and ASP.Net

So let’s look at each control in detail and add them to build the form with the above-mentioned functionality.

Group Box

A group box is used for logical grouping controls into a section. Let’s take an example if you had a collection of controls for entering details such as name and address of a person. Ideally, these are details of a person, so you would want to have these details in a separate section on the Form. For this purpose, you can have a group box. Let’s see how we can implement this with an example shown below

Step 1) The first step is to drag the Groupbox control onto the Windows Form from the toolbox as shown below

Step 2) Once the groupbox has been added, go to the properties window by clicking on the groupbox control. In the properties window, go to the Text property and change it to «User Details».

Once you make the above changes, you will see the following output

Output:-

In the output, you can clearly see that the Groupbox was added to the form. You can also see that the text of the groupbox was changed to «User Details.»

Label Control

Next comes the Label Control. The label control is used to display a text or a message to the user on the form. The label control is normally used along with other controls. Common examples are wherein a label is added along with the textbox control.

The label indicates to the user on what is expected to fill up in the textbox. Let’s see how we can implement this with an example shown below. We will add 2 labels, one which will be called ‘name’ and the other called ‘address.’ They will be used in conjunction with the textbox controls which will be added in the later section.

Step 1) The first step is to drag the label control on to the Windows Form from the toolbox as shown below. Make sure you drag the label control 2 times so that you can have one for the ‘name’ and the other for the ‘address’.

Step 2) Once the label has been added, go to the properties window by clicking on the label control. In the properties window, go to the Text property of each label control.

Once you make the above changes, you will see the following output

Output:-

You can see the label controls added to the form.

Textbox

A textbox is used for allowing a user to enter some text on the forms application. Let’s see how we can implement this with an example shown below. We will add 2 textboxes to the form, one for the Name and the other for the address to be entered for the user

Step 1) The first step is to drag the textbox control onto the Windows Form from the toolbox as shown below

Step 2) Once the text boxes have been added, go to the properties window by clicking on the textbox control. In the properties window, go to the Name property and add a meaningful name to each textbox. For example, name the textbox for the user as txtUser and that for the address as txtAddress. A naming convention and standard should be made for controls because it becomes easier to add extra functionality to these controls, which we will see later on.

Once you make the above changes, you will see the following output

Output:-

In the output, you can clearly see that the Textboxes was added to the form.

List box

A Listbox is used to showcase a list of items on the Windows form. Let’s see how we can implement this with an example shown below. We will add a list box to the form to store some city locations.

Step 1) The first step is to drag the list box control onto the Windows Form from the toolbox as shown below

Step 2) Once the list box has been added, go to the properties window by clicking on the list box control.

  1. First, change the property of the Listbox box control, in our case, we have changed this to lstCity
  2. Click on the Items property. This will allow you to add different items which can show up in the list box. In our case, we have selected items «collection».
  3. In the String Collection Editor, which pops up, enter the city names. In our case, we have entered «Mumbai», «Bangalore» and «Hyderabad».
  4. Finally, click on the ‘OK’ button.

Once you make the above changes, you will see the following output

Output:-

In the output, you can see that the Listbox was added to the form. You can also see that the list box has been populated with the city values.

RadioButton

A Radiobutton is used to showcase a list of items out of which the user can choose one. Let’s see how we can implement this with an example shown below. We will add a radio button for a male/female option.

Step 1) The first step is to drag the ‘radiobutton’ control onto the Windows Form from the toolbox as shown below.

Step 2) Once the Radiobutton has been added, go to the properties window by clicking on the Radiobutton control.

  1. First, you need to change the text property of both Radio controls. Go the properties windows and change the text to a male of one radiobutton and the text of the other to female.
  2. Similarly, change the name property of both Radio controls. Go the properties windows and change the name to ‘rdMale’ of one radiobutton and to ‘rdfemale’ for the other one.
Цукерберг рекомендует:  Создание и получение вложенных объектов на jQuery

One you make the above changes, you will see the following output

Output:-

You will see the Radio buttons added to the Windows form.

Checkbox

A checkbox is used to provide a list of options in which the user can choose multiple choices. Let’s see how we can implement this with an example shown below. We will add 2 checkboxes to our Windows forms. These checkboxes will provide an option to the user on whether they want to learn C# or ASP.Net.

Step 1) The first step is to drag the checkbox control onto the Windows Form from the toolbox as shown below

Step 2) Once the checkbox has been added, go to the properties window by clicking on the Checkbox control.

In the properties window,

  1. First, you need to change the text property of both checkbox controls. Go the properties windows and change the text to C# and ASP.Net.
  2. Similarly, change the name property of both Radio controls. Go the properties windows and change the name to chkC of one checkbox and to chkASP for the other one.

Once you make the above changes, you will see the following output

Output:-

Button

A button is used to allow the user to click on a button which would then start the processing of the form. Let’s see how we can implement this with an example shown below. We will add a simple button called ‘Submit’ which will be used to submit all the information on the form.

Step 1) The first step is to drag the button control onto the Windows Form from the toolbox as shown below

Step 2) Once the Button has been added, go to the properties window by clicking on the Button control.

  1. First, you need to change the text property of the button control. Go the properties windows and change the text to ‘submit’.
  2. Similarly, change the name property of the control. Go the properties windows and change the name to ‘btnSubmit’.

Once you make the above changes, you will see the following output

Output:-

Congrats, you now have your first basic Windows Form in place. Let’s now go to the next topic to see how we can do Event handling for Controls.

C# Event Handling for Controls

When working with windows form, you can add events to controls. An event is something that happens when an action is performed. Probably the most common action is the clicking of a button on a form. In Windows Forms, you can add code which can be used to perform certain actions when a button is pressed on the form.

Normally when a button is pressed on a form, it means that some processing should take place.

Let’s take a look at one of the event and how it can be handled before we go to the button event scenario.

The below example will showcase an event for the Listbox control. So whenever an item is selected in the listbox control, a message box should pop up which shows the item selected. Let’s perform the following steps to achieve this.

Step 1) Double click on the Listbox in the form designer. By doing this, Visual Studio will automatically open up the code file for the form. And it will automatically add an event method to the code. This event method will be triggered, whenever any item in the listbox is selected.

Above is the snippet of code which is automatically added by Visual Studio, when you double-click the List box control on the form. Now let’s add the below section of code to this snippet of code, to add the required functionality to the listbox event.

  1. This is the event handler method which is automatically created by Visual Studio when you double-click the List box control. You don’t need to worry about the complexity of the method name or the parameters passed to the method.
  2. Here we are getting the SelectedItem through the lstCity.SelectedItem property. Remember that lstCity is the name of our Listbox control. We then use the GetItemText method to get the actual value of the selected item. We then assign this value to the text variable.
  3. Finally, we use the MessageBox method to display the text variable value to the user.

One you make the above changes, and run the program in Visual Studio you will see the following output

Output:-

From the output, you can see that when any item from the list box is selected, a message box will pops up. This will show the selected item from the listbox.

Now let’s look at the final control which is the button click Method. Again this follows the same philosophy. Just double click the button in the Forms Designer and it will automatically add the method for the button event handler. Then you just need to add the below code.

  1. This is the event handler method which is automatically created by Visual Studio when you double click the button control. You don’t need to worry on the complexity of the method name or the parameters passed to the method.
  2. Here we are getting values entered in the name and address textbox. The values can be taken from the text property of the textbox. We then assign the values to 2 variables, name, and address accordingly.
  3. Finally, we use the MessageBox method to display the name and address values to the user.

One you make the above changes, and run the program in Visual Studio you will see the following output

Output:-

  1. First, enter a value in the name and address field.
  2. Then click on the Submit button

Once you click the Submit button, a message box will pop, and it will correctly show you what you entered in the user details section.

Tree and PictureBox Control

There are 2 further controls we can look at, one is the ‘Tree Control’ and the other is the ‘Image control’. Let’s look at examples of how we can implement these controls

Tree Control

– The tree control is used to list down items in a tree like fashion. Probably the best example is when we see the Windows Explorer itself. The folder structure in Windows Explorer is like a tree-like structure.

Let’s see how we can implement this with an example shown below.

Step 1) The first step is to drag the Tree control onto the Windows Form from the toolbox as shown below

Step 2) The next step is to start adding nodes to the tree collection so that it can come up in the tree accordingly. First, let’s follow the below sub-steps to add a root node to the tree collection.

  1. Go to the properties toolbox for the tree view control. Click on the Node’s property. This will bring up the TreeNode Editor
  2. In the TreeNode Editor click on the Add Root button to add a root node to the tree collection.
  3. Next, change the text of the Root node and provide the text as Root and click ‘OK’ button. This will add Root node.

Step 3) The next step is to start adding the child nodes to the tree collection. Let’s follow the below sub-steps to add child root node to the tree collection.

  1. First, click on the Add child button. This will allow you to add child nodes to the Tree collection.
  2. For each child node, change the text property. Keep on repeating the previous step and this step and add 2 additional nodes. In the end, you will have 3 nodes as shown above, with the text as Label, Button, and Checkbox respectively.
  3. Click on the OK button

Once you have made the above changes, you will see the following output.

Output:-

You will be able to see the Tree view added to the form. When you run the Windows form application, you can expand the root node and see the child nodes in the list.

PictureBox Control

This control is used to add images to the Windows Forms. Let’s see how we can implement this with an example shown below.

Step 1) The first step is to drag the PictureBox control onto the Windows Form from the toolbox as shown below

Step 2) The next step is to actually attach an image to the picture box control. This can be done by following the below steps.

  1. First, click on the Image property for the PictureBox control. A new window will pops out.
  2. In this window, click on the Import button. This will be used to attach an image to the picturebox control.
  3. A dialog box will pop up in which you will be able to choose the image to attach the picturebox
  4. Click on the OK button

One you make the above changes, you will see the following output

Output:-

From the output, you can see that an image is displayed on the form.

Summary

  • A Windows forms application is one that runs on the desktop of a computer. Visual Studio along with C# can be used to create a Windows Forms application.
  • Controls can be added to the Windows forms via the Toolbox in Visual Studio. Controls such as labels, checkboxes, radio buttons, etc. can be added to the form via the toolbox.
  • One can also use advanced controls like the tree view control and the PictureBox control.
  • Event handlers are used to respond to events generated from controls. The most common one is the one added for the button clicked event.

Заметка о консольных и оконных (Windows Forms) приложениях

Для первого знакомства с языком C# (в рамках раздела «Основы языка C#») мы будем создавать консольные приложения, хотя большинство пользователей использует лишь оконные (Windows_Forms) приложения. При создании в IDE такого приложения (создайте сами, не бойтесь экспериментировать, только в этом случае будет успех!) формиру­ется файлы Program.cs и Form1.cs (вызовы библиотек типа using System и using System.Windows.Forms для краткости удалены):

Текст Program.cs:

В нем также объявляется класс Program (помечен как статический — static). Обратим пока внимание в нем на строчку Application.Run(new Form1()); , необходимую для запуска следующего файла.Form1.cs:

Заметим, что в пространстве имен объявляется класс Form1, наследуемый от класса Form (наследование указывается через двоеточие), а в нем уже не статическая функция Form1() — «конструктор класса», в теле которого вызывается функция, инициализирующая компоненты формы.

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

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

Управление Windows-приложением основано на понятии события (event), которые могут создаваться как пользователем, так и возникать в процессе выполнения приложения. То есть, принцип «один вход — один выход» здесь не применим. Но об этом — позже.

Ограничимся пока этими двумя видами проектов.

Обсудим тему комментариев в C# или перейдем к важнейшей теме «Типы данных в языке C#».

2.1 Основы Windows.Forms

В этой части главы («Работаем с оконными элементами») вы узнаете об основах и достоинствах Windows.Forms в .NET Framework. Так сказать, небольшое теоретическое введение.
Windows.Forms используется в Microsoft .NET для создания приложений, снабженных графическим интерфейсом. Основывается он на .NET Framework class library и имеет намного более совершенную и удобную в работе модель программирования, чем, напримеру, программные интерфейсы Win32 API или MFC.

Если вам уже приходилось работать с Win32 API или MFC, то вам, безусловно, понравится, на сколько удобна и быстра разработка с использованием Windows.Forms. А написание оконных приложений — намного качественнее, так как Windows.Forms устраняют многие ошибки Windows API. Код, который вы будите писать — намного проще и компактнее (никаким DDX переменных и километров макросов, как в MFC — это просто отлично!).

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

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

Так как Windows.Forms, по сути, должна включать сотни организованных классов, чтобы обеспечивать все необходимые возможности разработчику, .NET Framework разбита на ряд иерархических разделов, имеющих свои имена. System является корневым разделом и предназначен для описания фундаментальных типов данных (о которых мы говорили в предыдущей главе).

Чтобы максимально ощутить мощь Windows Forms, мы сразу перейдем к созданию простых, с точки зрения программирования и языка C#, но интересных и осмысленных приложений. В следующей части мы создадим небольшое оконное приложение, которое будет «убегать от пользователя» при попытке ответа на каверзный вопрос.

C# и Я

Работа с формами в Visual Studio C#.

В принципе, чтобы понять основы программирования в C# после изучения какого-либо объектно-ориентированного языка программирования много времени не требуется. Основные принципы ООП никто не отменял, а если понять их логику, то на изучения правил языка потребуется немного времени, а дальше – оттачивание навыков, углубленное изучение отдельных вопросов программирования и т.д., в общем, все как обычно. Проблемы начинаются, когда приходится избавляться от “вредных” привычек при переходе на C#, например от привычки работы с формами. Попробую пояснить это на простом примере, в котором рассмотрим работу с формами в Visual Studio Express C#.

Давайте создадим новый проект в Visual Studio. Для этого в главном меню студии выбираем “Файл – Создать проект” и в открывшемся окне выбираем “Приложение для Windows Forms”:

Зададим имя проекту, например, “TestApp” и нажмем кнопку “Ok”. Студия создаст нам пустое приложение, состоящее из одной формы и услужливо покажет нам её конструктор:

Теперь создадим ещё одну форму – её мы будем вызывать по какому-либо событию. Для добавления новой формы выбираем в меню Visual Studio: “Проект – Добавить форму Windows…” в открывшемся оке необходимо выбрать “Форма Windows Forms” и задать её имя:

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

Теперь разберемся как показать вторую форму пользователю. Те, кто немного знают Delphi могут сказать “Что может быть проще – добавил в uses модуль и вызывай”. Действительно проще некуда, но не совсем так просто как в Delphi. Объясню на примере.

Бросаем на первую форму кнопку Button. Затем переходим в окно “Свойства”, выбираем “События” и двойным кликом мышки, напротив события Click создаем новый обработчик:

Вначале, попробуем написать в обработчике следующий код:

Сразу же получим внятное сообщение об ошибке:

» Ошибка 1 Для нестатического поля, метода или свойства «System.Windows.Forms.Control.Show()» требуется ссылка на объект … «

Почему так? Дело в том, что, работая в Delphi мы могли не задумываться над тем почему, приведенный выше код мог работать без проблем – там Form2 – глобальная переменная класса TForm2. И эта переменная уже проинициализирована. Тут может быть несколько мнений, кто-то скажет «Это удобно, быстро», другой – «Глобальные переменные – зло». Разработчики С# относятся как раз к «другим» и я с ними согласен – где возможно следует избавляться от использования глобальных переменных. Второй момент – в C# Form2 – это название класса, а мы, следуя “вредной” привычке из Delphi могли предположить, что это переменная. Отсюда и ошибка. Добрались до сути. Осталось найти решение. А решение довольно простое – надо создать переменную и работать с ней:

Теперь все заработает нормально. Запускаем приложение, жмем кнопку и получаем вторую форму:

Как открыть вторую форму в модальном режиме, т.е., чтобы нельзя было переключиться на первую, пока вторая открыта. Для этого необходимо вызвать метод ShowDialog(). Можно так:

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

Как видите, после Delphi работа с формами в Visual Studio оказывается такой же простой, просто необходимо избавиться от вредной привычке – использования глобальных переменных.

Responses to “Работа с формами в Visual Studio C#.”

Случайно набрел на Ваш блог
Спасибо, все весьма доходчиво…
Не думал что после «Делфей» споткнусь на таких вещах =)
А не могли бы Вы описать каким образом открыв Form2 закрыть Form1 ?
В моем случае либо открывает и висят обе формы, либо совсем не открывает =)
В C S новичок

>>Не думал что после «Делфей» споткнусь на таких вещах =)
После делфей тут и не на таком спотыкаться приходится
>>А не могли бы Вы описать каким образом открыв Form2 закрыть Form1 ?
Если вторая форма открыта модально, то первая и не закроется. А если открывать вторую форму не модально, то первую потом можно закрыть, например так:
Form1 myform = new Form1();
myform.Close();
>>В C S новичок
Я тоже

=)
Не получается
private void button2_Click(object sender, EventArgs e)
<
Form2 frm = new Form2();
frm.Show();

Form1 fmr2 = new Form1();
fmr2.Close();
>
Первая форма висит на заднем плане, уже час ковыряюсь…

Воооот!
Вдруг пригодится

Form1.ActiveForm.Hide();
Form2 fmr = new Form2();
fmr.ShowDialog();
Close();

Спасибо Николай, час ковырялся с закрытием первой формы. Последнее решение помогло.

Понравилась статья? Поделиться с друзьями:
Все языки программирования для начинающих