Додаток виндовс формс скачати як додати. Програмування в .NET Framework. Тести для LoginPresenter

Головна / Корисна інформація

Сьогодні я хочу розповісти про те, як створити проект Windows Forms на C++ в IDE Visual Studio 2013. Справа в тому, що, починаючи з VS 2012, у списку проектів, які можна створити, прибрали пункт Windows Forms. Я зараз говорю про те, що на C++, створити такий проект на C# можна, вибравши відповідний пункт у розділі проектів, що створюються. Однак той факт, що такий проект не можна вибрати зі списку, не говорить про те, що його не можна створити самому. Саме про це я хочу розповісти в цій статті.

Перше, що потрібно зробити - запустити Visual Studio. Як тільки VS запустили, послідовно натискаємо Файл > Створити > Проект

Після цього у вікні буде запропоновано вибрати тип проекту. Нам необхідно вибрати у розділі Visual C++ підрозділ CLR і вибрати пункт Пустий проект CLR.

Коли проект буде створено, у браузері рішень клацаємо правою кнопкою миші за створеним проектом. У контекстному меню, що відкрилося, послідовно вибираємо Додати > Створити елемент і в меню, що відкрилося, в розділі UI вибираємо Форма Windows Forms

Коли форму буде додано, в браузері рішень вибираємо файл MyForm.cpp. Перед вами відкриється Нова вкладказ єдиним рядком коду:

#include "MyForm.h"

У цей файл нам необхідно додати наступний код:

Using namespace System; використовуючи namespace System::Windows::Forms; void Main(array ^ args) ( Application::EnableVisualStyles(); Application::SetCompatibleTextRenderingDefault(false); Project1::MyForm form; Application::Run(%form); )

Після цього у властивостях проекту. Вибираємо підрозділ Системарозділу Компонувальник і в рядку Підсистема з меню вибираємо Windows (/SUBSYSTEM:WINDOWS) і натискаємо Застосувати.

Не закриваючи вікно властивостей проекту, переходимо до підрозділу Додатково та у рядку Точка входупишемо Mainі після цього натискаємо клавішу ОК.
На цьому налаштування проекту закінчуються. Для редагування зовнішнього вигляду форми необхідно перейти у вкладку MyForm.h [Конструктор], клацнувши двічі по файлу MyForm.h в браузері рішень.

Доброго часу доби!
Model-View-Presenter – досить відомий шаблон проектування. З першого погляду все виглядає просто: є модель (Model), яка містить всю бізнес-логіку екрану; Вид/Подання (View), який знає, як відобразити ті чи інші дані; Представник (Presenter), який є сполучною ланкою - реагує на події користувача в View, змінюючи Model, і навпаки.
Складність починається, коли кількість форм у проекті стає більшою за одну.
У цій статті розглядається:
- Трохи теорії;
- загальні проблемиреалізації MVP (зокрема Passive View) під Windows Forms;
- особливості реалізації переходів між формами та передача параметрів, модальні вікна;
- використання IoC-контейнера та шаблону Dependency Injection – DI (а саме Соnstructor Injection);
- деякі особливості тестування MVP програми (з використанням NUnit та NSubstitute);
- все це відбуватиметься на прикладі міні-проекту і намагатиметься бути наочним.
У статті торкається:
- Застосування шаблону Адаптер (Adapter);
- Проста реалізація шаблону Контролер програми (Application Controller).
Для кого ця стаття?
Головним чином для розробників-початківців на Windows Forms, які чули, але не пробували, або пробували, але не вийшло. Хоча впевнений, що деякі прийоми можна застосувати і для WPF, і навіть для веб-розробки.

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

Придумаємо просте завдання - реалізувати 3 екрани:
1) екран авторизації;
2) головний екран;
3) модальний екран зміни імені користувача.
Повинно вийти щось на кшталт цього:

Трохи теорії

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

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

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

Типова реалізація представника

public class Presenter ( private readonly IView _view; private readonly IService _service; public Presenter( IView view, IService service) ( _view = view; _service = service; _view.UserIdChanged += () => UpdateUserInfo(); ) private void ) ( var user = _service.GetUser(_view.UserId); _view.Username = user.Username; _view.Age = user.Age; ) )

Які плюси нам дає мала пов'язаність класів (використання інтерфейсів, подій)?
1. Дозволяє відносно вільно змінювати логіку будь-якого компонента, не ламаючи решту.
2. Великі можливості при unit-тестуванні. Шанувальники TDD мають бути у захваті.
Почнемо!

Як організувати проекти?

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

Що писати в Main()?

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

Private static void Main() ( Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new MainForm()); // безпосередній запуск форми (уявлення) )
Але ми домовилися, що Представники керуватимуть Представленнями, тому хотілося б, щоб код виглядав якось так:

Private static void Main() ( Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); var presenter = New LoginPresenter(New LoginForm(), New LoginService());
Спробуємо реалізувати перший екран:

Базові інтерфейси

// загальні методи всім уявлень public interface IView ( void Show(); void Close(); ) // контракт, яким представник буде взаємодіяти з формою public interface ILoginView: IView ( string Username ( get; ) string Password ( get; ); ) event Action Login; // подія "користувач намагається авторизуватися" void ShowError(string errorMessage); ) public interface IPresenter ( void Run(); ) // найдурніший сервіс авторизації public interface - Успішна авторизація, інакше false )

Подання

