C# — C# Win Form


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# — C# Win Form

Уроки 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; > >; >

Создание проекта в C# WinForms с использованием OpenGl

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

Для создания проекта нам понадобится Microsoft Visual Studio 2015. Для версий 2010 и 2012 разработаны специальные расширения, однако в данном уроке будет использована именно MVS 2015, для которой OpenGL подключим вручную. Объяснения будут как на русском, так и на английским языках. Ссылка на бесплатную редакцию:
https://www.microsoft.com/ru-ru/SoftMicrosoft/vs2015Community.aspx

1. Создание Приложения WindowsForms / Windows Forms Application

1. Нажимаем CTRL+SHIFT+N или выбираем Файл (File)->Создать (New)->Проект (Project).
2. Слева в пункте Установленные (Installed) разворачиваем пункт Шаблоны (Templates) и выбираем пункт Visual C#.
3. В списке выбираем Приложение Windows Forms (Windows Forms Application), задаем имя проекта и нажимаем OK.

2. Скачиваем библиотеки SharpGl

Готовые файлы можно найти в материалах к уроку — это архив . SharpGL.WinForms.zip.
Также материалы можно скачать и с официального сайта, для этого надо перейти на
http://sharpgl.codeplex.com/releases или зайти через главную страницу
http://sharpgl.codeplex.com в раздел Downloads. Нам нужна версия SharpGL 2.3. Под тегом RECOMMENDED DOWNLOAD переходим по ссылке SharpGL Assemblies (WPF & Winforms), будет загружен архив с папкой Core. В ней нам понадобится не все — только файлы из папки SharpGL.WinForms. В разделе OTHER AVAILABLE DOWNLOADS. можно скачать примеры по Samples, о которых будет идти речь в следующих уроках. Тут же и расширения для MVS 2010 и MVS 2012. Версия 2.3 рабочая и для 2012 Студии. Иначе можно скачать и с GitHub по ссылке https://github.com/dwmkerr/sharpgl/releases/tag/v2.3.0.1.

3. Подключение ссылок

Для подключения существует два пути. Первый: раздел из вкладки Сервис(Tools) в Диспетчер пакетов Nuget (NuGet Package Manager)->Консоль диспетчера пакетов (Package Manager Console)–>Выбрать в качестве Источника пакетов (Package Source) «nuget.org»(можно оставить все)->Ввести Install-Package SharpGL->Ввести Install-Package SharpGL.WinForms.

Второй способ: найти в Обозревателе решений (Solution Explorer) раздел Cссылки (References)->Добавить ссылку (Add reference):

Откроется Менеджер ссылок, необходим Обзор, далее находим у себя в файловой системе папку SharpGL.WinForms, где и лежат требуемые библиотеки SharpGl.dll, SharpGl.SceneGraph.dll, SharpGl.WinForms.dll:

Далее надо проверить в Обозревателе решений, в пункте Ссылки (References), появились ли ссылки SharpGl, SharpGl.SceneGraph, SharpGl.WinForms:

3. Добавление в панель элементов новых элементов

Первый шаг – простой, но не обязательный. Чтобы не добавить элементы в вкладку Общие, сделаем следующее. Свернем все группы элементов, последняя вкладка – Общие — обычно пустая, и если ее открыть, выскакивает надпись, что в данной группе элементов нет. Давайте щелкнем в свободной области панели правой кнопкой мыши и выберем «Добавить вкладку» из выпадающего списка. Создадим новую вкладку элементов, например, «MyOpenGL» – «группу» можно назвать как угодно:

Так как вкладка новая, увидим, что там элементов нет, щелкнем правой кнопкой по полоске с названием вкладки и далее из списка в «Выбрать элементы»:

В новом окне будет много вкладок, требуемая — «Компоненты .NET Framework». Зайдем в обзор и найдем в наших файлах SharpGL.WinForms.dll. Открываем, в списке можно глянуть, добавились ли элементы, жмем OK:

Во вкладке MyOpenGL должны появиться элементы Указатель (Стандартно), GLColorPicker, OpenGLControl, SceneControl, VertexControl. Новые элементы добавлены и теперь можно наконец-то приступать к разработке.

4. Создание экземпляра OpenGL-формы

