Структура проекта приложения windows forms

Первое приложение с .NET CLI

Последнее обновление: 25.11.2023

Для создания графических интерфейсов с помощью платформы .NET применяются разные технологии — Window Forms, WPF, UWP.
Однако наиболее простой и удобной платформой до сих пор остается Window Forms или сокращенно WinForms. Данное руководство ставит своей целью дать понимание принципов создания графических интерфейсов с помощью технологии WinForms
и работы основных элементов управления.

Создадим первое приложение на C# и Windows Forms. Что нам для этого потребуется? Прежде всего необходим текстовый редактор для написания кода программы.
Можно взять любой понравившийся текстовый редактор, например, Visual Studio Code

Также для компиляции и запуска программы нам потребуется .NET SDK. Для его установки перейдем на официальный сайт по ссылке
.NET SDK

После установки .NET SDK для первого проекта определим какую-нибудь папку. Например, в моем случае это будет папка C:\dotnet\winforms\helloapp.
Откроем терминал/командную строку и перейдем к созданной папке проекта с помощью команды cd

cd C:\dotnet\winforms\helloapp

В данном случае мы для создания и запуска проекта мы будем использовать встроенную инфраструктуру .NET CLI, которая устанавливается вместе с .NET SDK.

Для создания проекта в .NET CLI применяется команда dotnet new, после которой указывается тип проWindows Formsекта. Для создания проекта
Windows Forms применяется шаблон — winforms. Поэтому введем в терминале команду dotnet new winforms

C:\Users\eugen>cd C:\dotnet\winforms\helloapp

C:\dotnet\winforms\helloapp>dotnet new winforms
Шаблон "Приложение Windows Forms" успешно создан.

Идет обработка действий после создания...
Восстановление C:\dotnet\winforms\helloapp\helloapp.csproj:
  Определение проектов для восстановления...
  Восстановлен C:\dotnet\winforms\helloapp\helloapp.csproj (за 1,04 sec).
Восстановление выполнено.



C:\dotnet\winforms\helloapp>

После выполнения этой команды у нас будет создан следующий проект:

Структура проекта Windows Forms

Рассмотрим базовую структуру простейшего стандартного проекта Windows Forms:

• helloapp.csproj: стандартный файл проекта C#, который соответствует назанию проекта (по умолчанию названию каталога) и описывает все его настройки.

• helloapp.csproj.user: дополнительный файл проекта C#, который хранит специфичные для текущего пользователя настройки.

• Form1.cs: содержит класс формы, которая по умолчанию запускается при старте приложения

• Form1.Designer.cs: он содержит определение компонентов формы, добавленных
  на форму в графическом дизайнере (графический дизайнер Windows Forms на данный момент официально доступен только в Visual Studio)

• Program.cs: определяет класс Program, который запускается при старте приложения и запускает форму Form1

Например, посмотрим на содержимое файла helloapp.csproj

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>WinExe</OutputType>
    <TargetFramework>net8.0-windows</TargetFramework>
    <Nullable>enable</Nullable>
    <UseWindowsForms>true</UseWindowsForms>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

</Project>

Для компиляции приложения Windows Forms указаны следующие настройки:

• OutputType: определяет выходной тип проекта. Должен иметь значение WinExe — то есть выполняемое приложение с
  расширением exe под Windows

• TargetFramework: определяет применяемую для компиляции версию фреймворка .NET. Поскольку при создании проекта
  была выбрана версия .NET 8, а сам проект зависит от компонентов Windows, то здесь должно быть значение net7.0-windows

• Nullable: подключает в проект функционалность ссылочных nullable-типов

• UseWindowsForms: указывает, будет ли проект использовать Windows Forms (для этого устанавливается значение true)

• ImplicitUsings: подключает в проект функциональность неявно подключаемых глобальных пространств имен

Запуск проекта

Проект по умолчанию не представляет какой-то грандиозной функциональности, тем не менее этот проект мы уже можем запустить. Итак, запустим проект. Для этого выполним команду
dotnet run

