Введение в Windows Forms
Для создания графических интерфейсов с помощью платформы .NET применяются разные технологии — Window Forms, WPF, UWP. Однако наиболее простой и удобной платформой до сих пор остается Window Forms или сокращенно WinForms. Данное руководство ставит своей целью дать понимание принципов создания графических интерфейсов с помощью технологии WinForms и работы основных элементов управления.
Создадим первое приложение на C# и Windows Forms. Что нам для этого потребуется? Прежде всего необходим текстовый редактор для написания кода программы. Можно взять любой понравившийся текстовый редактор, например, Visual Studio Code
Также для компиляции и запуска программы нам потребуется .NET SDK. Для его установки перейдем на официальный сайт по ссылке .NET SDK
После установки .NET SDK для первого проекта определим какую-нибудь папку. Например, в моем случае это будет папка C:\dotnet\winforms\helloapp . Откроем терминал/командную строку и перейдем к созданной папке проекта с помощью команды cd
В данном случае мы для создания и запуска проекта мы будем использовать встроенную инфраструктуру .NET CLI, которая устанавливается вместе с .NET SDK.
Для создания проекта в .NET CLI применяется команда dotnet new , после которой указывается тип проWindows Formsекта. Для создания проекта Windows Forms применяется шаблон — winforms . Поэтому введем в терминале команду
После выполнения этой команды у нас будет создан следующий проект:
Структура проекта Windows Forms
Рассмотрим базовую структуру простейшего стандартного проекта Windows Forms:
helloapp.csproj : стандартный файл проекта C#, который соответствует назанию проекта (по умолчанию названию каталога) и описывает все его настройки.
helloapp.csproj.user : дополнительный файл проекта C#, который хранит специфичные для текущего пользователя настройки.
Form1.cs : содержит класс формы, которая по умолчанию запускается при старте приложения
Form1.Designer.cs : он содержит определение компонентов формы, добавленных на форму в графическом дизайнере (графический дизайнер Windows Forms на данный момент официально доступен только в Visual Studio)
Program.cs : определяет класс Program, который запускается при старте приложения и запускает форму Form1
Например, посмотрим на содержимое файла helloapp.csproj
Для компиляции приложения Windows Forms указаны следующие настройки:
OutputType : определяет выходной тип проекта. Должен иметь значение WinExe — то есть выполняемое приложение с расширением exe под Windows
TargetFramework : определяет применяемую для компиляции версию фреймворка .NET. Поскольку при создании проекта была выбрана версия .NET 7, а сам проект зависит от компонентов Windows, то здесь должно быть значение net7.0-windows
Nullable : подключает в проект функционалность ссылочных nullable-типов
UseWindowsForms : указывает, будет ли проект использовать Windows Forms (для этого устанавливается значение true )
ImplicitUsings : подключает в проект функциональность неявно подключаемых глобальных пространств имен
Запуск проекта
Проект по умолчанию не представляет какой-то грандиозной функциональности, тем не менее этот проект мы уже можем запустить. Итак, запустим проект. Для этого выполним команду
При запуске запускается графическая форма, код которой определяет класс Form1:
Запуск приложения
Файл Program.cs определяет точку входа в приложение:
Метод Main снабжен атрибутом [STAThread] . Этот атрибут, грубого говоря, необходим для корректной работы компонентов Windows. В самом методе сначала вызывается метод
который устанавливает некоторую базовую конфигурацию приложения
Затем вызывается метод
в который передается объект отображаемой по умолчанию на экране формы.
То есть, когда мы запустим приложение, сработает метод Main , в котором будет вызван метод Application.Run(new Form1()) , благодаря чему мы увидим форму Form1 на экране.
Определение формы
Теперь посмотрим на определение формы и немного изменим его. Для этого откроем файл Form1.cs в текстовом редакторе. По умолчанию он выглядит следующим образом:
Класс формы — Form1 представляет графическую форму — фактически то окно, которое мы увидим на экране при запуске проекта.
Этот класс определяется как частичный (с модификатором partial ) и наследуется от встроенного класса Form , который содержит базовую функциональность форм.
В самом классе Form1 определен по умолчанию только конструктор, где вызывается метод InitializeComponent() , который выполняет инициализацию компонентов формы из файла дизайнера Form1.Designer.cs . По сути именно код этого файла передается выше через вызов InitializeComponent()
Теперь изменим его код следующим образом:
В данном случае на форму добавляется кнопка, и у нее настраиваются различные свойства, как текст, положение на форме, размер, а также обработчик нажатия. Заново запустим проект, и нам отобразится та же форма, которая теперь будет содержать кнопку. И по нажатию на кнопку появится маленькое окно с сообщением.
Разработка графического кроссплатформенного приложения на C#. LXUI
Всем привет! Меня зовут Леонид, я являюсь разработчиком программного обеспечения (ПО) на языках программирования С++, C# и Java. Основной род деятельности за последние 10 лет создание систем сбора данных, мониторинга и автоматизации в промышленной сфере, так же участвовал в разработке ПО для финансового сектора. В одном из проектов была поставлена задача разработать пользовательское ПО, которое должно работать в операционных системах Windows, Linux и Android, используя среду .NET и оно не должно было быть WEB приложением (так как боялись за низкую производительность, да и в целом подобные SCADA системы в основном развивались в десктопном исполнении), скорее всего это была архитектурная ошибка, но благодаря ей появилась основа для нового компактного фреймворка. Забегая вперед, скажу это была достаточно амбициозная идея, так как на дворе был 2017 год и необходимых кроссплатформенных систем с пользовательским интерфейсом на .NET не существовало.
Для Windows систем был устаревший Windows Forms и все больше набирал обороты WPF, под Android был только Xamarin, который казался жутко тормозным и глючным в плане разработки, а под Linux все было совсем плохо. Имея достаточно неплохой опыт в создании пользовательских элементов управления еще со времен C++ Builder, было решено сделать свой UI с блэкджеком и шарпом.
Первые пробы
Для создания любой пользовательской графической системы необходимо:
Выводить на экран (отрисовывать) различные примитивы (точки, линии, многоугольники и т.д.), изображения (растровая графика, векторная графика), текст.
Получать информацию с устройств ввода (клавиатура, мышь, тач-панель и т.п.)
В некоторых случаях может понадобиться дополнительно иметь возможность проигрывать звук, взаимодействовать с функциями операционной системой, например, получать/задавать буфер обмена, выводить уведомления и т.д.
Делать это все максимально быстро, иначе наш интерфейс будет медленным и неудобным в использовании:)
В качестве основы будущего фреймворка LXUI был взят кроссплатформенный игровой движок MonoGame, который в свою очередь продолжал традиции XNA от Microsoft. MonoGame уже включает практически все необходимое из списка, остается только сделать надстройку над ним. На самом деле это большая и сложная работа, построить быстрый и надежный интерфейс, особенно если необходимо обрабатывать тысячи элементов управления. Даже просто вывести текст на экране с возможностью его выравнивания, переноса, обрезки, вывода большого объема текста (10ки мегабайт), потокобезопасным и чтоб при этом интерфейс был отзывчивым, требуется немало усилий и различных трюков оптимизации.
Так появился первый рабочий проект “Omega” и дальнейшие его ответвление “Trassa”.
СПО “Трасса” 
СПО “Трасса” 
СПО “Трасса”
Использование MonoGame в проекте создавало свои сложности, не везде удавалось достичь высокой производительности и совместимости, иногда приходилось городить грабли под разные платформы и функциональных возможностей уже не хватало, хотелось иметь полноценные векторные шрифты, более простое развертывание в различных системах и многое другое.
SDL2 и Material Design
В какой-то момент времени я наткнулся на замечательную компактную библиотеку SDL2, это свободно-распространяемый кроссплатформенный игровой движок с огромными встроенными возможностями и очень высокой производительностью. После внимательного изучения ее функционала было принято решение написать новую версию LXUI с 0, используя данный движок как основу. На самом деле рассматривались и другие движки, в том числе и Unity, но все они не подходили в силу большого размера исполняемых файлов и поддержкой платформ, например SDL2 по прежнему поддерживает Windows XP, кто-то скажет, что это бред и данная операционная система давно устарела, но к сожалению это не так, в государственных и финансовых структурах до сих пор иногда встречается. Задача была сделать библиотеку максимально компактной, а не монстра в сотни мегабайт для пустого проекта, и так же с максимальной поддержкой даже уже устаревших операционных систем. Поэтому LXUI написана на фреймворке .NET 4.0 (также есть адаптация под .NET Standard 2.0) и позволяет использовать устаревшие среды разработки и маломощные компьютеры, а главное не скачивать самую последнюю среду разработки и самый последний фреймворк, чтобы написать простой калькулятор :).
Накопив достаточный опыт в предыдущей версии, были понятны основные направления развития и удобства/неудобства пользования библиотекой. Одним из таких недостатков стали визуальные аспекты, стили, поведения, анимации. Тут очень многое было заимствовано из Material Design от компании Google. Например, даже основные цветовые схемы состоят из Primary, Secondary, Surface, Background и других цветов, появилась поддержка векторных шрифтов, некоторые анимации нажатия кнопок, переключателей.
Прошли короновирусные времена (а может и не прошли вовсе), библиотека успешно использовалась в нескольких внутренних проектах и возникла мысль, а почему бы не попробовать выложить ее в свет! И тут начался непривычный кошмар :). Регистрации на различных ресурсах, публикации и самое главное документация! С ней сейчас еще предстоит много работы, поэтому сами исходные коды еще не выложены на GitHub. Но уже можно загрузить для испытаний NuGet сборки для Desktop версии (https://www.nuget.org/packages/LXUI.Desktop) и Android (https://www.nuget.org/packages/LXUI.Android). Для простенькой демонстрации был сделан проект Weather (https://github.com/lxuinet/Meteo.Test), который скомпилирован под Android и Desktop (в том числе был опробован в виртуальной машине с операционной системой Raspberry Pi). Дополнительная информация доступна на официальном сайте (http://lxui.net/), сайт к сожалению пока тоже пустой, но надеюсь со временем все наладится!
Weather, Raspberry Pi
Hello World!
Итак приступим, попробуем создать простое приложение! Если вы планируете использовать один и тот же код и ресурсы в разных системах (Android/Desktop), то необходимо создать общую библиотеку классов или общий проект. Для создании Desktop версии нам необходимо создать консольный проект или проект Windows Forms, в качестве среды разработки будем использовать Microsoft Visual Studio 2019 (никто не запрещает использовать любую другую среду). Создаем консольный проект .NET Framework версии 4.0 или выше (можно использовать .NET Core проекты)
Создание проекта
В свойствах проекта изменяем «Тип выходных данных», это нужно чтобы не отображалось окно консоли:
Настройка проекта
Подключаем NuGet пакет. В поиске вводим LXUI и выбираем LXUI.Desktop:
Добавление NuGet пакета
Теперь необходимо создать стартовую форму, это обычный класс, наследуемый от LX.Control и зададим рамку элемента через свойство BorderSize:
В главной функции приложения Main, необходимо запустить LXUI и создать экземпляр нашей формы. Принцип очень схож с классическим Windows Forms:
Теперь необходимо добавить нашу форму на экран, для этого у Control есть метод AddToRoot(), вызовем данный метод в конструкторе формы:
Первый запуск
Мы видим маленький белый прямоугольник, это дефолтные размеры и расположение нашей формы. Для выравнивания формы обратимся к свойству Alignment, здесь очень много разных возможностей выравнивания, например можно прикрепить форму к любому краю родительского элемента или разместить ее по центру. Выполним заполнение по всему родительскому элементу:
Концепция LXUI — любой элемент может содержать в себе другие элементы и как угодно их выравнивать, например, стать панелью, списком или галерей. Теперь добавим 100 текстовых меток в центре формы и запустим приложение:
Вывод текста на экране
Все 100 надписей расположились по центру, давайте превратим нашу форму в список! Для этого используем свойство Layout:
Вертикальный список
Можно создавать любые пользовательские Layout и на лету менять поведение элементов внутри формы без изменения разметки формы. Обратите внимание, автоматически создалась полоса прокрутки. В LXUI нет необходимости создать различные ScrollViewer и тому подобные элементы, фреймворк сам определяет их необходимость. Видимость, размеры и цвета элементов прокрутки можно настроить в соответствующих свойствах. На текущий момент нет поддержки колеса мыши, но зато есть так называемая прокрутка “пальцем”, привычная всем пользователям тачскринов (к данному подходу очень быстро привыкаешь и в десктопных приложениях).
Теперь добавим иконку справа к нашим надписям. Добавим файл изображения в проект и укажем действие при сборке “Внедренный ресурс”. В текущей версии поддерживаются форматы изображений: Bmp, Gif (без анимации), Jpg, Png, Psd, Tga, монохромные векторные изображения, загруженные из шрифтов.
Добавление ресурсов в проект
Загрузим изображение и добавим его в наши надписи:
Можно упростить весь код:
Текст с картинкой
Можно немного поиграться со свойствами Control. Зададим фоновой цвет надписи, на основе цвета родительского элемента с автоматической градацией, добавим скругления краев и изменим масштаб окна:
Изменение масштаба окна
Из-за более светлого фона надписи, цвет текста стал черным, это также достигается благодаря указанному по умолчанию цвету текста равному Color.Content. Авто цвета удобно использовать, если вы создаете разные темы, в том числе светлые/темные:
Светлая тема 
Темная тема
Аналоги и тестирование
Существует огромное количество кроссплатформенных GUI, но только не в .NET, реально мало кто назовет даже 1-2 фреймворка. Есть Xamarin.Forms, у которого нет поддержки Linux, тот же .NET MAUI скоро выйдет, опять же без поддержки Linux систем и если честно, подход использовать максимально последний .NET для запуска отпугивает, плюс выходные размеры пустого проекта становятся все больше и больше. Есть AvaloniaUI, которая очень сильно выросла за последние годы и видно была проделана просто гигантская работа в сторону повышения качества продукта. Но это все достаточно крупные игроки, до которых очень далеко.
Пустой проект на .NET MAUI под Windows 10
Поскольку моей задачей является создать очень компактный и очень производительный фреймворк я просто обязан провести некоторые сравнительные тесты. Для этого будем сравнивать LXUI с фреймворками: WPF (Windows Presentation Foundation, аналог Windows Forms от Microsoft) и AvaloniaUI (кроссплатформенный фреймворк), к сожалению MAUI даже не удалось запустить, поэтому пока их исключаем из тестов. Для меня важными критериями в этих тестах являются:
Общая производительность и плавность интерфейса
Конфигурация тестовой среды:
Процессор: Intel Xeon E5-2696 v3
Оперативная память: 64 Гб
Видеокарта: ASUS GeForce GTX 1660 Ti 6 Гб
Операционная система: Window 10 Pro 21H2
Среда разработки: Visual Studio Community 2019 Версия 16.11.15
Код тестовых примеров я буду приводить на LXUI, код других тестовых проектов можно загрузить с GitHub (https://github.com/lxuinet/LX.Test). Сразу оговорюсь, возможно, я не правильно (не оптимально) составлял тестовые примеры, надеюсь, в комментариях мне предложат другие варианты, более быстрые. Также не ставится целью кого-то обидеть или принизить, любая здравая критика только приветствуется. Поехали!
Test 1. Проверяем скорость загрузки большого числа элементов
Задача. Создать форму с вертикальным списком и прокруткой, в который добавить N-ое количество кнопок с текстом и изображением, с автоматическим размером по содержимому.
Тест 1
WPF (N = 10 000 элементов)
Количество сборок мусора:
Прокрутка списка: Очень быстро
Изменение размера окна:
В целом интерфейс отзывчив, визуально не видно задержек в отрисовке на события мыши, только изменение размеров окна подкачали.
Диагностика Test1.WPF
AvaloniaUI (N = 10 000 элементов)
Количество сборок мусора:
Прокрутка списка: Практически недоступна
Изменение размера окна:
Заметны значительные задержки в прорисовке событий мыши, прокрутку сделать практически невозможно, как и изменение размера окна, так же многократно были заметны подвисания процесса при выходе.
Диагностика Test1.AvaloniaUI
LXUI (N = 100 000 элементов) в 10 раз больше элементов
Количество сборок мусора:
Прокрутка списка: Очень быстро
Изменение размера окна:
Нет никаких задержек при прорисовке, минимальные задержки при изменении размера окна.
Диагностика Test1.LXUI
Test 2. Создаем галерею иконок
Задача. Загрузить из папки 226 изображения, в формате PNG. Создать форму с галереей изображений и добавить в нее 226 х N элементов.
Тест 2
WPF (N = 100, 22 600 элементов)
Количество сборок мусора:
Прокрутка списка: Очень быстро
Изменение размера окна:
Нет никаких задержек при прорисовке, минимальные задержки при изменении размера окна.
Диагностика Test2.WPF
AvaloniaUI (N = 100, 22 600 элементов)
Количество сборок мусора:
Прокрутка списка: Практически недоступна
Изменение размера окна:
Прокрутку сделать практически невозможно, как и изменение размера окна.
Диагностика Test2.AvaloniaUI
LXUI (N = 1000, 226 000 элементов) в 10 раз больше элементов
Количество сборок мусора: 0
Прокрутка списка: Очень быстро
Изменение размера окна:
Нет никаких задержек при прорисовке, минимальные задержки при изменении размера окна.
Диагностика Test2.LXUI
Test 3. Работа с текстом
Задача. Создать форму с текстовым редактором, загрузить большой текст
17 х N символов и выровнять по правому краю.
Тест 3
WPF (N = 10 000, 168 890 символов)
Количество сборок мусора: 0
Прокрутка текста: Очень быстро
Изменение размера окна:
Задержка при вводе:
Большая задержка при вводе текста и изменении размера окна.
Диагностика Test3.WPF
AvaloniaUI (N = 10 000, 168 890 символов)
Количество сборок мусора: > 100
Прокрутка списка: Очень быстро
Изменение размера окна:
Задержка при вводе:
Большая задержка при вводе текста и изменении размера окна.
Диагностика Test3.AvaloniaUI
LXUI (N = 100 000, 1 788 890 символов) в 10 раз больше символов
Количество сборок мусора: 3
Прокрутка списка: Очень быстро
Изменение размера окна:
Задержка при вводе:
Нет никаких задержек при прорисовке, изменений размера окна и вводе символов, максимальная плавность.
Диагностика Test3.LXUI
Итоги тестирования
По результатам проведенных тестов, LXUI имеет очень высокую оптимизацию производительности, более чем в 10 раз превосходящую среди сравниваемых фреймворков. Данный запас производительности дает гарантию быстрого и плавного исполнения приложений в мобильных устройствах и более слабых настольных системах. WPF достаточно неплохо справилась с данными тестами, в основном были задержки при изменении размеров окна, где происходит основной перерасчет положения элементов управления. У AvaloniaUI есть заметные проблемы с производительностью, что не может сказаться на выполнении тяжелых пользовательских интерфейсов, особенно на мобильных устройствах. Конечно, это были синтетические тесты и нужно учитывать множество факторов, например, сейчас LXUI проигрывает в скорости загрузки больших изображений (4к и выше), также требуется много и других доработок.
Вывод
На мой взгляд, LXUI мог бы стать вполне конкурентным фреймворком для построения пользовательских кроссплатформенных систем. Основным преимуществом я бы назвал:
Маленький размер выходных файлов, всего одна библиотека размером в 3 МБ.
Высокая оптимизация и производительность.
Простой вход для новичков, не нужно изучать язык разметки XAML и т.п. и в тоже время структура библиотеки схожа с классическим Windows Forms
Поддержка устаревших версий .NET, сред разработки и операционных систем, например в системе Linux достаточно установить пакеты mono-complete, libsdl2 и libsdl2-ttf, которые входят в официальные репозитории даже на таких система как Raspberry Pi.
В перспективе необходимо расширять библиотеку пользовательских элементов управления, скинов, сделать её максимально потокобезопасной, добавить поддержку векторной графики, проигрывания звука и видео, расширить список платформ, в частности планируется добавить поддержку iOS и macOS, дать разработчикам больше доступа к графической подсистеме, добавить 3D, шейдеры, а главное привести в порядок документацию, добавить больше примеров и сделать полноценный конструктор форм и пользовательских элементов управления. Одно из направлений можно развить в сторону игр, так как большинство казуальных игр строятся на GUI со стандартными элементами управления.
Текущая статья очень кратко описывает возможности LXUI, не затронуты многие темы, например: скины, таймеры, горячие клавиши, анимации.
P.S.
Это моя первая статья такого рода, приношу извинения за возможные многочисленные ошибки, жду от вас отзывов и рекомендаций, до скорой встречи!
Языки_Программирования_Лабораторные / PL_Lab3_Win
Цель работы Знакомство с методами визуального программирования. Приобретение навыков разработки приложений с графическим интерфейсом в среде Visual Studio .Net на языке C#.
Ведение в визуальное программирование
Визуальное программирование — способ создания программы для ЭВМ с помощью манипулирования графическими видимыми (визуальными) объектами вместо написания программного кода. Одно из основных назначений визуальных методов программирования — разработка графических интерфейсов пользователя приложения.
Средства для организации взаимодействия с пользователем, например окна, кнопки, меню и другие элементы управления, называют графическим интерфейсом пользователя (Graphical User Interface, GUI). Windows — графическая операционная система, поэтому говорят, что она обеспечивает графический интерфейс пользователя.
Средства визуальной разработки служат сокращению затрат времени и средств на разработку приложения.
Среда быстрой разработки визуального интерфейса берет на себя рутинную работу, связанную с подготовкой программы к работе, автоматически генерирует соответствующий программный код и позволяют сосредоточиться не на оформлении интерфейса, а на логике работы будущей программы.
Процесс создания Windows-приложения состоит из двух основных этапов:
1. Визуальное проектирование, то есть задание внешнего облика приложения.
2. Определение поведения приложения путем написания процедур обработки различных событий.
Визуальное проектирование состоит в выборе и размещении различных элементов управления, таких, как кнопки, переключатели, значки и т.д. на плоскости окна будущего приложения. Такие элементы называются объектами (компонентами), их можно перетаскивать в проектируемом окне с помощью мыши. В итоге программисту остается только написать программный код, определяющий, что должна делать программа при наступлении определенного события:
• при щелчке мышью на той или иной кнопке;
• при выборе определенного пункта меню;
• по прошествии определенного интервала времени;
• и вообще при наступлении какого-либо иного события, которое может произойти с программой или с операционной системой, под управлением которой она работает.
Такое программирование визуального интерфейса и программного кода называют событийно-ориентированным.
Windows Forms — это часть.NET Framework, которая поддерживает создание приложений со стандартным GUI на платформе Windows. Различные элементы управления интерфейса (кнопки, меню, переключатели, списки, элементы ввода и т. д.) размещаются на форме. Форма — это окно Windows. На этапе разработки приложения форма – это экранный объект или контейнер, на поверхности которого размещаются компоненты. Когда разрабатываемая программа будет откомпилирована и запущена на исполнение, форма превратится в обычное окно Windows и будет реагировать на определенные в ней события. Таких окон в программе может быть сколько угодно.
Среда Visual Studio.NET предоставляет большое количество элементов, которые можно сгруппировать по нескольким функциональным группам.
Таблица 3.3 — Основные группы элементов управления
Интерфейсные элементы
Редактирование текста
Отображение текста
Label, LinkLabel, StatusBar
Выбор из списка
CheckedListBox, ComboBox, DomainUpDown, ListBox,
ListView, NumericUpDown, TreeView
Отображение графики
Хранение графики
Ввод значений
CheckBox, CheckedListBox, RadioButton, TrackBar
Диалоговые панели
ColorDialog, FontDialog, OpenFileDialog, PrintDialog,
Создание меню
Button, LinkLabel, NotifyIcon, ToolBar
Объединение компонентов
Panel, GroupBox, TabControl
Создание приложения с графическим интерфейсом на основе Windows Forms
Для создания Windows-приложения, после запуска Microsoft Visual Studio, выберите в меню пункт File—New—Project. На экране появится окно вида:
В этом и последующем окне создания проекта следует выбрать:
Project Types: Visual C#;
Templates: Windows Application;
Name: пишем то имя, с которым будет сформирован .exe файл;
Location: директория в которой будет помещен проект;
Можно поставить галочку «Create Directory for Solution» или задать директорию для данного решения в выбранной папке (кнопка Browse. ).
После выполнения указанных действий экран примет вид:
На панелях инструментов находятся элементы управления (компоненты), перетаскивая которые на форму, можно создавать графический интерфейс приложения Windows. Элементы управления разбиты на категории с логичными названиями, например Menus and Toolbars (меню и панели инструментов), Data (данные), Common Dialogs (диалоговые окна) и т.д. Чтобы добавить элемент управления на форму Windows, достаточно щелкнуть его мышью и перетащить на форму.
Каждый компонент является объектом в смысле объектно-ориентированного программирования – любой из них обладает свойствами и методами обработки событий, связанными с этими компонентами. Компонент, расположенный на панели элементов, является общим описанием класса. Компонент, расположенный на форме, является экземпляром этого класса. Экземпляру можно придать индивидуальные качества – определить индивидуальные свойства и методы. Поэтому однотипные элементы на форме могут иметь различный вид и вызывать различные действия.
С помощью окна свойств можно просматривать и изменять свойства и события, связанные с компонентами приложения. Окно свойств является контекстно-зависимым: пункты меню в нем зависят от редактируемых разработчиком параметров. Например, при изменении цвета фона формы Windows появляется палитра цветов, в которой можно выбрать другое значение.
Окно свойств также можно использовать для управления событиями Events. Чтобы сделать это, необходимо щелкнуть значок с изображением молнии 
, расположенный в верхней его части. С каждым событием (например, клик мышью) из списка событий можно связать заданный программный код, если дважды щелкнуть имя события.
Рассмотрим процесс разработки простого приложения с графическим интерфейсом.
Шаг 1. Поместите курсор мыши на закладку ToolBox (Панель элементов). Панель элементов раскроется как показано на рисунке.
Шаг 2. Раскройте раздел Common Controls (Обычные элементы управления) и перетащите элемент Button на Форму.
Шаг 3. Убедитесь что эта кнопка выделена в форме и отображена в окне Properties (Свойства). Содержимое в поле свойства Text измените на «Щелкните здесь».
Шаг 4. Щелкните дважды по кнопке на форме. Это должно вызвать редактор кода, где необходимо вписать следующий код:
private void button1_Click(object sender, EventArgs e)
Form2 obj = new Form2();
вписываем сами
Шаг 5. Добавьте вторую форму к Вашему проекту для этого щелкните правой кнопкой мыши на имени решения в Solution Explorer (Обозревателе решений). В появившемся меню выберите Add (Добавить) и затем Windows Form (Форму Windows Form).
Шаг 6. В появившемся диалоговом окне Add New Item (Добавление нового элемента) выберите Windows Form и нажмите Add (Добавить). Появится новая форма. В Обозревателе решений (Solution Explorer) появится новый пункт – Form2.cs
Шаг 7. Выберите вторую форму. В окне Properties (Свойства) изменить свойство FormBorderStyle на FixedToolWindow.
Шаг 8. Из панели элементов перетащите на форму элемент Label.
Шаг 9. Измените свойство Text объекта Label1 на «Сообщение для Вас. Щелкните по кнопке ниже, чтобы получит его».
Шаг 10. Перетащите на форму элемент Button и измените свойство Text на «Click Me».
Шаг 11. Щелкните дважды на кнопке — раскроется редактор кода:
private void button1_Click(object sender, EventArgs e)
MessageBox.Show(«Всем привет от C#»);
вписываем сами
Шаг 12. Сохраните и запустите проект на компиляцию и исполнение.
Рассмотрим пример разработки Windows- приложения, вычисляющего одно из трех выражений:
; 
, 
,
в зависимости от желания пользователя.
Шаг 1. Создайте новое Windows-приложение С#.
Шаг 2. Установите на форму элементы управления как это показано на рисунке
Шаг 3. Измените свойство Text элементов label1, label2, label3 и label4 на x =, y =, Функция и F = соответственно.
Шаг 4. Измените свойство Text элемента button1 на текст Вычислить, button2 — Выход.
Шаг 5. Измените свойство Text элемента comboBox1 на текст Выбор функции.
Затем нажмите на кнопке 
рядом со свойством Items элемента comboBox1 и введите три строки: F1, F2 и F3.
Шаг 6. Щелкните дважды на кнопке Выход, чтобы раскрылось окно редактора кода и впишите в обработчик события button2_Click код: Close( ); Этот оператор обеспечит завершение работы приложения при нажатии на кнопку button2.
Шаг 7. Вернитесь к редактору формы и щелкните дважды на кнопке Вычислить. Впишите в обработчик события button1_Click следующий код:
GUI обертка для консольного приложения на C#
Для тех кто не в курсе, GUI (Graphical user interface) — графический интерфейс пользователя. То есть это интерфейс в котором элементы управления представлены в виде изображений, анимации и так далее. Но существуют программы, которые не используют GUI. Обычно их называют «консольные приложения».
Сегодня я расскажу вам как создать GUI оболочку для консольного приложения. В этом нет ничего сложного, главное знать аргументы командной строки, которые принимает приложение.
Заинтересованных прошу под кат.
И так, для начала напишем маленький класс, со статистической функцией, которая будет запускать наше приложение. Я буду использовать Visual Studio 2010, C# и .NET 4.0. Создадим отдельный файл и в нем напишем каркас класса.
В .NET есть классы для запуска *.exe файлов. Что бы их использовать, необходимо подключить пространство имен System.Diagnostics. Допишем в начало файла:
Для запуска любого *.exe файла я использовал класс Process. Простой запуск *.exe файла можно сделать так:
Что произойдет во время MyProc.Start()? Наша программа запустит *.exe файл указанный в filename, и продолжит выполнение. Есть и другие варианты, но я использовал такой, так как далее, с помощью свойства StartInfo удобно задавать другие параметры запуска.
А что если нужно, что бы управляющая программа(программа которая запускает) дождалась завершения запускаемой программы? Для этого есть метод у класса Process, который называется WaitForExit. Он не возвращает управление, пока запущенное приложение не завершиться. Его недостаток проявиться, если запущенное приложение зависнет — из-за него зависнет управляющая программа, или поток который ее запустил в случае использования многопоточности. WaitForExit можно использовать после вызова Start, например вот так:
Для удобства, необходимо изменить метод Start нашего класса EXEStarter так, что бы программист мог сам задать «ждать завершение процесса или нет». Это совсем не трудно:
Как видно из фрагмента кода, если waitforexit равно true, значит метод будет ждать завершения процесса, ну и наоборот. Идем дальше. Для задания параметров консольному приложению, нам нужно использовать аргументы командной строки. У свойства StartInfo класса Process, есть свойство Arguments, которое принимает строку содержащую все аргументы командной строки, для этого приложения. снова допишем наш метод Start.
Неплохо было бы еще скрыть окно, которое открывается при запуске приложения, так как оно не несет никакой полезной нагрузки в данном случае. Для этого в StartInfo есть булевое свойство CreateNoWindow. Как вы уже догадались, если присвоить ему true — окно открываться не будет. Добавим перед запуском приложения строчку:
Теперь консольное окошко не будет открываться. Можно так же добавить строку:
Свойство UseShellExecute как вы уже догадались булевое и отвечает за то, будет ли при запуске использоваться оболочка ОС. Если поставить его в true, то можно в FileName задать не только *.exe файл, а и любой другой, или даже ссылку, при этом будет запущенно приложение, которое установлено по умолчанию в ОС для этого типа файлов.
Опять для удобства, можно перегрузить метод Start нашего класса, что бы он мог принимать меньше аргументов. Например вот так:
Работа с аргументами командной строки все еще остается не очень удобной. Я решил написать маленький класс, который стал бы для меня удобным средством создания аргументов командной строки. Из чего состоит аргумент командной строки? Из имени и значения. Обычно это выглядит например так: «-t 60», то есть «-t» имя, а «60» — значения. Много аргументов могут не принимать значения. Начнем написание класса.
Но в таком состоянии это не класс, а лишний код. Добавим метод ToString. Кстати, очень часто консольные утилиты в качестве аргументом принимают путь к какому-либо файлу. Если в этом пути есть пробелы, нужно ставить кавычки. Необходимо это учесть.
Я перегрузил метод ToString, который достался классу от Object. Если Value существует, добавляю кавычки и возвращаю строку. Допишем ему еще 2 конструктора, один принимает только имя, другой имя и значение.
Теперь класс закончен. Но его все равно будет не достаточно, ведь для добавления 10 аргументов в запуск *.exe придется создать 10 объектов этого класса и для каждого вызвать ToString. Напишем еще один класс на основе List из System.Collections.Generic. Вот что у меня получилось:
Методы List будут служить для добавления элементов, а перегруженный ToString вернет правильную строку с пробелами.
С классами все. Напишем маленький пример, что бы понять, как это работает. Для примера я использовал архиватор 7zip. Что бы за архивировать файл необходимо выполнить следующую команду:
Где %7zip Path% — путь к 7z.exe, «a» — опция, которая означает добавления файлов в архив, %Output Path% — путь результата, %Input Path% — путь для входного файла. Список всех аргументов командной строки для 7zip вы можете получит, запустив 7zip через консоль. Я создал небольшую форму с помощью WinForms. 
Поместил на нее 1 кнопку. Подключил к проекту свои файлы с классами EXEStarter, ComanLineArgument и ComandLineArgumentsList. После этого написал обработчик нажатия кнопки. Он вызывает сначала диалоги выбора файлов, а потом с помощью только что написанных классов архивирует выбранный файл. Код получился вот такой:
Вот собственно и все. Задавайте свои ответы. Пишите пожелания, критику и сообщайте о моих орфографических ошибках.