Для этого располагаем OpenGLControl на нашу форму и заходим в свойства нового объекта. Для лучшей ориентации рекомендуется использование категорий. Находим в первой же категории SharpGL такие атрибуты:
Dock – позиция нового «контрола» на форме. Введем «Fill», чтобы наш «контрол» занял всю площадь. Также можно из выпадающего списка выбрать «Центр», интуитивно будет понятно, что имеется в виду.
FrameRate – количество кадров, которые будут отрисованы в секунду. По умолчанию там 20, изменим на 30. Однако этот параметр зависит от того, насколько «тяжелое» приложение и FPS может быть и ниже.
OpenGLVersion – версия технологии, которую мы реализовываем – это OpenGL2_1, и она уже задана по умолчанию. На момент создания урока последняя версия – OpenGL4_4.
RenderTrigger – один из контекстов рендеринга, можно выбрать TimerBased – тогда каждый кадр будет отрисовываться на основании времени, т.е. с определенной частотой секунд. Если мы зададим Manual – рендеринг каждого кадра надо будет реализовывать вручную.
Последний, и самый интересный – DrawFPS.
Его используют, если хотят проверить, как работает приложение. Можете сразу перейти к выполнению следующего пункта, но лучше прочитайте его до конца.
Зададим значение атрибута DrawFPS равным True. После запуска проекта получим ошибку типа System.NullReferenceException и следующие:
«Элемент управления Sharp.OpenGL вернул в конструкторе необработанное исключение и был отклонен. Исключение: Ссылка на объект не указывает на экземпляр объекта.»

Это происходит, если предварительно не задать в событиях нашего «контрола» свойство атрибута OpenGLDraw, просто щелкнув мышью по незаполненному полю атрибута. Перейдем из конструктора к коду, для этого можно нажать F7 или на поле формы щелкнуть правой кнопкой мыши и выбрать этот пункт из выпадающего списка. Увидим, что появилась следующая функция – обработчик событий, которая и отрисовывает «контрол»:

private void openGLControl1_OpenGLDraw ( object sender, RenderEventArgs args )


Она будет вызываться каждый раз при отрисовке нашего кадра – как в цикле.
Теперь можно запустить проект и он успешно выполнится. Вывод будет состоять из просто черного экрана. На форме в конструкторе будет отображаться текст ошибки:

Это будет оставаться, пока не реализуем пункт 5, и поэтому не стоит обращать внимание. Все же лучше этого не видеть и сделать все сразу правильно.

5. Очистка буфера и создание. Реализация отрисовки

После всех операций при запуске приложения внизу все равно будут отображаться непонятные цифры и символы:

Это происходит, потому что картинка обновляется очень много раз в секунду, но мы ее не очищаем и она заполняет буфер. Устраним это.
Для того, чтобы не использовать полные имена типов, сначала просто пропишем вверху пространства имен:

Там находятся все те функции, которые нам необходимы для работы в этом примере. В коде мы видим Инициализатор формы InitializeComponent(); – ее конструктор, который создан автоматически.
В обработчике событий пропишем следующие команды. Т.к. мы реализуем ООП, то сначала создаем экземпляр окна, в котором будем рисовать, чтобы было удобно обращаться к нашему «контролу».

OpenGL gl = this . openGLControl1 . OpenGL ;

После вызываем функцию очистки буфера и очищаем и цветовой буфер – буфер, в котором хранятся цвета объектов, и буфер глубины – уже с «глубинами» этих объектов с помощью операции «ИЛИ» (|). Дело в том, что без этой операции изображения и цифры просто будут накладываться друг на друга, и мы будем видеть то изображение, которое получили в пункте 4.

gl . Clear ( OpenGL . GL_COLOR_BUFFER_BIT | OpenGL . GL_DEPTH_BUFFER_BIT ) ;

Далее возвращаем центр координат в начальную точку и сбрасываем модельно-видовую матрицу, которая реализовывает передвижение, вращение и подобные операции над объектами.

После выполняем сдвиг пера, которым будем рисовать объекты, с помощью метода gl.Translate(X.Xf, Y.Yf, Z.Zf). Для этого устанавливаем Z.Zf = -5.0f, а остальное – по нулям. И, наконец, рисуем белый треугольник.

Задание цвета производится методом gl.Color(R.rf, G.gf, B.bf);, принимающего на вход три вещественных параметра в диапазоне [0.0; 1.0] — интенсивность красного, зеленого и синего цветов соответственно.

Ниже приведенный код при запуске выводит нам такую фигуру:

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

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

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

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

Цукерберг рекомендует:  33 сайта на спортивную тематику

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() может стать достаточно большим.


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 . Это дает эффект прибавления расстояния к местоположению, чтобы получить новое местоположение, что очень удобно для динамического создания форм и элементов управления.

Цукерберг рекомендует:  Вакансии The Flow

Свойство 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 , уни-

Программирование в .NET Framework

Приложения Windows Forms