C:\dotnet\winforms\helloapp>dotnet run

При запуске запускается графическая форма, код которой определяет класс Form1:

Картинка с сайта: metanit.com

Запуск приложения

Файл Program.cs определяет точку входа в приложение:

namespace helloapp;

static class Program
{
    [STAThread]
    static void Main()
    {
        ApplicationConfiguration.Initialize();
        Application.Run(new Form1());
    }    
}

Метод Main снабжен атрибутом [STAThread]. Этот атрибут, грубого говоря,
необходим для корректной работы компонентов Windows. В самом методе сначала вызывается метод

ApplicationConfiguration.Initialize()

который устанавливает некоторую базовую конфигурацию приложения

Затем вызывается метод

Application.Run(new Form1());

в который передается объект отображаемой по умолчанию на экране формы.

То есть, когда мы запустим приложение, сработает метод Main, в котором будет вызван метод Application.Run(new Form1()),
благодаря чему мы увидим форму Form1 на экране.

Определение формы

Теперь посмотрим на определение формы и немного изменим его. Для этого откроем файл Form1.cs в текстовом редакторе. По умолчанию он выглядит следующим образом:

namespace helloapp;

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }
}

Класс формы — Form1 представляет графическую форму — фактически то окно, которое мы увидим на экране при запуске проекта.

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

В самом классе Form1 определен по умолчанию только конструктор, где вызывается метод InitializeComponent(), который выполняет инициализацию компонентов формы из файла дизайнера
Form1.Designer.cs. По сути именно код этого файла передается выше через вызов InitializeComponent()

Теперь изменим его код следующим образом:

namespace helloapp;

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
        // определяем кнопку
        Button button = new Button();
        // текст кнопки
        button.Text ="Click";
        // положение кнопки
        button.Location = new Point(50, 50);
        // размер кнопки
        button.Size = new Size { Width = 80, Height = 30 };
        // обработчик нажатия кнопки
        button.Click += (o, e) => MessageBox.Show("Hello METANIT.COM!");
        // добавление кнопки на форму
        this.Controls.Add(button);
    }
}

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

Картинка с сайта: metanit.com

Простейшее приложение
WinForms может выглядеть
подобно следующему примеру:

using
System;

using
System.Windows.Forms;

namespace
SimpleApp

{

//
главное
окно

class
MainWindow
: Form

{

public
MainWindow()
{ }

}

//
класс
программы

class
Program

{

static
void
Main(string[]
args)

{

//
создаем
главное
окно

Application.Run(new
MainWindow());

}

}

}

Как видно, помимо
реализующего точку входа приложений
класса Program,
создается класс, наследующий от Form.
Экземпляр данного класса и представляет
собой главное окно запускаемого
приложения. Собственно запуск оконного
приложения осуществляется при помощи
вызова Application.Run(),
которому передается ссылка на экземпляр
главного окна.

Элементы управления

Элементы управления,
как правило, располагаются на форме,
образуя иерархическую древовидную
структуру. Например, на главном окне
могут находиться несколько кнопок и
панель, на которой в свою очередь будут
расположены несколько чекбоксов и
GroupBox, содержащий набор
переключателей (RadioButton).
Это реализовано при помощи свойства
Controls
базового класса System.Windows.Forms.Controls,
от которого унаследованы все остальные
элементы управления. Данное свойство
представляет собой коллекцию объектов
типа Control
и создание иерархической структуры
элементов обычно производится повторением
следующей последовательности шагов:

• В классе, порожденном
  от Form,
  определяется переменная-член нужного
  элемента UI.

• Настраивается
  внешний вид и поведение элемента UI.

• Полученный элемент
  UI добавляется в контейнер ControlCollection
  нужного родитель с помощью вызова
  Controls.Add()

События

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

class
MainWindow
: Form