public class LoginPresenter: IPresenter ( private readonly ILoginView _view; private readonly ILoginService _service; public LoginPresenter(ILoginView view, ILoginService service) (_view = view; _service = service; .Password); ) public void Run() ( _view.Show(); ) private void Login(string username, string password) ( if (username == null) throw new ArgumentNullException("username"); if (password == null) throw new ArgumentNullException("password"); var user = new User (Name = username, Password = password); if (!_service.Login(user)) else ( // Успішна авторизація, запуск головного екрану (?) ) ) )

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

Public partial class LoginForm: Form, ILoginView ( // ... public new void Show() ( Application.Run(this); ) )
Це заклинання дозволить нашому додатку запуститися, відобразити форму, а після закриття форми коректно завершити програму. Але до цього ми ще повернемось.

А випробування будуть?

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

Тести для LoginPresenter

Public class LoginPresenterTests ( private ILoginView _view; public void SetUp() ( _view = Substitute.For (); // заглушка для представлення var service = Substitute.For (); // заглушка для сервісу service.Login(Arg.Any ()) // авторизується лише користувач admin/password .Returns(info => info.Arg ().Name == "admin" && info.Arg ().Password == "password"); var presenter = новий LoginPresenter(_view, service); presenter.Run(); ) public void InvalidUser() ( _view.Username.Returns("Vladimir"); _view.Password.Returns("VladimirPass"); _view.Login += Raise.Event (); _view.Received().ShowError(Arg.Any ()); // цей метод повинен викликатися з текстом помилки ) public void ValidUser() ( _view.Username.Returns("admin"); _view.Password.Returns("password"); _view.Login += Raise.Event (); _view.DidNotReceive().ShowError(Arg.Any ()); // а в цьому випадку все ОК))

Тести досить дурні, як поки й сам додаток. Але так чи інакше вони успішно пройдені.

Хто і як запустить другий екран із параметром?

Як ви могли помітити, я не написав жодного коду за успішної авторизації. Як мені запустити другий екран? Перше на думку спадає це:

// LoginPresenter: успішна авторизація var mainPresenter = new MainPresenter(new MainForm()); mainPresenter.Run(user);
Але ми домовилися, що представники нічого не знають про уявлення, крім їх інтерфейсів. Що ж робити?
На допомогу приходить патерн Application Controller (реалізований спрощено), всередині якого міститься IoC-контейнер, який знає, як за інтерфейсом отримати об'єкт реалізації.
Контролер передається кожному Представнику параметром конструктора (знову DI) та реалізує приблизно такі методи:

Public interface IApplicationController ( IApplicationController RegisterView () where TImplementation: class, TView where TView: IView; IApplicationController RegisterService () де TImplementation: class, TService; void Run () where TPresenter: class, IPresenter; )
Після невеликого рефакторингу запуск програми став виглядати так:

Private static void Main() ( Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); // всі залежності тепер реєструються в одному місці: var controller = new ApplicationController(new LightInjectAdapder()) .RegisterView () .RegisterService () .RegisterView (); controller.Run (); }
Пару слів про новий ApplicationController(new LightInjectAdapder()) . Як IoC-контейнер я використовував бібліотеку LightInject, але не безпосередньо, а через адаптер (патерн Adapter), щоб у разі, якщо знадобиться змінити контейнер на інший, я зміг написати інший адаптер і не змінювати логіку контролера. Всі методи, що використовуються, є в більшості IoC-бібліотек, складнощів виникнути не повинно.
Реалізуємо додатковий інтерфейс IPresenter, який відрізняється лише тим, що метод Run приймає параметр. Потім успадкуємо від нього аналогічно першому екрану.
Тепер, не без гордості, запускаємо другий екран, передаючи авторизованого користувача:

Controller.Run (user); View.Close();

Не можна просто так взяти та закрити форму.

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

// LoginForm public new void Show() ( _context.MainForm = this; Application.Run(_context); ) // MainForm public new void Show() ( _context.MainForm = this; base.Show(); )

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

Реалізація модального вікна не викликає труднощів. На кнопці "Змінити ім'я" виконується Controller.Run (user) . Єдина відмінність цієї форми від інших - вона не головна, тому формі для показу не потрібно ApplicationContext:

Public new void Show() ( ShowDialog(); )
Якщо потрібно відкрити звичайне вікно, метод взагалі не потрібно визначати, оскільки він вже реалізований у класі Form.

Ну і накрутили... Як тепер ЦЕ використати?

Тепер, коли каркас готовий, додавання нової форми зводиться до таких кроків:

Пишемо інтерфейс Подання, інтерфейс Моделі (якщо потрібно).
Реалізуємо Представника, принагідно вирішивши, чи будемо в нього передавати якісь дані чи модель.
[Опціонально] Пишемо тести для Представника, переконуємось, що все нормально.
[Опціонально] Реалізуємо Модель та тести для неї.
Накидаємо форми і реалізуємо інтерфейс Уявлення.

Зміна IoC-контейнера на вашого улюбленого відбувається шляхом реалізації простого інтерфейсу IContainer класом-адаптером.

Забрати демонстраційний проект можна з

https://metanit.com/sharp/windowsforms/1.1.php
Введення у Windows Forms
Для створення графічних інтерфейсів за допомогою платформи .NET застосовуються різні технології- Window Forms, WPF, програми для магазину Windows Store (для ОС Windows 8/8.1/10). Однак найбільш простою та зручною платформою досі залишається Window Forms або форми. Даний посібник ставить за мету дати розуміння принципів створення графічних інтерфейсів за допомогою технології WinForms і роботи основних елементів управління.
Створення графічної програми
Для створення графічного проекту нам знадобиться середовище розробки Visual Studio. Оскільки найбільш поширена поки що версія Visual Studio 2013, то для цього посібника я використовуватиму безкоштовну версіюданого середовища Visual Studio Community 2013яку можна знайти на сторінці https://www.visualstudio.com/en-us/products/visual-studio-community-vs.aspx.
Після встановлення середовища та всіх його компонентів, запустимо Visual Studio і створимо проект графічної програми. Для цього в меню виберемо пункт File (Файл) і підменю виберемо New - > Project (Створити - > Проект). Після цього перед нами відкриється діалогове вікно створення нового проекту:
У лівій колонці виберемо Windows Desktop, а центральній частині серед типів проектів - тип Windows Forms Applicationі дамо йому якесь ім'я в полі внизу. Наприклад, назвемо його HelloApp. Після цього натискаємо OK.
Після цього Visual Studio відкриє проект із створеними за замовчуванням файлами:
Більшість простору Visual Studio займає графічний дизайнер, який містить форму майбутньої програми. Поки що вона порожня і має лише заголовок Form1. Праворуч знаходиться вікно файлів рішення/проекту – Solution Explorer (Оглядач рішень). Там і знаходяться всі пов'язані з нашим додатком файли, у тому числі файли форми Form1.cs.
Внизу праворуч знаходиться вікно властивостей – Properties. Так як у мене в даний момент вибрано форму як елемент управління, то в цьому полі відображаються властивості, пов'язані з формою.
Тепер знайдемо у цьому вікні властивість форми Text і змінимо його значення будь-яке інше:
Таким чином, ми змінили заголовок форми. Тепер перенесемо на поле якийсь елемент керування, наприклад, кнопку. Для цього знайдемо у лівій частині Visual Studio вкладку Toolbox (Панель інструментів). Натисніть на цю вкладку, і у нас відкриється панель з елементами, звідки ми можемо за допомогою миші перенести на форму будь-який елемент:
Знайдемо серед елементів кнопку і, захопивши її покажчиком миші, перенесемо на форму:
Це – візуальна частина. Тепер приступимо до самого програмування. Додамо найпростіший код мовою C#, який виводив би повідомлення з натискання кнопки. Для цього ми повинні перейти до файлу коду, який пов'язаний із цією формою. Якщо у нас не відкритий файл коду, ми можемо натиснути на форму правою кнопкою миші і в меню вибрати View Code (Подивитися файл коду):
Однак скористаємося іншим способом, щоби не писати багато зайвого коду. Наведемо покажчик миші на кнопку і клацніть по ній подвійним клацанням. Ми автоматично потрапляємо у файл коду Form1.cs, який виглядає так:
Using System;

використовуючи System.ComponentModel;
використовуючи System.Data;
використовуючи System.Drawing;
використовуючи System.Linq;
використовуючи System.Text;

using System.Windows.Forms;
Namespace HelloApp
{

{
Public Form1()
{
InitializeComponent();
}

{
}
}
}
Додамо виведення повідомлення після натискання кнопки, змінивши код таким чином:
Using System;
використовуючи System.Collections.Generic;
використовуючи System.ComponentModel;
використовуючи System.Data;
використовуючи System.Drawing;
використовуючи System.Linq;
використовуючи System.Text;
використовуючи System.Threading.Tasks;
using System.Windows.Forms;
Namespace HelloApp
{
public partial class Form1: Form
{
Public Form1()
{
InitializeComponent();
}
Private void button1_Click(object sender, EventArgs e)
{
MessageBox.Show("Привіт");
}
}
}
Запуск програми
Щоб запустити програму в режимі налагодження, натисніть клавішу F5 або зелену стрілку на панелі Visual Studio. Після цього запуститься наша форма із самотньою кнопкою. І якщо ми натиснемо кнопку на формі, то нам буде відображено повідомлення з привітанням.
Після запуску програми студія компілює його у файл із розширенням exe. Знайти даний файлможна, зайшовши до папки проекту і далі в каталог bin/Debug або bin/Release
Розглянувши коротко створення проекту графічного докладання, ми можемо перейти до огляду основних компонентів і почнемо з форм.
https://metanit.com/sharp/windowsforms/2.1.php
Робота з формами
Основи форм
Зовнішній вигляд програми є переважно через форми. Форми є основними будівельними блоками. Вони надають контейнер для різних елементів керування. А механізм подій дозволяє елементам форми відкликатися введення користувача, і, таким чином, взаємодіяти з користувачем.
При відкритті проекту в Visual Studio в графічному редакторіми можемо побачити візуальну частину форми - ту частину, яку ми бачимо після запуску програми і куди переносимо елементи з панелі управління. Але насправді форма приховує потужний функціонал, що складається з методів, властивостей, подій та інше. Розглянемо основні властивості форм.
Якщо ми запустимо програму, то відобразиться одна порожня форма. Однак навіть такий простий проект із порожньою формою має кілька компонентів:
Незважаючи на те, що ми бачимо лише форму, але стартовою точкою входу в графічний додаток є клас Program, розташований у файлі Program.cs:
Using System;
використовуючи System.Collections.Generic;
використовуючи System.Linq;
використовуючи System.Threading.Tasks;
using System.Windows.Forms;
Namespace HelloApp
{
static class Program
{
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
}
}
Спочатку програмою запускається цей клас, потім за допомогою виразу Application.Run(new Form1()) він запускає форму Form1. Якщо раптом ми захочемо змінити стартову форму в додатку на якусь іншу, то нам треба змінити у цьому виразі Form1 на відповідний клас форми.
Сама форма складна за змістом. Вона поділяється на низку компонентів. Так, у структурі проекту є файл Form1.Designer.cs, який виглядає приблизно так:
Namespace HelloApp
{
partial class Form1
{
///

/// Required designer variable.
///

///

/// Clean up any resources being used.
///

/// true if managed resources should be disposed; іншіwise, false.

{

{
components.Dispose();
}
base.Dispose(disposing);
}
#region Windows Form Designer generated code
///

/// Required метод для Designer support - do not modify
/// the contents of this method with the code editor.
///

{
this.SuspendLayout();
// Form1

this.Name = "Form1";
this.Text = "Привіт світ!";
this.ResumeLayout(false);
}
}
Тут оголошується частковий клас форми Form1, яка має два методи: Dispose(), який виконує роль деструктора об'єкта, та InitializeComponent(), який встановлює початкові значення властивостей форми.
При додаванні елементів керування, наприклад, кнопок, їх опис також додається до файлу.
Але на практиці ми рідко зіштовхуватимемося з цим класом, тому що вони виконує в основному дизайнерські функції - встановлення властивостей об'єктів, встановлення змінних.
Ще один файл - Form1.resx- Зберігає ресурси форми. Як правило, ресурси використовуються для створення одноманітних форм одночасно для кількох мовних культур.
І важливіший файл - Form1.cs, який у структурі проекту називається просто Form1, містить код або програмну логіку форми:
Using System;
використовуючи System.Collections.Generic;
використовуючи System.ComponentModel;
використовуючи System.Data;
використовуючи System.Drawing;
використовуючи System.Linq;
використовуючи System.Text;
використовуючи System.Threading.Tasks;
using System.Windows.Forms;
Namespace HelloApp
{
public partial class Form1: Form
{
Public Form1()
{
InitializeComponent();
}
}
}
За замовчуванням тут є лише конструктор форми, в якому просто викликається метод InitializeComponent(), оголошений у файлі дизайнера Form1.Designer.cs. Саме з цим файлом ми і більше працюватимемо.
https://metanit.com/sharp/windowsforms/2.2.php
Основні властивості форм
За допомогою спеціального вікна Properties (Властивості) праворуч Visual Studio надає нам зручний інтерфейс для керування властивостями елемента:
Більшість цих властивостей впливає візуальне відображення форми. Пробіжимося за основними властивостями:
- Name: встановлює ім'я форми – точніше ім'я класу, який успадковується від класу Form
- BackColor: вказує на колір фону форми. Клацнувши на цю властивість, ми зможемо вибрати той колір, який нам підходить зі списку запропонованих кольорів або палітри кольорів
- BackgroundImage: вказує на зображення фону форми
- BackgroundImageLayout: визначає, як зображення, задане у властивості BackgroundImage, розташовуватиметься на формі.
- ControlBox: вказує, чи відображається меню форми. У даному випадкупід меню розуміється меню найвищого рівня, де знаходяться іконка програми, заголовок форми, а також кнопки мінімізації форми та хрестик. Якщо ця властивість має значення false, то ми не побачимо ні іконки, ні хрестика, за допомогою якого зазвичай закривається форма
- Cursor: визначає тип курсору, який використовується на формі
- Enabled: якщо ця властивість має значення false, вона не зможе отримувати введення від користувача, тобто ми не зможемо натиснути на кнопки, ввести текст у текстові поля і т.д.
- Font: задає шрифт для всієї форми та всіх розміщених на неї елементів управління. Проте, задавши у елементів форми свій шрифт, ми можемо цим перевизначити його
- ForeColor: колір шрифту на формі
- FormBorderStyle: вказує, як буде відображатися межа форми та рядок заголовка. Встановлюючи цю властивість у None можна створювати зовнішній вигляддодатки довільної форми
- HelpButton: вказує, чи відображається кнопка довідки форми
- Icon: задає піктограму форми
- Location: визначає положення по відношенню до лівого верхнього кута екрана, якщо для властивості StartPosition встановлено значення Manual
- MaximizeBox: вказує, чи буде доступна кнопка максимізації вікна в заголовку форми
- MinimizeBox: вказує, чи буде доступна кнопка мінімізації вікна
- MaximumSize: задає максимальний розмір форми
- MinimumSize: задає мінімальний розмір форми
- Opacity: задає прозорість форми
- Size: визначає початковий розмір форми
- StartPosition: вказує на початкову позицію, з якої форма з'являється на екрані
- Text: визначає заголовок форми
- TopMost: якщо ця властивість має значення true, то форма завжди буде знаходитися поверх інших вікон
- Visible: чи видима форма, якщо ми хочемо приховати форму від користувача, то можемо задати цій властивості значення false
- WindowState: вказує, у якому стані форма перебуватиме при запуску: у нормальному, максимізованому або мінімізованому
Програмне налаштування властивостей
За допомогою значень властивостей у вікні Властивості ми можемо змінити на свій розсуд зовнішній вигляд форми, але все те саме ми можемо зробити динамічно в коді. Перейдемо до коду, для цього натиснемо правою кнопкою миші на формі і виберемо в контекстному меню View Code (Перегляд коду). Перед нами відкривається файл коду Form1.cs. Змінимо його так:
Using System;
використовуючи System.Collections.Generic;
використовуючи System.ComponentModel;
використовуючи System.Data;
використовуючи System.Drawing;
використовуючи System.Linq;
використовуючи System.Text;
використовуючи System.Threading.Tasks;
using System.Windows.Forms;
Namespace HelloApp
{
public partial class Form1: Form
{
Public Form1()
{
InitializeComponent();
Text = "Hello World!";
this.BackColor = Color.Aquamarine;
this.Width = 250;
this.Height = 250;
}
}
}

У цьому випадку ми налаштували кілька властивостей відображення форми: заголовок, колір фону, ширину і висоту. При використанні конструктора форми треба враховувати, що решта коду повинен йти після виклику методу InitializeComponent(), тому всі установки властивостей тут розташовані після цього методу.
Встановлення розмірів форми
Для встановлення розмірів форми можна використовувати такі властивості, як Width/Height або Size. Width/Height приймають числові значення, як у наведеному вище прикладі. При встановленні розмірів через властивість Size, нам треба привласнити властивості об'єкт типу Size:
This.Size = new Size(200,150);
Об'єкт Size у свою чергу набуває в конструкторі числові значення для встановлення ширини та висоти.
Початкове розташування форми
Початкове розташування форми встановлюється за допомогою властивості StartPosition, яка може приймати одне з наступних значень:
- Manual: Положення форми визначається властивістю Location
- CenterScreen: Положення форми в центрі екрану
- WindowsDefaultLocation: Позиція форми на екрані визначається системою Windows, а розмір визначається властивістю Size
- WindowsDefaultBounds: Початкова позиція та розмір форми на екрані задається системою Windows
- CenterParent: Положення форми встановлюється у центрі батьківського вікна
Всі ці значення містяться в перерахунку FormStartPosition, тому, щоб, наприклад, встановити форму в центрі екрана, нам треба прописати так:
This.StartPosition = FormStartPosition.CenterScreen;
Фон та кольори форми
Щоб встановити колір як фону форми, так і шрифту, нам треба використовувати значення кольору, що зберігається в структурі Color:
This.BackColor = Color.Aquamarine;
this.ForeColor = Color.Red;
Крім того, ми можемо як фон задати зображення у властивості BackgroundImage, вибравши його у вікні властивостей або в коді, вказавши шлях до зображення:
This.BackgroundImage = Image.FromFile("C:\Users\Eugene\Pictures\3332.jpg");
Щоб належним чином налаштувати потрібне нам відображення фонової картинки, треба використовувати властивість BackgroundImageLayout, яка може приймати одне з наступних значень:
- None: Зображення міститься у верхньому лівому кутку форми та зберігає свої початкові значення
- Tile: Зображення розташовується на формі у вигляді мозаїки
- Center: Зображення розташовується по центру форми
- Stretch: Зображення розтягується до розмірів форми без збереження пропорцій
- Zoom: Зображення розтягується до розмірів форми із збереженням пропорцій
Наприклад, розташуємо форму по центру екрана:
This.StartPosition = FormStartPosition.CenterScreen;
https://metanit.com/sharp/windowsforms/2.3.php
Додавання форм. Взаємодія між формами
Щоб додати ще одну форму до проекту, натисніть на ім'я проекту у вікні Solution Explorer (Обозреватель рішень) правою кнопкою миші і виберемо Add(Додати)->Windows Form...
Дамо новій формі якесь ім'я, наприклад, Form2.cs:
Отже, у нас у проект було додано другу форму. Тепер спробуємо здійснити взаємодію між двома формами. Припустимо, перша форма натискання на кнопку буде викликати другу форму. По-перше, додамо на першу форму Form1 кнопку та подвійним клацанням по кнопці перейдемо у файл коду. Отже, ми потрапимо в обробник події натискання кнопки, який створюється за замовчуванням після подвійного натискання на кнопку:

{
}
Тепер додамо до нього код виклику другої форми. У нас друга форма називається Form2, тому спочатку ми створюємо об'єкт цього класу, а потім для його відображення на екрані викликаємо метод Show:
Private void button1_Click(object sender, EventArgs e)
{
Form2 newForm = new Form2();
newForm.Show();
}
Тепер зробимо навпаки – щоб друга форма вплинула на першу. Поки що друга форма не знає про існування першої. Щоб це виправити, треба другій формі передати відомості про першу форму. Для цього скористаємося передачею посилання на форму у конструкторі.
Отже, перейдемо до другої форми і перейдемо до її коду - натиснемо правою кнопкою миші на форму і виберемо View Code (Перегляд коду). Поки що він порожній і містить лише конструктор. Оскільки C# підтримує перевизначення методів, ми можемо створити кілька методів і конструкторів з різними параметрамита залежно від ситуації викликати один із них. Отже, змінимо файл коду другої форми на наступний:
Using System;
використовуючи System.Collections.Generic;
використовуючи System.ComponentModel;
використовуючи System.Data;
використовуючи System.Drawing;
використовуючи System.Linq;
використовуючи System.Text;
використовуючи System.Threading.Tasks;
using System.Windows.Forms;
Namespace HelloApp
{
public partial class Form2: Form
{
Public Form2()
{
InitializeComponent();
}
Public Form2(Form1 f)
{
InitializeComponent();
f.BackColor = Color.Yellow;
}
}
}
Фактично ми тільки додали тут новий конструктор public Form2(Form1 f), в якому ми отримуємо першу форму та встановлюємо її тло у жовтий колір. Тепер перейдемо до коду першої форми, де ми викликали другу форму та змінимо його на наступний:
Private void button1_Click(object sender, EventArgs e)
{
Form2 newForm = new Form2(this);
newForm.Show();
}
Оскільки в даному випадку ключове слово this представляє посилання на поточний об'єкт - об'єкт Form1, то при створенні другої форми вона отримуватиме її (посилання) і через неї керуватиме першою формою.
Тепер після натискання на кнопку у нас буде створено другу форму, яка відразу змінить колір першої форми.
Ми можемо також створювати об'єкти та поточної форми:
Private void button1_Click(object sender, EventArgs e)
{
Form1 newForm1 = new Form1();
newForm1.Show();
Form2 newForm2 = new Form2(newForm1);
newForm2.Show();
}
Працюючи з кількома формами треба враховувати, що з них є головною - яка запускається першої у файле Program.cs. Якщо в нас одночасно відкрита купа форм, то при закритті головною закривається вся програма і разом з ним всі інші форми.
https://metanit.com/sharp/windowsforms/2.4.php
Події Windows Forms. Події форми
Для взаємодії з користувачем Windows Forms використовується механізм подій. Події в Windows Forms представляють стандартні події на C#, що тільки застосовуються до візуальних компонентів і підпорядковуються тим же правилам, що події C#. Але створення обробників подій у Windows Forms все ж таки має деякі особливості.
Насамперед WinForms є деякий стандартний набір подій, який здебільшого є у всіх візуальних компонентів. Окремі елементи додають свої події, але принципи роботи з ними будуть схожими. Щоб переглянути всі події елемента, нам потрібно вибрати цей елемент у полі графічного дизайнера та перейти до вкладки подій на панелі форм. Наприклад, події форми:
Щоб додати обробник, можна просто двічі натиснути по порожньому полю поруч із назвою події, і після цього Visual Studio автоматично згенерує обробник події. Наприклад, натисніть для створення обробника для події Load:
І в цьому полі відобразиться назва методу обробника події Load. За промовчанням він називається Form1_Load.
Якщо ми перейдемо у файл коду форми Form1.cs, побачимо автосгенерований метод Form1_Load:

{
Public Form1()
{
InitializeComponent();
}

{
}
}
І при кожному завантаженні форми спрацьовуватиме код в обробнику Form1_Load.
Як правило, більшість обробників різних візуальних компонентів мають два параметри: sender - об'єкт, який ініціював подію, та аргумент, що зберігає інформацію про подію (у даному випадку EventArgs e).
Але це лише обробник. Додавання ж обробника, створеного таким чином, провадиться у файлі Form1.Designer.cs:
Namespace HelloApp
{
partial class Form1
{
private System.ComponentModel.IContainer components = null;
Protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
private void InitializeComponent()
{
this.SuspendLayout();
This.AutoScaleDimensions = New System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.ClientSize = New System.Drawing.Size(284, 261);
this.Name = "Form1";
// додавання оброблювача
this.Load += New System.EventHandler(this.Form1_Load);
this.ResumeLayout(false);
}
}
}
Для додавання обробника використається стандартний синтаксис C#: this.Load += new System.EventHandler(this.Form1_Load)
Тому якщо ми захочемо видалити створений подібним чином обробник, нам треба не тільки видалити метод з коду форми в Form1.cs, але і видалити додавання обробника в цьому файлі.
Однак ми можемо додавати обробники подій та програмно, наприклад, у конструкторі форми:
Using System;
використовуючи System.Collections.Generic;
використовуючи System.ComponentModel;
використовуючи System.Data;
використовуючи System.Drawing;
використовуючи System.Linq;
використовуючи System.Text;
використовуючи System.Threading.Tasks;
using System.Windows.Forms;
Namespace HelloApp
{
public partial class Form1: Form
{
Public Form1()
{
InitializeComponent();
this.Load += LoadEvent;
}
Private void Form1_Load(object sender, EventArgs e)
{
}
Private void LoadEvent(object sender, EventArgs e)
{

}
}
}
Крім раніше створеного обробника Form1_Load, тут також доданий інший обробник завантаження форми: this.Load += LoadEvent;, який встановлює як фон жовтий колір.
https://metanit.com/sharp/windowsforms/2.5.php
Створення непрямокутних форм. Закриття форми
За замовчуванням усі форми у Windows Forms прямокутні. Однак ми можемо створювати і непрямокутні довільні форми. Для цього використовується властивість Region. Як значення воно набуває об'єкт однойменного класу Region.
При створенні непрямокутних форм, зазвичай, не використовуються межі форми, оскільки кордону задаються цим об'єктом Region. Щоб усунути межі форми, треба привласнити у форми властивості FormBorderStyle значення None.
І ще один аспект, який треба враховувати, полягає у переміщенні, закритті, максимізації та мінімізації форм. Тобто в даному випадку, як у звичайній формі, ми не зможемо натиснути на хрестик, щоби закрити форму, не зможемо її перемістити на нове місце. Тому нам треба додатково визначати для цього програмну логіку.
Отже, перейдемо до коду форми та змінимо його наступним чином:
Using System;
використовуючи System.Collections.Generic;
використовуючи System.ComponentModel;
використовуючи System.Data;
використовуючи System.Drawing;
використовуючи System.Linq;
використовуючи System.Text;
використовуючи System.Threading.Tasks;
using System.Windows.Forms;
Namespace HelloApp
{
public partial class Form1: Form
{
Point moveStart; // точка для переміщення
Public Form1()
{
InitializeComponent();
this.FormBorderStyle = FormBorderStyle.None;
this.BackColor = Color.Yellow;
button1.Text = "Закрити";
}
Private void button1_Click(object sender, EventArgs e)
{
this.Close();
}
Private void Form1_Load(object sender, EventArgs e)
{
System.Drawing.Drawing2D.GraphicsPath myPath = new System.Drawing.Drawing2D.GraphicsPath();
// створюємо еліпс з висотою та шириною форми
myPath.AddEllipse(0, 0, this.Width, this.Height);
// створюємо за допомогою еліпса ту область форми, яку хочемо бачити
Region myRegion = новий Region(myPath);
// встановлюємо видиму область
this.Region = myRegion;
}
Private void Form1_MouseDown(object sender, MouseEventArgs e)
{

if (e.Button == MouseButtons.Left)
{
moveStart = новий Point(e.X, e.Y);
}
}
Private void Form1_MouseMove(object sender, MouseEventArgs e)
{
// якщо натиснута ліва кнопка миші
if ((e.Button & MouseButtons.Left)! = 0)
{
// отримуємо нову точку положення форми
Point deltaPos = новий Point(e.X - moveStart.X, e.Y - moveStart.Y);
// встановлюємо положення форми
this.Location = новий Point(this.Location.X + deltaPos.X,
this.Location.Y + deltaPos.Y);
}
}
}
}

Створення області форми відбувається у обробнику події Form1_Load. Для створення області використовується графічний шлях - об'єкт класу System.Drawing.Drawing2D.GraphicsPath, до якого додається еліпс. Графічний шлях дозволяє створити фігуру будь-якої форми, тому, якщо ми захочемо форму у вигляді морської зірки, то просто потрібно належним чином налаштувати використовуваний графічний шлях.
Для закриття форми в обробнику події натискання кнопки button1_Click форма закривається програмним чином: this.Close()
Для переміщення форми обробляються дві події форми - подія натискання кнопки і подія переміщення покажчика миші.
https://metanit.com/sharp/windowsforms/3.1.php
Контейнери у Windows Forms
Для організації елементів управління зв'язані групи існують спеціальні елементи - контейнери. Наприклад, Panel, FlowLayoutPanel, SplitContainer, GroupBox. Ту ж форму можна віднести до контейнерів. Використання контейнерів полегшує керування елементами, а також надає формі певного візуального стилю.
Всі контейнери мають властивість Controls, що містить усі елементи цього контейнера. Коли ми переносимо будь-який елемент з панелі інструментів на контейнер, наприклад кнопку, вона автоматично додається до цієї колекції цього контейнера. Або ми також можемо додати елемент керування динамічно за допомогою коду у цю колекцію.
Динамічне додавання елементів
Додамо на форму динамічно кнопку. Для цього додамо подію завантаження форми, в якій створюватиметься новий елемент керування. Це можна зробити або за допомогою коду або візуальним чином.
Перетягуючи елементи з панелі інструментів, ми можемо легко додати нові елементи на форму. Однак такий спосіб досить обмежений, оскільки дуже часто потрібно динамічно створювати (видаляти) елементи на формі.
Для динамічного додавання елементів створимо обробник події завантаження форми у файлі коду:

{
}
Тепер додамо до нього код додавання кнопки на форму:
Private void Form1_Load(object sender, EventArgs e)
{

helloButton.ForeColor = Color.DarkGray;
helloButton.Location = новий пункт(10, 10);

this.Controls.Add(helloButton);
}
Спочатку ми створюємо кнопку та встановлюємо її властивості. Потім, використовуючи метод Controls.Add, ми додаємо її в колекцію елементів форми. Якби ми цього не зробили, ми кнопку не побачили б, оскільки в цьому випадку для нашої форми її просто не існувало б.
За допомогою методу Controls.Remove() можна видалити раніше доданий елемент із форми:
This.Controls.Remove(helloButton);
Хоча в даному випадку як контейнер використовувалася форма, але при додаванні та видаленні елементів з будь-якого іншого контейнера, наприклад, GroupBox, буде застосовуватися ті самі методи.
https://metanit.com/sharp/windowsforms/3.2.php
Елементи GroupBox, Panel та FlowLayoutPanel
GroupBox є спеціальним контейнером, який обмежений від іншої форми кордоном. Він має заголовок, який встановлюється через властивість Text. Щоб зробити GroupBox без заголовка, як значення властивості Text просто встановлюється порожній рядок.
Нерідко цей елемент використовується для групування перемикачів - елементів RadioButton, оскільки дозволяє розмежувати їхні групи.
Елемент Panel представляє панель і, як і GroupBox, об'єднує елементи в групи. Вона може візуально зливатися з іншою формою, якщо вона має те ж значення кольору фону як BackColor, що і форма. Щоб її виділити, можна окрім кольору вказати для елемента кордону за допомогою властивості BorderStyle, яка за умовчанням має значення None, тобто відсутність меж.
Також якщо панель має багато елементів, які виходять за її межі, ми можемо зробити панель, що прокручується, встановивши її властивість AutoScroll в true
Як і форма, GroupBox і Panel мають колекції елементів, і ми також можемо динамічно додавати в ці контейнери елементи. Наприклад, на формі є елемент GroupBox, який має ім'я groupBox1:
Private void Form1_Load(object sender, EventArgs e)
{
Button helloButton = New Button();
helloButton.BackColor = Color.LightGray;
helloButton.ForeColor = Color.Red;
helloButton.Location = новий пункт(30, 30);
helloButton.Text = "Привіт";
groupBox1.Controls.Add(helloButton);
}
Для вказівки розташування елемента в контейнері ми використовуємо структуру Point: new Point(30, 30);, котрої в конструкторі передаємо розміщення по осях Х і Y. Ці координати встановлюються щодо лівого верхнього кута контейнера - тобто в даному випадку елемента GroupBox
При цьому треба враховувати, що контейнером верхнього рівня є форма, а елемент groupBox1 сам знаходиться в колекції елементів форми. І за бажання ми могли б видалити його:
This.Controls.Remove(groupBox1);
FlowLayoutPanel
Елемент FlowLayoutPanel успадкований від класу Panel, і тому успадковує всі його властивості. Однак, додаючи додаткову функціональність. Так, цей елемент дозволяє змінювати позиціонування та компонування дочірніх елементів під час зміни розмірів форми під час виконання програми.
Властивість елемента FlowDirection дозволяє задати напрямок, у якому спрямовані дочірні елементи. За замовчуванням має значення LeftToRight - тобто елементи розташовуватимуться починаючи від лівого верхнього краю. Наступні елементи йдуть праворуч. Ця властивість також може приймати такі значення:
- RightToLeft – елементи розташовуються від правого верхнього кута в ліву сторону
- TopDown - елементи розташовуються від верхнього лівого кута і йдуть вниз
- BottomUp - елементи розташовуються від нижнього лівого кута і йдуть вгору
При розміщенні елементів важливу роль відіграє властивість WrapContents. За промовчанням воно має значення True. Це дозволяє переносити елементи, які не вміщаються у FlowLayoutPanel, на новий рядок або новий стовпець. Якщо воно має значення False, то елементи не переносяться, а до контейнера просто додаються смуги прокручування, якщо властивість AutoScroll дорівнює true.
https://metanit.com/sharp/windowsforms/3.3.php
TableLayoutPanel
Елемент TableLayoutPanel також перевизначає панель і має дочірні елементи управління у вигляді таблиці, де для кожного елемента є своя комірка. Якщо нам хочеться помістити в комірку більше одного елемента, то до цієї комірки додається інший компонент TableLayoutPanel, в який потім вкладаються інші елементи.
Щоб встановити потрібне число рядків стовпців таблиці, ми можемо використовувати властивості Rows та Columns відповідно. Вибравши один із цих пунктів у вікні Properties (Властивості), нам відобразиться наступне вікно для налаштування стовпців та рядків:
У полі Size Type ми можемо вказати розмір стовпців/рядків. Нам доступні три можливі варіанти:
- Absolute: задається абсолютний розмір для рядків або стовпців у пікселях
- Percent: визначається відносний розмір у відсотках. Якщо нам потрібно створити гумовий дизайн форми, щоб її рядки та стовпці, а також елементи керування в осередках таблиці автоматично масштабувалися при зміні розмірів форми, то потрібно використовувати саме цю опцію
- AutoSize: висота рядків і ширина стовпців задається автоматично залежно від розміру найбільшого в рядку або стовпці комірки
Також ми можемо комбінувати ці значення, наприклад один стовпець може бути фіксованим з абсолютною шириною, а інші стовпці можуть мати ширину у відсотках.
У цьому діалоговому вікні ми також можемо додати або видалити рядки та стовпці. У той же час графічний дизайнер Visual Studio не завжди відразу відображає зміни в таблиці - додавання або видалення рядків і стовпців, зміна їх розмірів, тому, якщо змін на формі ніяких не відбувається, треба її закрити і відкрити знову в графічному дизайнері.
Отже, наприклад, у мене є три стовпці і три рядки розмір яких однаковий - 33.33%. У кожну комірку таблиці додано кнопку, яка має властивість Dock=Fill.
Якщо я зміню розміри форми, то автоматично масштабуються і рядки і стовпці разом із кнопками, що в них укладені:
Що досить зручно для створення інтерфейсів, що масштабуються.
У коді динамічно ми можемо змінювати значення стовпців та рядків. Причому всі стовпці представлені типом ColumnStyle, а рядки – типом RowStyle:
TableLayoutPanel1.RowStyles.SizeType = SizeType.Percent;
tableLayoutPanel1.RowStyles.Height = 40;
TableLayoutPanel1.ColumnStyles.SizeType = SizeType.Absolute;
tableLayoutPanel1.ColumnStyles.Width = 50;
Для встановлення розміру ColumnStyle і RowStyle визначено властивість SizeType, яка приймає одне зі значень однойменного перерахування SizeType
Додавання елемента до контейнера TableLayoutPanel має свої особливості. Ми можемо додати його як до наступного вільного осередку або можемо явно вказати осередок таблиці:
Button saveButton = New Button();
// додаємо кнопку в наступний вільний осередок
tableLayoutPanel1.Controls.Add(saveButton);
// додаємо кнопку в комірку (2,2)
tableLayoutPanel1.Controls.Add(saveButton, 2, 2);
В даному випадку додаємо кнопку в комірку, що утворюється на перетині третього стовпця і третього рядка. Щоправда, якщо у нас немає стільки рядків та стовпців, то система автоматично вибере потрібну комірку для додавання.
https://metanit.com/sharp/windowsforms/3.4.php
Розміри елементів та їх позиціонування у контейнері

Позиціювання
Для кожного елемента керування ми можемо визначити властивість Location, яка визначає координати верхнього лівого кута елемента щодо контейнера. При перенесенні елемента з панелі інструментів на форму ця властивість встановлюється автоматично. Однак потім у вікні властивостей ми можемо вручну виправити координати положення елемента:
Також ми можемо встановити позицію елемента у коді:
1
2
3
4
private void Form1_Load(object sender, EventArgs e)
{
button1.Location = новий Point(50, 50);
}
Встановлення розмірів
За допомогою властивості Size можна встановити розміри елемента:
Додаткові властивості MaximumSize та MinimumSize дозволяють обмежити мінімальний та максимальний розміри.
Встановлення властивостей у коді:
1
2
3
4
button1.Size = new Size ( Width = 50, Height = 25 );
// встановлення властивостей окремо
button1.Width = 100;
button1.Height = 35;
Властивість Anchor
Додаткові можливості щодо позиціонування елемента дозволяє визначити властивість Anchor. Ця властивість визначає відстань між однією із сторін елемента та стороною контейнера. І якщо при роботі з контейнером ми його розтягуватимемо, то разом з ним буде розтягуватися і вкладений елемент.
За замовчуванням у кожного елемента, що додається, ця властивість дорівнює Top, Left:
Це означає, що якщо ми будемо розтягувати форму вліво або вгору, то елемент збереже відстань від лівої та верхньої межі елемента до меж контейнера, як виступає форма.
Ми можемо задати чотири можливі значення для цієї властивості або їх комбінацію:
Right

При цьому слід зазначити, що ця властивість враховує відстань до меж контейнера, а не форми. Тобто, якщо у нас на формі є елемент Panel, а на Panel розташована кнопка, то на кнопку впливатиме зміна меж Panel, а не форми. Розтягування форми в цьому випадку впливатиме лише, якщо воно впливає на контейнер Panel.

Щоб задати цю властивість у коді, треба використовувати перелік AnchorStyles:

1
2
3
button1.Anchor = AnchorStyles.Left;
// задаємо комбінацію значень
button1.Anchor = AnchorStyles.Left | AnchorStyles.Top;
Властивість Dock
Властивість Dock дозволяє прикріпити елемент до певної сторони контейнера. За замовчуванням воно має значення None, але також дозволяє встановити ще п'ять значень:

Top: елемент притискається до верхньої межі контейнера
Bottom: елемент притискається до нижньої межі контейнера
Left: елемент притискається до лівої сторони контейнера
Right: елемент прикріплюється до правої сторони контейнера
Fill: елемент заповнює весь простір контейнера

https://metanit.com/sharp/windowsforms/3.5.php
Панель вкладок TabControl та SplitContainer

TabControl

Елемент TabControl дозволяє створити елемент керування з кількома вкладками. І кожна вкладка зберігатиме деякий набір інших елементів керування, як кнопки, текстові поля та ін. Кожна вкладка представлена класом TabPage.
Щоб налаштувати вкладки елемента TabControl, використовуємо властивість TabPages. При перенесенні елемента TabControl з панелі інструментів на форму за замовчуванням створюються дві вкладки – tabPage1 та tabPage2. Змінимо їх відображення за допомогою властивості TabPages:
Нам відкриється вікно редагування/додавання та видалення вкладок:
Кожна вкладка являє собою панель, на яку ми можемо додати інші елементи керування, а також заголовок, за допомогою якого ми можемо перемикатися по вкладках. Текст заголовка задається за допомогою Text.
Керування вкладками у коді
Для додавання нової вкладки нам треба її створити та додати до колекції tabControl1.TabPages за допомогою методу Add:
//додавання вкладки
TabPage newTabPage = new TabPage();
newTabPage.Text = "Континенти";
tabControl1.TabPages.Add(newTabPage);
Видалення так само просто:
// Видалення вкладки
// за індексом
tabControl1.TabPages.RemoveAt(0);
// по об'єкту
tabControl1.TabPages.Remove(newTabPage);
Отримуючи в колекції tabControl1.TabPages потрібну вкладку індексу, ми можемо їй легко маніпулювати:
//Зміна властивостей
tabControl1.TabPages.Text = "Перша вкладка";
SplitContainer
Елемент SplitContainer дозволяє створювати дві розділені сплітером панелі. Змінюючи положення сплітера можна змінити розміри цих панелей.
Використовуючи властивість Orientation, можна встановити горизонтальне або вертикальне відображення сплітера на форму. В даному випадку ця властивість набуває значень Horisontal і Vertical відповідно.
У разі, коли треба заборонити зміну положення спліттера, можна привласнити властивості IsSplitterFixed значення true. Таким чином, сплітер виявиться фіксованим, і ми не зможемо змінити його положення.
За умовчанням при розтягуванні форми або її звуженні також змінюватиметься розмір обох панелей сплітконтейнера. Однак ми можемо закріпити за однією панеллю фіксовану ширину (при вертикальній орієнтації спліттера) або висоту (при горизонтальній орієнтації спліттера). Для цього нам потрібно встановити у елемента SplitContainer властивість FixedPanel. Як значення воно набуває панелі, яку треба зафіксувати:
Щоб змінити положення сплітера в коді, ми можемо керувати властивістю SplitterDistance, яка задає положення спліттера в пікселях від лівого або верхнього краю SplitContainer. А за допомогою властивості SplitterIncrement можна задати крок, на який переміщатиметься спліттер під час руху його за допомогою клавіш-стрілок.
Щоб приховати одну з двох панелей, ми можемо встановити властивість Panel1Collapsed або Panel2Collapsed у true

https://metanit.com/sharp/windowsforms/4.1.php
Елементи управління
Елементи управління є візуальними класами, які отримують введені користувачем дані і можуть ініціювати різні події. Всі елементи управління успадковуються від класу Control і тому мають низку загальних властивостей:
Anchor: Визначає, як елемент буде розтягуватись

BackColor: Визначає фоновий колір елемента

BackgroundImage: Визначає фонове зображення елемента

ContextMenu: Контекстне меню, яке відкривається при натисканні на елемент правою кнопкою миші. Задається за допомогою елемента ContextMenu

Cursor: Уявляє, як відображатиметься курсор миші при наведенні на елемент

Dock: Задає розташування елемента на формі

Enabled: Визначає, чи буде доступний елемент для використання. Якщо ця властивість має значення False, елемент блокується.

Font: Встановлює шрифт тексту для елемента

ForeColor: Визначає колір шрифту

Location: Визначає координати верхнього лівого кута елемента керування

Name: Ім'я елемента керування

Size: Визначає розмір елемента

Width: ширина елемента

Height: висота елемента

TabIndex: Визначає порядок обходу елемента натискання клавіші Tab

Tag: Дозволяє зберігати значення, асоційоване з цим елементом управління

Кнопка
Найчастіше використовуваним елементом управління є кнопка. Обробляючи подію натискання кнопки, ми можемо робити ті чи інші дії.
При натисканні на кнопку на формі в редакторі Visual Studio ми за замовчуванням потрапляємо до коду обробника події Click, який буде виконуватися при натисканні:
Private void button1_Click(object sender, EventArgs e)
{
MessageBox.Show("Hello World");
}
Оформлення кнопки
Для керування зовнішнім відображенням кнопки можна використовувати властивість FlatStyle. Воно може приймати такі значення:
Flat - Кнопка має плоский вигляд.

Popup - Кнопка набуває об'ємного вигляду при наведенні на неї покажчика, в інших випадках вона має плоский вигляд

Standard - Кнопка має об'ємний вигляд (використовується за умовчанням)

System - Вид кнопки залежить від операційної системи

Зображення на кнопці
Як і для багатьох елементів керування, для кнопки можна задавати зображення за допомогою властивості BackgroundImage. Однак ми можемо також керувати розміщенням тексту та зображення на кнопках. Для цього необхідно використовувати властивість TextImageRelation. Воно набуває наступних значень:
Overlay: текст накладається на зображення

ImageAboveText: зображення знаходиться над текстом

TextAboveImage: текст розміщується над зображенням

ImageBeforeText: зображення знаходиться перед текстом

TextBeforeImage: текст розміщується перед зображенням

Наприклад, встановимо для кнопки зображення. Для цього виберемо кнопку і у вікні властивостей натиснемо на полі Image (не плутати з BackgroundImage). Нам відкриється діалогове вікно встановлення зображення:
У цьому вікні виберемо опцію Local Resource і натиснемо кнопку Import, після чого нам відкриється діалогове вікно для вибору файлу зображення.
Після вибору зображення ми можемо встановити властивість ImageAlign, яка керує позиціонуванням зображення на кнопці:
Нам доступно 9 варіантів, за допомогою яких ми можемо прикріпити зображення до певної сторони кнопки. Залишимо тут значення за замовчуванням – MiddleCenter, тобто позиціонування по центру.
Потім перейдемо до властивості TextImageRelation і встановимо для нього значення ImageBeforeText. У результаті ми отримаємо кнопку, де відразу після зображення йде напис на кнопці:
Клавіші швидкого доступу
При використанні форм при використанні клавіатури дуже зручно користуватися клавішами швидкого доступу. При натисканні на клавіатурі комбінації клавіш At+ деякий символ, буде викликатись певна кнопка. Наприклад, задамо для деякої кнопки властивість Text рівне &Аватар. Перший знак – амперсанд – визначає ту літеру, яка буде підкреслена. У цьому випадку напис буде виглядати як Аватар. І тепер щоб викликати подія Clickнам достатньо натиснути на комбінацію клавіш Alt+А.
Стандартні кнопки
Форма, на якій розміщуються всі елементи керування, має властивості, що дозволяють призначати кнопку за замовчуванням та кнопку скасування.
Так, властивість форми AcceptButton дозволяє призначати кнопку за замовчуванням, яка спрацьовуватиме за натисканням клавіші Enter.
Аналогічно працює властивість форми CancelButton, яка призначає кнопку скасування. Призначивши таку кнопку, ми можемо викликати її натискання, натиснувши клавішу Esc.

https://metanit.com/sharp/windowsforms/4.2.php
Label
Для відображення простого тексту на формі, доступного тільки для читання, використовується елемент Label. Щоб задати текст мітки, потрібно встановити властивість Text елемента.
LinkLabel
Особливий тип позначок представляють елементи LinkLabel, які призначені для виведення посилань, які аналогічні до посилань, розміщених на стандартних веб-сторінок.
Властивість ActiveLinkColor задає колір посилання при натисканні

Властивість LinkColor задає колір посилання до натискання, за яким ще не було переходів

Властивість VisitedLinkColor задає колір посилання, яким вже були переходи

Крім кольору посилання для даного елемента ми можемо задати властивість LinkBehavior, яка керує поведінкою посилання. Ця властивість набуває чотирьох можливих значень:
SystemDefault: для посилання встановлюються системні налаштування

AlwaysUnderline: посилання завжди підкреслюється

HoverUnderline: посилання підкреслюється тільки при наведенні на неї курсору миші

NeverUnderline: посилання ніколи не наголошується

За замовчуванням, весь текст на даному елементі вважається посиланням. Однак, за допомогою властивості LinkArea ми можемо змінити область посилання. Наприклад, ми не хочемо включати на заслання перші шість символів. Для цього задаємо підсвойство Start:
Щоб виконати перехід по посиланню натискання на неї, треба додатково написати код. Цей код повинен обробляти подію LinkClicked, яка має елемент LinkLabel. Наприклад, нехай у нас на формі є елемент посилання, що називається linkLabel1 і який містить деяке посилання:
Public partial class Form1: Form
{
Public Form1()
{
InitializeComponent();
// задаємо обробник події
linkLabel1.LinkClicked += linkLabel1_LinkClicked;
}
Private void linkLabel1_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
{
System.Diagnostics.Process.Start("http://metanit.com");
}
}
Метод System.Diagnostics.Process.Start() відкриє це посилання у веб-браузері, встановленому в системі браузером за промовчанням.

https://metanit.com/sharp/windowsforms/4.3.php
Текстове поле TextBox
Для введення та редагування тексту призначені текстові поля – елемент TextBox. Так само як і елемент Label текст елемента TextBox можна встановити або отримати за допомогою властивості Text.
За умовчанням при перенесенні елемента з панелі інструментів створюється текстове поле для рядка. Для відображення великих обсягів інформації в текстовому полі потрібно використовувати властивості Multiline і ScrollBars. При установці для властивості Multiline значення true всі надлишкові символи, які виходять за межі поля, будуть переноситися на новий рядок.
Крім того, можна зробити прокручування текстового поля, встановивши для його властивості ScrollBars одне із значень:
None: без прокручування (за замовчуванням)

Horizontal: створює горизонтальне прокручування при довжині рядка, що перевищує ширину текстового поля

Vertical: створює вертикальне прокручування, якщо рядки не розміщуються в текстовому полі

Both: створює вертикальну та горизонтальну прокручування

Автозаповнення текстового поля
Елемент TextBox має достатні можливості для створення автозаповнюваного поля. Для цього нам треба прив'язати властивість AutoCompleteCustomSourceелемента TextBox до деякої колекції, з якої беруться дані заповнення поля.
Отже, додамо на форму текстове поле та пропишемо в код події завантаження наступні рядки:
Public partial class Form1: Form
{
Public Form1()
{
InitializeComponent();
AutoCompleteStringCollection source = new AutoCompleteStringCollection()
{
"Ковальів",
"Іванів",
"Петрів",
"Кустів"
};
textBox1.AutoCompleteCustomSource = source;
textBox1.AutoCompleteMode = AutoCompleteMode.SuggestAppend;
textBox1.AutoCompleteSource = AutoCompleteSource.CustomSource;
}
}

Режим автодоповнення, представлений властивістю AutoCompleteMode, має декілька можливих значень:
None: відсутність автодоповнення

Suggest: пропонує варіанти для введення, але не доповнює

Append: доповнює введене значення до рядка зі списку, але не пропонує варіанти для вибору

SuggestAppend: одночасно пропонує варіанти для автодоповнення, і доповнює введене користувачем значення

Перенесення за словами
Щоб текст в елементі TextBox переносився за словами, потрібно встановити властивість WordWrapрівним true. Тобто якщо одне слово не вміщується на рядку, то переноситься на наступний. Ця властивістьпрацюватиме лише для багаторядкових текстових полів.
Введення пароля
Також цей елемент має властивості, які дозволяють зробити з нього поле для введення пароля. Так, для цього треба використовувати PasswordChar та UseSystemPasswordChar.
Властивість PasswordChar за замовчуванням не має значення, якщо ми встановимо як нього якийсь символ, цей символ буде відображатися при введенні будь-яких символів у текстове поле.
Властивість UseSystemPasswordChar має схожу дію. Якщо ми встановимо його значення в true, замість введених символів у текстовому полі буде відображатися знак пароля, прийнятий у системі, наприклад, точка.
Подія TextChanged
З усіх подій елемента TextBox слід зазначити подію TextChanged, яка спрацьовує при зміні тексту елемента. Наприклад, помістимо на форму крім текстового поля мітку та зробимо так, щоб при зміні тексту в текстовому полі також змінювався текст на мітці:
Public partial class Form1: Form
{
Public Form1()
{
InitializeComponent();
TextBox1.TextChanged += textBox1_TextChanged;
}
Private void textBox1_TextChanged(object sender, EventArgs e)
{
label1.Text = textBox1.Text;
}
}

https://metanit.com/sharp/windowsforms/4.4.php
Елемент MaskedTextBox
Елемент MaskedTextBox насправді представляє звичайне текстове поле. Однак цей елемент дозволяє контролювати введення користувача і перевіряти його автоматично на наявність помилок.
Щоб контролювати символи, що вводяться в поле, треба задати маску. Для завдання маски можна використовувати такі символи:
0: Дозволяє вводити лише цифри

9: Дозволяє вводити цифри та пробіли

#: Дозволяє вводити цифри, пробіли та знаки "+" та "-"

L: Дозволяє вводити лише літерні символи

?: Дозволяє вводити додаткові необов'язкові літерні символи

A: Дозволяє вводити літерні та цифрові символи

.: Задає позицію роздільника цілої та дробової частини.

,: Використовується для розділення розрядів у цілій частині числа

:: Використовується в часових проміжках - розділяє години, хвилини та секунди

/: Використовується для поділу дат

$: Використовується як символ валюти

Щоб встановити маску, треба встановити властивість Mask елемента. Знайшовши цю властивість у вікні властивостей (Porperties), натиснемо на нього і відобразиться вікно для завдання одного зі стандартних шаблонів маски. Зокрема, ми можемо вибрати Phone number (Телефонний номер), який передбачає введення в текстове поле лише телефонного номера:
Тепер при запуску ми зможемо ввести в текстове поле лише цифри, отримавши телефонний номер.
Тепер зробимо свою маску. Наприклад, створимо маску для введення ініціалів імені та по батькові та прізвищ обмеженої довжини у текстове поле. Для цього надамо властивості Mask значення L.L.L?????????. Тоді введення в текстове поле буде виглядати так:
Даний елемент також представляє ряд властивостей, які можна використовувати для управління введенням. Так, властивість BeepOnError при встановленні значення true подає звуковий сигналпід час введення неправильного символу.
Властивість HidePromptOnLeave при установці в true при втрати текстового поля фокусу приховує, вказані в PromptChar
Властивість PromptChar вказує на символ, який відображається на місці введення символів. За промовчанням стоїть знак підкреслення.
Властивість AsciiOnly при значенні true дозволяє вводити тільки asci-символи, тобто символи діапазону A-Z і a-z.

https://metanit.com/sharp/windowsforms/4.5.php
Елементи Radiobutton та CheckBox
CheckBox
Елемент CheckBox або прапорець призначений для встановлення одного з двох значень: відмічено або не позначено. Щоб відзначити прапорець, треба встановити його властивості Checked значення true.
Крім властивості Checked у елемента CheckBox є властивість CheckState, яка дозволяє задати для прапорця один з трьох станів - Checked (відзначений), Indeterminate (прапорець не визначений - відзначений, але знаходиться в неактивному стані) і Unchecked (не відмічений)
Також слід зазначити властивість AutoCheck – якщо вона має значення false, то ми не можемо змінювати стан прапорця. За промовчанням воно має значення true.
При зміні стану прапорця він генерує подію CheckedChanged. Обробляючи цю подію, ми можемо отримувати змінений прапорець і робити певні дії:
Private void checkBox_CheckedChanged(object sender, EventArgs e)
{
CheckBox checkBox = (CheckBox) sender; // Наводимо відправника до елемента типу CheckBox
if (checkBox.Checked == true)
{
MessageBox.Show("Прапорець" + checkBox.Text + "тепер відзначений");
}
else
{
MessageBox.Show("Прапорець" + checkBox.Text + "тепер не відзначений");
}
}
Radiobutton
На елемент CheckBox схожий елемент RadioButton або перемикач. Перемикачі розташовуються групами, і включення одного перемикача означає відключення решти.
Щоб встановити у перемикача увімкнений стан, треба привласнити його властивості Checked значення true.
Для створення групи перемикачів, з яких можна було б вибирати, треба помістити кілька перемикачів у якийсь контейнер, наприклад, елементи GroupBox або Panel. Перемикачі. що знаходяться в різних контейнерах, будуть відноситися до різних груп:
Так само ми можемо перехоплювати перемикання перемикачів у групі, обробляючи подію CheckedChanged. Зв'язавши кожен перемикач групи з одним обробником цієї події, ми зможемо отримати той перемикач, який обраний в даний момент:
Private void radioButton_CheckedChanged(object sender, EventArgs e)
{
// Наводимо відправника до елемента типу RadioButton
RadioButton radioButton = (RadioButton)sender;
if (radioButton.Checked)
{
MessageBox.Show("Ви вибрали" + radioButton.Text);
}
}

https://metanit.com/sharp/windowsforms/4.6.php
ListBox
Елемент ListBox є простим списком. Ключовою властивістю цього елемента є властивість Items, яка й зберігає набір всіх елементів списку.
Елементи до списку можуть бути додані як під час розробки, так і програмним способом. У Visual Studio у вікні Properties (Властивості) елемента ListBox ми можемо знайти властивість Items. Після подвійного клацання на властивість нам відобразиться вікно для додавання елементів до списку:
У порожньому полі ми вводимо по одному елементу списку - по одному на кожному рядку. Після цього всі додані нами елементи виявляться у списку, і ми зможемо ними керувати:
Програмне керування елементами у ListBox
Додавання елементів
Отже, всі елементи списку входять у властивість Items, яка є колекцією. Для додавання нового елемента в цю колекцію, а значить і до списку, треба використовувати метод Add, наприклад: listBox1.Items.Add("Новий елемент"); При використанні цього методу кожен елемент, що додається, додається в кінець списку.
Можна додати кілька елементів, наприклад, масив. Для цього використовується метод AddRange:
String countries = ("Бразилія", "Аргентина", "Чилі", "Уругвай", "Колумбія");
listBox1.Items.AddRange(countries);
Вставка елементів
На відміну від простого додавання вставка здійснюється за певним індексом списку за допомогою методу Insert:
ListBox1.Items.Insert(1, "Парагвай");
В даному випадку вставляємо елемент на другу позицію у списку, тому що відлік позицій починається з нуля.
Видалення елементів
Для видалення елемента за текстом використовується метод Remove:
ListBox1.Items.Remove("Чилі");
Щоб видалити елемент за його індексом у списку, використовується метод RemoveAt:
ListBox1.Items.RemoveAt(1);
Крім того, можна очистити відразу весь список, застосувавши метод Clear:
ListBox1.Items.Clear();
Доступ до елементів списку
Використовуючи індекс елемента, можна сам елемент у списку. Наприклад, отримаємо перший елемент списку:
String firstElement = listBox1.Items;
Метод Count дозволяє визначити кількість елементів у списку:
Int number = listBox1.Items.Count();
Виділення елементів списку
При виділенні елементів списку ми можемо ними керувати як через індекс, так і через виділений елемент. Отримати виділені елементи можна за допомогою таких властивостей елемента ListBox:
SelectedIndex: повертає або встановлює номер виділеного списку. Якщо виділені елементи відсутні, тоді властивість має значення -1

SelectedIndices: повертає або встановлює колекцію виділених елементів у вигляді набору їх індексів

SelectedItem: повертає або встановлює текст виділеного елемента

SelectedItems: повертає або встановлює виділені елементи у вигляді колекції

За промовчанням список підтримує виділення одного елемента. Щоб додати можливість виділення кількох елементів, необхідно встановити у його властивості SelectionMode значення MultiSimple.
Щоб виділити елемент програмно, треба застосувати метод SetSelected(int index, bool value), де index – номер виділеного елемента. Якщо другий параметр - value має значення true, то елемент за вказаним індексом виділяється, якщо false, то виділення навпаки приховується:
ListBox1.SetSelected(2, true); // буде виділено третій елемент
Щоб зняти виділення з усіх виділених елементів, використовується метод ClearSelected.
Подія SelectedIndexChanged
З усіх подій елемента ListBox треба відзначити насамперед подію SelectedIndexChanged, що виникає при зміні виділеного елемента:
Public partial class Form1: Form
{
Public Form1()
{
InitializeComponent();
String countries = ("Бразилія", "Аргентина", "Чилі", "Уругвай", "Колумбія");
listBox1.Items.AddRange(countries);
listBox1.SelectedIndexChanged += listBox1_SelectedIndexChanged;
}
Void listBox1_SelectedIndexChanged(object sender, EventArgs e)
{
string selectedCountry = listBox1.SelectedItem.ToString();
MessageBox.Show(selectedCountry);
}
}
У цьому випадку на вибір елемента списку відображатиметься повідомлення з виділеним елементом.

comboBox1.Items.AddRange(new string ("Уругвай", "Еквадор"));
// Додаємо один елемент на певну позицію
comboBox1.Items.Insert(1, "Болівія");
При додаванні за допомогою методів Add/AddRange всі нові елементи розміщуються в кінці списку. Однак якщо ми задамо ComboBox властивість Sorted рівним true, тоді при додаванні буде автоматично сортуватися.

Видалення елементів:

// видаляємо один елемент
comboBox1.Items.Remove("Аргентина");
// видаляємо елемент за індексом
comboBox1.Items.RemoveAt(1);
// Видаляємо всі елементи
comboBox1.Items.Clear();
Ми можемо отримати елемент за індексом та робити з ним різні дії. Наприклад, змінити його:

ComboBox1.Items = "Парагвай";
Налаштування оформлення ComboBox
За допомогою низки властивостей можна налаштувати стиль оформлення компонента. Так, властивість DropDownWidth задає ширину списку, що випадає. За допомогою властивості DropDownHeight можна встановити висоту списку, що випадає.

Ще одна властивість MaxDropDownItems дозволяє задати число видимих елементів списку - від 1 до 100. За замовчуванням це число 8.

Інша властивість DropDownStyle задає стиль ComboBox. Воно може приймати три можливі значення:

Dropdown: використовується за замовчуванням. Ми можемо відкрити список варіантів, що випадає, при введенні значення в текстове поле або натиснувши на кнопку зі стрілкою в правій частині елемента, і нам відобразиться власне список, в якому можна вибрати можливий варіант
DropdownList: щоб відкрити список, що випадає, треба натиснути на кнопку зі стрілкою в правій стороні елемента
Simple: ComboBox представляє просте текстове поле, в якому ми можемо використовувати клавіші клавіатури вгору/вниз для переходу між елементами.

Подія SelectedIndexChanged
Найбільш важливою подією для ComboBox також є подія SelectedIndexChanged, що дозволяє відстежити вибір елемента у списку:

Public partial class Form1: Form
{
Public Form1()
{
InitializeComponent();

ComboBox1.SelectedIndexChanged += comboBox1_SelectedIndexChanged;
}

Void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
{
string selectedState = comboBox1.SelectedItem.ToString();
MessageBox.Show(selectedState);
}
}
Тут також властивість SelectedItem буде посилатися на вибраний елемент.

Тепер настав час створити наш перший віконний додаток.
Важливі теми, що розглядаються в цій частині:
Додаток, що розробляється, буде невеликою формою, що повторює ідею давним-давно придуманої програми: на формі буде міститися питання «». При спробі наведення вказівника миші на кнопку « Так звичайно!вікно буде тікати від нас. Натискання на кнопку « Ніне буде нічим обмежено.

Створюючи цю програму, ми розглянемо основні принципи створення віконних додатків C#, і навіть методи реалізації з допомогою них будь-яких кінцевих цілей: у разі - це кумедно тікає вікно.

Створіть новий проект, як тип шаблону встановіть програму Windows Forms, як показано на малюнку 1:
1. Створення нового проекту.
Назвіть проект RandWindowта натисніть кнопку ОК.

Робоче вікно MS Visual Studioмістить наступні допоміжні вікна (рис. 2).

Малюнок 2. Допоміжні вікна.
На малюнку цифрам зазначено:

Вікно Toolbox(Панель елементів управління) - елементи управління ви можете розмістити на формі, що створюється.

Вікно Solution Explorer(Оглядач рішень) - тут ви зможете побачити такі вузли: Properties- Налаштування проекту, Links(Посилання) - підключені до проекту бібліотеки, а також створені та підключені до проекту файли вихідних кодів (з розширенням .cs) та підключені до проекту форми (наприклад, Form1).

Вікно Class View(Вікно класів) – тут представлені усі створені у програмі класи.

Вікно Properties(Властивості) - вибравши будь-який елемент керування або навіть форму, ви зможете побачити всі параметри даного об'єкта, а також змінити значення, встановлені за замовчуванням.

Створення віконних програм зводиться до створення всіх необхідних діалогових вікон, а також розміщення на них необхідних елементів. Надалі ми налаштовуємо обробку подій, створюваних користувачем, та налаштовуємо технічні аспекти роботи програми. У нашому випадку спочатку розмістимо всі необхідні елементи керування на головній формі, після чого додамо обробник події переміщення миші та обробку натискання кнопок.

Додавання нових елементів керування на форму

Отже, після того, як ви ввели ім'я проекту, встановили необхідний шаблон і натиснули кнопку ОК, MS Visual Studioавтоматично створить каркас віконної програми, після чого ми зможемо додати нові віконні елементи.

Для цього необхідно перетягнути необхідний віконний елемент із вікна інструментів ( ToolBox).

Нашому вікну буде потрібно 2 елемента поля для введення, в які ми виводитимемо координати покажчика миші, що полегшить нам розуміння роботи програми.

У центрі вікна буде напис, який ми створимо за допомогою елемента Label.
Знизу будуть розташовані 2 кнопки.

Трохи розтягніть заготовку вікна. Якщо ви натиснете на нього правою кнопкою, відкриється контекстне меню. У ньому натисніть пункт властивості, після чого ви зможете вивчити різні параметри вікна, які ви можете змінити. На малюнку 3 зображені найнеобхідніші властивості:
Малюнок 3. Різні властивості вікна (форми) C# .NET.
Трохи розтягніть заготовку вікна та додайте всі необхідні елементи. На малюнку 4 ви можете побачити їх у вікні ToolBox:

Малюнок 4. Перетягуйте необхідні елементи з вікна Toolbox на форму, що створюється.

Перейдіть до властивостей рядка Label1де зміните текст на « Ви прагнете зробити світ кращим?». Також змініть тип шрифту, для цього знайдіть властивість Font(Рис. 5).
Рисунок 5. Властивість Font елемента Label.
Після чого встановіть тип шрифту Tahoma, ширину шрифту Boldта розмір рівний 16 (Рис. 6).

Малюнок 6. Налаштування шрифту.
Далі змініть текст на кнопках, використовуючи властивість Text.

Отримана заготовка вікна програми виглядатиме так (рис. 7).

Малюнок 7. Форма виглядатиме так.

Технічна частина роботи програми

Спочатку ми додамо обробник події переміщення миші та реалізуємо виведення її координат xі yу два створені поля введення.
Далі ми створимо функції обробники клацання по кожній із клавіш миші (особливо старанні користувачі все ж таки зможуть потрапити по кнопці « Так звичайно!»).
Далі ми додамо код, який реалізує випадкове переміщення вікна в тому випадку, якщо курсор наблизиться до кнопки « Так звичайно!».

Визначення переміщення вказівника миші формою

Клацніть безпосередньо на частини форми програми ( НЕодному з елементів).

Тепер перейдіть до властивостей форми за допомогою клацання правої кнопки миші -> контекстне меню властивості.

Тепер необхідно перейти до списку можливих подій, які можуть одержувати це вікно. Для цього клацніть на кнопці « Event»(Події), як показано на малюнку 8:
8. Перехід до списку можливих подій.
Коли користувач пересуває вказівник миші на вікно, операційна системапосилає повідомлення програмі з поточними координатами покажчика. Вони нам і потрібні.

Щоб призначити обробник цієї події, знайдіть рядок MouseMove(мал. 9), після чого зробіть подвійне клацання в полі праворуч від неї – автоматично додасться обробник події руху миші та додасться функція Form1_MouseMoveу коді нашої програми.
Рисунок 9. Після подвійного клацання праворуч від MouseMove з'явиться цей рядок, і автоматично здійсниться перехід до коду функції-обробника цієї події.
Додайте в цю функцію 2 рядки, щоб її код став виглядати так.

/*http://сайт, Anvi*/ private void Form1_MouseMove(object sender, MouseEventArgs e) ( // перекладаємо координату X у рядок і записує в поля введення textBox1.Text = e.X.ToString(); // переводимо координату Y в рядок та записує в поля введення textBox2.Text = e.Y.ToString();
Ця функція, що обробляє подію переміщення покажчика миші над формою, отримує 2 параметра: об'єкт відправник та екземпляр класу MouseEventsArgs, що містить інформацію про координати вказівника миші та інші поточні властивості.

textBox1і textBox2це екземпляри класу textbox, що реалізують керування нашими елементами поля для введення.

Член даних екземплярів Textдозволяє встановити текст у даних полях.

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

Тепер повернемось до заготівлі нашої форми. Для цього клацніть на відповідній закладці (Form1.cs [Конструктор]), як показано на малюнку 10:
Малюнок 10. Перехід до конструктора форм C#.
Зробіть подвійне клацання по першій кнопці: Visual Studioавтоматично додасть код обробки цієї кнопки під час натискання.

Додайте наступні рядки коду:

/*http://сайт, Anvi*/ private void button1_Click(object sender, EventArgs e) ( // Вивести повідомлення з текстом "Ви завзяті" MessageBox.Show("Ви завзяті!!"); // Завершити додаток Application. Exit(); )
Тепер знову поверніться до конструктора і додайте другу кнопку також за допомогою подвійного клацання по ній.

/*http://сайт, Anvi*/ private void button2_Click(object sender, EventArgs e) ( // Вивести повідомлення, з текстом "Ми не сумнівалися у вашій байдужості" // другий параметр - заголовок вікна повідомлення "Увага" // MessageBoxButtons.OK - тип кнопки, що розміщується на формі повідомлення // MessageBoxIcon.Information - тип повідомлення - буде мати іконку "інформація" і відповідний звуковий сигнал MessageBox.Show("Ми не сумнівалися у вашій байдужості","Увага", MessageBoxButtons.OK, MessageBoxIcon.Information);
Як бачите, ми трохи ускладнили код виклику вікна-повідомлення, щоб продемонструвати те, як воно працює, більш детально. Усі параметри, що передаються в функцію Showзакоментовані у вихідному коді.

Тепер нам залишилося лише реалізувати переміщення вікна в той момент, коли миша наближається до кнопки. Так звичайно».

Для цього ми додамо код до функції:

private voidForm1_MouseMove(object sender, MouseEventArgs)

Принцип дуже простий: отримуючи координати руху миші, ми перевіряємо, чи не входять вони у квадрат, що окреслює нашу кнопку з невеликим запасом. Якщо так, то ми генеруємо 2 випадкові числа, які будуть використані для переміщення вікна.

Ми б могли просто відстежувати повідомлення про наведення покажчика миші на кнопку, але воно приходить з помітною затримкою, у зв'язку з чим користувач без особливих зусиль натисне на кнопку так, тому ми просто обчислюватимемо потрапляння курсору в зону навколо кнопки.

Також нам знадобиться оголосити дещо " робітниківзмінних, які ми будемо надалі використовувати.

Генерація випадкових чисел

Клас Randomв C#є генератор псевдовипадкових чисел - тобто. цей клас відповідає за видачу послідовності чисел, що відповідає певним статистичним критеріям випадковості.

Random rnd = новий Random();

Тут ми оголосили екземпляр класу Random (rnd), за допомогою якого ми генеруватимемо випадкові числа. Надалі ми будемо використовувати код, виду rnd.Next(діапазон_генерації) або rnd.Next(від до -1 ) для генерації випадкового числа.

Також ми оголосимо ще кілька змінних, частина з яких одразу буде ініціалізована.

Windows.Forms.SystemInformation.PrimaryMonitorSize.Width; int _h = System.Windows.Forms.SystemInformation.PrimaryMonitorSize.Height;
tmp_locationоголошується у тому, щоб у майбутньому тимчасово зберігати поточне становище вікна.

Також нам слід подумати про те, що при випадковому переміщенні наше вікно може вийти далеко за межі екрана.

Щоб визначити роздільну здатність екрану C# .NET , ми будемо використовувати:

/*http://сайт, Anvi*/ System.Windows.Forms.SystemInformation.PrimaryMonitorSize
_hі _wзберігатимуть у собі розміри екрана користувача, які визначаються за її ініціалізації.
Тепер код цієї функції буде виглядати так:

/*http://esate.ru, Anvi*/ private void Form1_MouseMove(object sender, MouseEventArgs e) ( // переводимо координату X у рядок і записує в поля введення textBox1.Text = e.X.ToString(); // переводимо координату Y в рядок і записує в поля введення textBox2.Text = e.Y.ToString();// якщо координата по осі X і по осі Y лежить в квадраті if, що окреслюється навколо кнопки "так, звичайно" (e.X > 80 && e.X 100 && e.Y (_w - this.Width / 2) ||tmp_location.Y (_h - this.Height / 2)) ( // новими координатами стане центр вікна tmp_location.X = _w / 2; tmp_location.Y = _h / 2; ) // оновлюємо становище вікна, на нове згенероване this.Location = tmp_location; ) )
Ось, власне, і все. Відкомпелювавши програму, можете спробувати натиснути на кнопку "Так, звичайно". Це буде дуже важко.

Останнє оновлення: 31.10.2015

Для створення графічних інтерфейсів за допомогою платформи .NET застосовуються різні технології - Window Forms, WPF, програми для магазину Windows Store (для ОС Windows 8/8.1/10). Однак найбільш простою та зручною платформою досі залишається Window Forms або форми. Даний посібник ставить за мету дати розуміння принципів створення графічних інтерфейсів за допомогою технології WinForms і роботи основних елементів управління.

Створення графічної програми

Для створення графічного проекту нам знадобиться середовище розробки Visual Studio. Оскільки найбільш поширена поки що версія Visual Studio 2013, то для цього посібника я використовуватиму безкоштовну версію даного середовища Visual Studio Community 2013яку можна знайти на сторінці https://www.visualstudio.com/en-us/products/visual-studio-community-vs.aspx.

Після встановлення середовища та всіх його компонентів, запустимо Visual Studio і створимо проект графічної програми. Для цього в меню виберемо пункт File (Файл) і підменю виберемо New - > Project (Створити - > Проект). Після цього перед нами відкриється діалогове вікно створення нового проекту:

У лівій колонці виберемо Windows Desktop, а в центральній частині серед типів проектів - тип Windows Forms Applicationі дамо йому якесь ім'я в полі внизу. Наприклад, назвемо його HelloApp. Після цього натискаємо OK.

Після цього Visual Studio відкриє проект із створеними за замовчуванням файлами:

Більшість простору Visual Studio займає графічний дизайнер, який містить форму майбутньої програми. Поки що вона порожня і має лише заголовок Form1. Праворуч знаходиться вікно файлів рішення/проекту – Solution Explorer (Оглядач рішень). Там і знаходяться всі пов'язані з нашим додатком файли, у тому числі файли форми Form1.cs.

Внизу праворуч знаходиться вікно властивостей – Properties. Так як у мене в даний момент вибрано форму як елемент управління, то в цьому полі відображаються властивості, пов'язані з формою.

Тепер знайдемо у цьому вікні властивість форми Text і змінимо його значення будь-яке інше:

Таким чином, ми змінили заголовок форми. Тепер перенесемо на поле якийсь елемент керування, наприклад, кнопку. Для цього знайдемо у лівій частині Visual Studio вкладку Toolbox (Панель інструментів). Натисніть на цю вкладку, і у нас відкриється панель з елементами, звідки ми можемо за допомогою миші перенести на форму будь-який елемент:

Знайдемо серед елементів кнопку і, захопивши її покажчиком миші, перенесемо на форму:

Це – візуальна частина. Тепер приступимо до самого програмування. Додамо найпростіший код мовою C#, який виводив би повідомлення з натискання кнопки. Для цього ми повинні перейти до файлу коду, який пов'язаний із цією формою. Якщо у нас не відкритий файл коду, ми можемо натиснути на форму правою кнопкою миші і в меню вибрати View Code (Подивитися файл коду):

Однак скористаємося іншим способом, щоби не писати багато зайвого коду. Наведемо покажчик миші на кнопку і клацніть по ній подвійним клацанням. Ми автоматично потрапляємо у файл коду Form1.cs, який виглядає так:

Using System; використовуючи System.Collections.Generic; використовуючи System.ComponentModel; використовуючи System.Data; використовуючи System.Drawing; використовуючи System.Linq; використовуючи System.Text; використовуючи System.Threading.Tasks; using System.Windows.Forms; namespace HelloApp ( Public partial class Form1: Form ( public Form1() ( InitializeComponent(); ) private void button1_Click(object sender, EventArgs e) ( ) ) )

Додамо виведення повідомлення після натискання кнопки, змінивши код таким чином:

Запуск програми

Щоб запустити програму в режимі налагодження, натисніть клавішу F5 або зелену стрілку на панелі Visual Studio. Після цього запуститься наша форма із самотньою кнопкою. І якщо ми натиснемо кнопку на формі, то нам буде відображено повідомлення з привітанням.

Після запуску програми студія компілює його у файл із розширенням exe. Знайти цей файл можна, зайшовши до папки проекту і далі до каталогу bin/Debug або bin/Release

Розглянувши коротко створення проекту графічного докладання, ми можемо перейти до огляду основних компонентів і почнемо з форм.