Если вы захотите писать программы, похожие на привычные приложения Windows, то наверняка воспользуетесь классами из пространства имен System.Windows.Forms . Они позволяют задействовать кнопки, списки, текстовые поля, меню, окна сообщений и множество других «элементов управления». Элементы управления — это то, что вы помещаете в форму. Они нужны для вывода информации, например, текстовой (элемент управления Label ) или графической (элемент управления PictureBox ), либо для выполнения определенных действий, например, выбора значения или перехода к другой форме после нажатия кнопки. Все элементы управления помещаются на форму.


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

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

Компания Майкрософт предоставила в составе библиотеки классов .NET Framework огромное количество «элементов управления», которые можно помещать на формы. Освоив этот инструмент, вы сможете быстро создавать эффектные приложения.

Некоторые полезные классы из пространства имен System.Windows.Forms

Вот некоторые элементы управления, которые можно размещать на формах:

  • Label (Надпись).
  • Button (Кнопка).
  • ListBox (Список).
  • CheckBox (Флажок).
  • RadioButton (Переключатель).
  • MessageBox (Окно сообщений).
  • Menu (Меню).
  • TabControl (Управление вкладками).
  • Toolbar (Панель инструментов).
  • TreeView (Дерево).
  • DataGrid (Сетка данных).
  • PictureBox (Изображение).
  • RichTextBox (Текстовое поле с поддержкой формата RTF ).

Работа с примерами программ Windows Forms в Visual C# Express

Возможно, вы предпочтете не использовать уже заготовленные примеры проектов, а разрабатывать их «с нуля». В таком случае нужно учесть, что для каждого проекта C# Express сразу же создает два файла (с именами Form1.cs и Program.cs ) и наполняет их исходным кодом на языке C#, то есть вы изначально получаете простейшую, но полноценную программу. Предлагаемый нами способ работы с уже полученным проектом состоит в выполнении следующих действий:

  • Удалите файл Form1.cs.
  • Замените код в файле Program.cs на код примера, с которым вы работаете.

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

Пример программы 3.3

Рассмотрим пример простейшего приложения Windows Forms. Оно всего лишь создает новую форму и выводит определенный текст в заголовок окна формы.

Пример программы 3.4

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

Пример программы 3.5

Кнопку на форму мы поместили, но при нажатии на нее ничего не происходит. Это скучно.

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

Пример программы 3.6

Мы добились успеха: наша программа умеет выполнять основные действия. Теперь добавим на форму несколько новых элементов управления, аккуратно разместим их и немного поработаем с ними. Возьмем элементы управления 4-х типов: Button, ListBox, MessageBox и PictureBox.

BestProg


Пример программирования события клика на кнопке в C# . Разработка программы определения площади поверхности шара

На примере решения задачи определения площади поверхности шара, подробно описывается как программировать событие в среде Microsoft Visual Studio — C# .

Содержание

Условие задачи

Составить программу, которая по введенному радиусу R находит площадь поверхности шара. Программу реализовать как Windows Forms Application .

Площадь поверхности шара вычисляется по формуле:

где R – радиус шара, π константа равная 3.1415 .

В программе используются следующие элементы управления:

  • Label – метка для вывода сообщений;
  • Button – кнопка для выполнения расчета;
  • TextBox – поле ввода, предназначенное для ввода значения R .

Выполнение

1. Запустить MS Visual Studio. Создать проект по шаблону Windows Forms Application

Подробный пример создания нового приложения типа Windows Forms Application описан здесь . Сохранить проект под любым именем.

2. Размещение элементов управления на форме.

Из вкладки « Common Controls » выносим на форму четыре элемента управления (рис. 1):

  • два элемента управления типа Label (метка);
  • элемент управления типа Button (кнопка);
  • элемент управления типа TextBox (строка ввода).

Рис. 1. Элементы управления Label , Button , TextBox

Автоматически создаются четыре объекта с именами label1 , label2 , button1 и textBox1 . По этим именам можно будет иметь доступ к свойствам этих объектов.

Форма приложения будет иметь вид, как показано на рис. 2.

Рис. 2. Форма приложения после размещения label1 , label2 , button1 и textBox1

3. Настройка элементов управления типа Label .

Выделяем элемент управления (объект) label1 . В палитре Toolbox изменяем свойство Text , набираем « R = «.

Точно так же изменяется свойство Text для элемента управления label2 (рис. 3). Вводим текст « Площадь поверхности шара = «.

Рис. 3. Изменение свойства Text в label1

4. Элемент управления Button .