{

//
Устанавливаем обработчики событий
создания окна и щелчка мышью

public
MainWindow()

{

this.Load
+=
new
EventHandler(MainWindow_Load);

this.Click
+=
new
EventHandler(MainWindow_Click);

}

//
Обработчик
щелка
мышью
по
окну

void
MainWindow_Click(object
sender,
EventArgs
e)

{

this.Text
=
«Click
detected!»;

}

//
Обработчик
создания
окна

private
void
MainWindow_Load(object
sender,
EventArgs
e)

{

this.Text
=
«Main
Window!»;

}

}

1. Техника визуальной разработки приложений
   в WinForms+C#.

1. Библиотека wpf. Отличия wpf от WindowsForms. Разметка xaml. Понятие Windows Presentation Foundation

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

Решения .NET
2.0 для обеспечения желаемой функциональности

Технология WPF
(появившаяся в версии .NET 3.0) специально
создавалась для того, чтобы объединить
все эти ранее несвязанные задачи в
рамках единой объектной модели. Таким
образом, теперь вся вышеперечисленная
функциональность реализована в WPF.

Возможно, одним из
наиболее значительных преимуществ WPF
стал способ четкого отделения внешнего
вида и поведения приложения от программной
логики, управляющей этим. Используя
XAML, можно определить пользовательский
интерфейс приложения через разметку
XML. Эта разметка (в идеале генерируемая
с помощью инструментов, таких как
Microsoft Expression Blend) может быть затем
присоединена к управляемому коду для
обеспечения деталей функциональности
программы. XAML позволяет определять не
только простые элементы пользовательского
интерфейса (кнопки, таблицы, окна списков
и т.п.), но также двух- и трехмерную
графику, анимацию, логику привязки
данных и функциональность мультимедиа
(вроде воспроизведения видео).

Программная модель
WPF отличается от Windows
Forms также тем, что для
вывода графики GDI не
используется. Все операции визуализации
выполняются через DirectX,
таким образом, WPF приложения
автоматически используют аппаратное
ускорение для вывода графики. Кроме
этого WPF позволяет
использовать разнообразные графические
эффекты (размытие, сглаживание,
прозрачность и т.д.) без необходимости
напрямую работать с вызовами DirectX.

Основные возможности
WPF:

• Множество диспетчеров
  компоновки (намного больше, чем в Windows
  Forms) для обеспечения
  исключительно гибкого контроля над
  размещением содержимого.

• Использование
  расширенного механизма привязки данных
  для связи содержимого с элементами
  пользовательского интерфейса
  разнообразными способами.

• Встроенный механизм
  стилей, позволяющий определять «темы»
  для приложения WPF.

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

• Поддержка двух- и
  трехмерной графики, анимации и
  воспроизведения видео и аудио.

• Развитый типографский
  API-интерфейс, поддерживающий
  документы XML Paper
  Specification (XPS),
  фиксированные документы (WYSIWYG),
  документы нефиксированного формата
  и аннотации в документах (например,
  API-интерфейс Sticky
  Notes).

• Поддержка
  взаимодействия с унаследованными
  моделями графического интерфейса (т.е.
  Windows Forms,
  ActiveX и Win32
  HWND). Например, можно
  встраивать специальные элементы
  управления Windows Forms
  в приложение WPF и наоборот.

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]

• #
• #
• #
• #
• #
• #
• #
• #
• #
• #
• #

Как структурировать приложения Windows в Visual Studio Team Foundation Server

Область применения

• Microsoft® Visual Studio® Team Foundation Server (TFS) .
• Microsoft Visual Studio Team System (VSTS) .
• Microsoft Windows® Form Applications

Описание

В этой статье подробно разбирается процесс организации и структурирования приложений Windows Form в Team Foundation Server. Описана рекомендованная структура дерева исходного кода в системе управления исходным кодом TFS.

Содержание

• Задачи.
• Обзор.
• Порядок операций.
• Шаг 1 — создание локальных папок проекта Windows Forms.
• Шаг 2 — создание пустого решения.
• Шаг 3 — добавление проекта Windows Forms в решение.
• Шаг 4 — добавление библиотеки элементов управления (при необходимости).
• Шаг 5 — добавление библиотеки классов (при необходимости).
• Шаг 6 — проверка структуры решения.
• Шаг 7 — проверка локальной структуры каталогов.
• Шаг 8 — добавление решения в систему управления исходным кодом.
• Рекомендации по работе с совместно используемым кодом.
• Дополнительные ресурсы.

Задачи

• Научиться создавать структуру дерева исходного кода приложения Windows Forms.
• Разобраться, какую структуру дерева рекомендуется использовать в системе управления исходным кодом TFS.

Обзор

В статье показано, как создавать структуру каталогов системы управления исходным кодом для приложений Windows Forms. Поскольку в проекты Windows Forms часто включаются дополнительные библиотеки классов и элементов управления, структура должна это учитывать. В системе управления исходным кодом папки для хранения проектов Windows Forms располагаются под папками верхнего уровня /Main/Source. Такая структура позволяет добавлять папки Development и Releases при необходимости создания ветвей для изолированной разработки и обслуживания выпущенных версий. Дополнительную информацию о создании структуры каталогов верхнего уровня вы найдете в разделе «Как структурировать папки управления исходным кодом в Visual Studio Team Foundation Server «.

Порядок операций

• Шаг 1 — создание локальных папок проекта Windows Forms.
• Шаг 2 — создание пустого решения.
• Шаг 3 — добавление проекта Windows Forms в решение.
• Шаг 4 — добавление библиотеки элементов управления (при необходимости).
• Шаг 5 — добавление библиотеки классов (при необходимости).
• Шаг 6 — проверка структуры решения.
• Шаг 7 — проверка локальной структуры каталогов.
• Шаг 8 — добавление решения в систему управления исходным кодом.

Шаг 1 — создание локальных папок проекта Windows Forms

На этом этапе вы создадите на своем компьютере локальную структуру каталогов для проекта Windows Forms. Чтобы обеспечить единый подход к командной разработке и эффективную организацию проектов на своем компьютере, сгруппируйте разрабатываемый исходный код всех командных проектов, над которыми вы работаете, в одной корневой папке, например, C:\DevProjects. Если такой папки еще нет на компьютере, создайте ее.

Шаг 2 — создание пустого решения

Начните создание приложения Windows Forms с явного создания файла решения Visual Studio (.sln) . Затем добавьте в него проект Windows Forms и все необходимые дополнительные проекты, например, библиотеки классов или элементов управления. Вот как создается решение в папке верхнего уровня C:\DevProjects.

1. В меню File выберите команду New и щелкните Project.
2. Разверните Other Project Types и выберите Visual Studio Solutions.
3. Выберите Blank Solution.
4. Назовите свое решение MyApp.
5. Присвойте свойству Location значение C:\DevProjects и щелкните OK. Будет создана папка C:\DevProjects\MyApp. Visual Studio добавляет в эту папку файл решения ( .sln ) и файл пользовательских параметров решения ( .suo ). Обратите внимание, что на шаге 8 в систему управления исходным кодом добавляется только файл .sln.

Шаг 3 — добавление проекта Windows Forms в решение

Добавьте проект Windows Forms в свое решение.

1. В Solution Explorer щелкните правой кнопкой решение MyApp, выберите Add и щелкните New Project.
2. В диалоговом окне Add New Project выберите Visual C# в качестве типа проекта и Windows Application в качестве шаблона.
3. Присвойте параметру Location значение C:\DevProjects\MyApp\Source.
4. Назовите проект MyWinFormApp.
5. Щелкните OK, чтобы закрыть диалоговое окно Add New Project и добавить проект.

Шаг 4 — добавление библиотеки элементов управления (при необходимости)

Если в приложении Windows Forms используются дополнительные библиотеки элементов управления, добавьте их следующим образом:

1. В Solution Explorer щелкните правой кнопкой свое решение, выберите Add и щелкните New Project.
2. В диалоговом окне Add New Project выберите Visual C# в качестве типа проекта и Windows Control Library в качестве шаблона.
3. Присвойте параметру Location значение C:\DevProjects\MyApp\Source.
4. Назовите библиотеку элементов управления ControlLibrary.
5. Щелкните OK, чтобы закрыть диалоговое окно Add New Project.

Шаг 5 — добавление библиотеки классов (при необходимости)

Если в приложении Windows Forms используются дополнительные библиотеки классов, добавьте их следующим образом:

1. В Solution Explorer щелкните правой кнопкой свое решение, выберите Add и щелкните New Project.
2. В диалоговом окне Add New Project выберите Visual C# в качестве типа проекта и Class Library в качестве шаблона.
3. Присвойте параметру Location значение C:\DevProjects\MyApp\Source.
4. Назовите библиотеку классов ClassLibrary1
5. Щелкните OK, чтобы закрыть диалоговое окно Add New Project.

Шаг 6 — проверка структуры решения

В Solution Explorer проверьте структуру решения. Она должна выглядеть следующим образом:

Шаг 7 — проверка локальной структуры каталогов

В проводнике Windows проверьте локальную структуру каталогов. Она должна выглядеть следующим образом:

Шаг 8 — добавление решения в систему управления исходным кодом

Добавьте в систему управления исходным кодом TFS свое решение, содержащее проект Windows Forms, а также, возможно, библиотеки классов и элементов управления.

1. Щелкните правой кнопкой мыши MyApp и выберите Add Solution to Source Control.
2. В диалоговом окне Add Solution MyApp to Source Control выберите свой командный проект.
3. В диалоговом окне щелкните Make New Folder и назовите новую папку Main.
4. Выделите вновь созданную папку Main и щелкните Make New Folder. Назовите новую папку Source.
5. Выделите вновь созданную папку Source и щелкните OK.

6. Проверьте структуру папок в системе управления исходным кодом, щелкнув дважды Source Control в Team Explorer. При этом откроется Source Control Explorer. Структура папок должна выглядеть следующим образом:

7. Теперь вы можете просматривать изменения, ожидающие возвращения на сервер, и возвращать файлы исходного кода. В меню View выберите Other Windows и щелкните Pending Changes. Выберите проект и исходные файлы, которые необходимо возвратить, введите комментарий к возвращаемым изменениям и щелкните Check In.

Рекомендации по работе с общим кодом

Существует два основных варианта использования общего кода в веб-приложениях Windows Forms:

Использование кода из общей папки

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

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

• C:\MyProjects\MyApp\
• C:\MyProjects\SharedCommon\

Используются следующие сопоставления рабочих областей:

Дополнительную информацию по этому вопросу вы найдете в статье «Working with multiple team projects in Team Build» по адресу http://blogs. msdn.com/manishagarwal/archive/2005/12/22/506635.aspx.

Создание ветви общего кода

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

В качестве примера опять рассмотрим командный проект Common, являющийся контейнером для совместно используемого кода. Чтобы создать ветвь для общего кода, выполните следующие действия:

1. В Source Control Explorer щелкните правой кнопкой мыши корневую папку командного проекта Common.
2. Щелкните Branch .
3. В диалоговом окне Branch в качестве Target задайте корневую папку командного проекта $/MyTeamProject1/Main/Source/ и щелкните OK.
4. После завершения ветвления не забудьте возвратить созданную ветвь в систему управления исходным кодом.

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

• Дополнительную информацию о создании рабочих областей вы найдете в статье «How to: Create a Workspace» по адресу http://msdn2.microsoft. com/en-us/library/ms181384(VS.80).aspx.
• Дополнительную информацию о ссылках на файлы сборок в разных командных проектах вы найдете в статье «Working with multiple team projects in Team Build» по адресу http://blogs.msdn.com/manishagarwal/ar-chive/2005/12/22/506635.aspx.