Аналогично к label1 выделяем элемент управления (объект) button1 . В свойстве Text вводим строку « Вычислить «.

5. Корректировка вида формы.

Изменяем название формы. Для этого выделяем форму. В свойстве Text формы вводим текст « Площадь поверхности шара «.

После корректировки форма будет иметь вид, как показано на рисунке 4.

Рис. 4. Вид формы после корректировки

6. Программирование события клика на кнопке « Вычислить «.
6.1. Вызов программного кода.

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

Цукерберг рекомендует:  Вакансии Beencart

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

Чтобы вызвать фрагмент кода обработки события на кнопке button1 нужно выполнить такие действия:

  • выделить кнопку button1 (рис. 5 — 1);
  • перейти к вкладке Events (события) в окне свойств (рис. 5 — 2);
  • сделать двойной щелчок «мышкой» напротив события « Click » (рис. 5 — 3).


Рис. 5. Последовательность вызова фрагмента кода обработки события Click

В итоге, откроется вкладка программного кода, который размещен в файле « Form1.cs » (рис. 6).

Рис. 6. Метод обработки события клика на кнопке button1

Листинг программного кода следующий:

6.2. Ввод программного кода обработки события.

В методе button1_Click вписываем код обработки события. Листинг метода следующий:

В коде описываются две переменные R и S типа double . Также описывается константа Pi .

Для преобразования из текстового типа string в тип double используется метод Parse . Таким образом заполняется значение переменной R.

Подобным образом можно преобразовывать данные и других типов. Например, для типа int можно написать:

Результат вычисления площади поверхности шара выводится в label2.Text . Преобразование в тип string осуществляется с помощью метода ToString() .

6.3. Корректировка программного кода.

В коде, описанном в пункте 6.2 нету защиты от некорректного ввода значения R . Поэтому метод button1_Click нужно переписать следующим образом:

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

В этом случае в свойстве ex.Message буде выведено сообщение:

7. Запуск программы на выполнение.

После этого можно запустить нашу программу на выполнение и протестировать ее работу при любых значениях R .

Программирование на 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#. WinForms, WPF, ASP NET

Об этом кворке

Напишу программу на C# в среде программирования Visual Studio 2020. Делаю проект за 1 — 3 дня, в зависимости от сложности задания.

Любые версии dotNET Framework. Исходный код, проект для Visual Studio оставляю Вам.

На C# программирую более 3 лет. Могу писать курсовые. Знаю:

  1. WPF
  2. Windows Forms
  3. Консольные приложения
  4. ASP NET
  5. Работа с БД (Access: accdb, mdb. MSSql, MySql)
  6. Парсинг веб страниц
  7. Взаимодействие программы с Microsoft Office (Word, Excel)
  8. Работа с API сайтов
  9. Работа с ботами Telegram

Что Вы получите, заказав мой kwork:

  1. Скомпилированная программа под Windows (архив со всеми нужными файлами)
  2. Проект для Visual Studio (архив со всеми исходники и прочим)

Дополнительные услуги:

  1. Комментарии. Делаю подробные комментарии, почти к каждой строке кода.

От Вас требуется четкое ТЗ. Описание функций программы.

Если Вам нужна доработка уже существующей программы, то скидывайте ее проект для Visual Studio.

Если нужно, укажите версию . NET Framework. Более низкие версии — большая совместимость с Windows старых версий (XP, Vista).

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# — C# Win Form

I have created an C# window form application from Micosoft Visual Studio 2010.

When I try to put this into ASP.NET invironmont, it is very frustrated working for me.

I have no idea how to do.

I think .csproj file would to for converting my code to ASP.NET or

at least import the window form application working on ASP.NET form.

Could anyone please answer this question who has very variety experience on similar sort of problem?

I can be also working on 2012, if the special feature on 2012 would help for this problem.

Answers

Go back to your Windows Forms application and try to rewrite it so that all of the code in the Form classes only contain code that directly updates the UI display in event handlers. Other code in the Form classes should react to user actions and fire events. It is critical that Form classes do not process any of the data. This requires using events to pass data between classes: one to display data; one to pass data; and separate ones to process and access data;

You may want to look at how the Model-View-Controller pattern works. I once posted a boiled down version of the MVC pattern in WinForms in the Windows Forms Forum.

There is a link in that thread to the sample. I gave a layman’s explanation of how the pattern works, and why it performs its’ work in such a seemingly round about fashion.

Once you have separated your business logic from your UI logic, the task of converting the application to use another type of UI should be much simpler.

Hope this helps.

Mark the best replies as answers. «Fooling computers since 1971.»

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