Кратко съдържание

Том 2

Кратко съдържание. 2

Съдържание. 13

Предговор към втория том. 33

Глава 15. Изграждане на графичен потребителски интерфейс с Windows Forms  55

Глава 16. Изграждане на уеб приложения с ASP.NET. 173

Глава 17. Многонишково програмиране и синхронизация. 283

Глава 18. Мрежово и Интернет програмиране. 349

Глава 19. Отражение на типовете (Reflection). 431

Глава 20. Сериализация на данни. 459

Глава 21. Уеб услуги с ASP.NET. 501

Глава 22. Отдалечени извиквания с .NET Remoting. 587

Глава 23. Взаимодействие с неуправляван код. 631

Глава 24. Управление на паметта и ресурсите. 675

Глава 25. Асемблита и разпространение. 747

Глава 26. Сигурност в .NET Framework. 816

Глава 27. Mono – свободна имплементация на .NET Framework. 864

Глава 28. Помощни инструменти за .NET разработчици. 910

Глава 29. Практически проект. 972

Заключение към втория том. 1032

 


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

 

Светлин Наков и колектив

 

 


Александър Русев

Александър Хаджикръстев

Антон Андреев

Бранимир Ангелов

Васил Бакалов

Виктор Живков

Галин Илиев

Георги Пенчев

Деян Варчев

Димитър Бонев

Димитър Канев

Ивайло Димов

Ивайло Христов

Иван Митев

Лазар Кирчев

Манол Донев

Мартин Кулов

Михаил Стойнов

Моника Алексиева

Николай Недялков

Панайот Добриков

Преслав Наков

Радослав Иванов

Рослан Борисов

Светлин Наков

Стефан Добрев

Стефан Захариев

Стефан Кирязов

Стоян Дамов

Тодор Колев

Христо Дешев

Христо Радков

Цветелин Андреев

Явор Ташев


 

 

 

Българска асоциация на разработчиците на софтуер

София, 2004-2006


Програмиране за .NET Framework (том 2)

 

© Българска асоциация на разработчиците на софтуер (БАРС), 2006 г.

 

Настоящата книга се разпространява свободно при следните условия:

Читателите имат право:

-     да използват книгата и учебните материали към нея или части от тях за всякакви цели, включително да ги да променят според своите нужди и да ги използват при извършване на комерсиална дейност;

-     да използват сорс кода от примерите и демонстрациите, включени към книгата и учебните материали или техни модификации, за всякакви нужди, включително и в комерсиални софтуерни продукти;

-     да разпространяват безплатно непроменени копия на книгата и учеб­ните материали в електронен или хартиен вид;

-     да разпространяват безплатно оригинални или променени части от учебните материали, но само при изричното споменаване на източника и авторите на съответния текст, програмен код или друг материал.

Читателите нямат право:

-     да разпространяват срещу заплащане книгата, учебните матери­али или части от тях (включително модифицирани версии), като изключе­ние прави само програмният код;

-     да премахват настоящия лиценз от книгата или учебните материали.

 

Всички запазени марки, използвани в тази книга, са собственост на техните притежатели.

 

 

Официален уеб сайт:

www.devbg.org/dotnetbook/

 

ISBN: 954-775-672-9

ISBN: 978-954-775-672-4


Национална академия по разработка на софтуер

Лекторите

» Светлин Наков е автор на десетки технически публи­ка­ции и ня­колко книги, свър­­зани с раз­работката на соф­ту­ер, заради което е тър­сен лектор и кон­султант.

Той е разработчик с дъл­гого­дишен опит, работил по раз­нообразни проекти, реали­зи­рани с раз­лични техноло­гии (.NET, Java, Oracle, PKI и др.) и преподавател по съвре­мен­ни софтуерни технологии в СУ "Св. Климент Охридски".

През 2004 г. е носител на награ­дата "Джон Атанасов" на прези­дента на България Ге­орги Пър­ва­нов.

Светлин Наков ръководи обу­чението по Java технологии в Академията.

 

» Мартин Кулов е софтуерен инженер и консул­тант с дългогодишен опит в изграждането на решения с платформите на Microsoft.

Мартин е опитен инструктор и сертифициран от Майкрософт разработчик по програмите MCSD, MCSD.NET, MCPD и MVP и меж­дународен лектор в световна­та организа­ция на .NET потре­бителски­те групи INETA.

Мартин Кулов ръководи обу­чението по .NET технологии в Академията.

Академията

» Национална академия по раз­ра­ботка на софтуер (НАРС) е център за професионално обу­чение на соф­ту­ерни специалисти.

 

» НАРС провежда БЕЗПЛАТНО кур­сове по разработка на софтуер и съв­ременни софтуерни тех­нологии в Со­фия и други градове.

 

» Предлагани специалности:

§  Въведение в програмирането (с езиците C# и Java)

§  Core .NET Developer

§  Core Java Developer

 

» Качествено обу­чение с много практически про­екти и индивиду­ално внимание за всеки.

 

» Гарантирана работа! Трудов до­говор при постъпване в Академията.

 

» БЕЗПЛАТНО!

Учите безплатно във въведителните курсове и по стипендии от работода­телите в следващите нива.

http://academy.devbg.org




 

 

 


 

 

www.devbg.org

 

 

Българска асоциация на разработчиците на софтуер (БАРС) е нестопанска организация, която подпомага про­фе­сионалното развитие на българските софтуерни специ­а­листи чрез образо­вателни и други инициативи.

БАРС работи за насърчаване обмяната на опит между раз­работ­чиците и за усъвършенстване на техните знания и умения в областта на проектирането и разработката на софтуер.

Асоциацията организира специализирани конференции, семи­нари и курсове за обучение по разработка на софту­ер и софту­ерни технологии.

БАРС организира създаването на Национална академия по раз­работка на софтуер – учебен център за професионал­на подго­товка на софтуерни специалисти.

 


Отзив от Теодор Милев

 

Свидетели сме как платформата Microsoft .NET се налага все повече в света на софтуерните технологии. Тази тенденция се наблюдава и в България, където прогресивно нараства броят на проектите, реализирани на базата на .NET. С увеличаване на .NET разработчиците расте и нуждата от качествена техническа литература и учебни материали, които да бъдат използвани при обучението на .NET специалисти.

"Програмиране за .NET Framework" е първата чисто българска книга за Microsoft .NET технологиите. Тя представя на читателя в последователен, структуриран, достъпен и разбираем вид основните концепции за разра­ботка на приложения с .NET Framework и езика C#. Книгата обхваща в детайли всички основни .NET технологии като набляга върху най-важните от тях – ADO.NET, ASP.NET, Windows Forms и XML уеб услуги.

По качество на изложения материал книгата се отличава с високо профе­сионално ниво и превъзхожда повечето преводни издания по темата. Тя е отлично структурирана, а стилът на изложени­ето е лесен за възприемане. Инфор­мацията е поднесена с много примери, а това е най-важното за един софтуерен разработчик.

Книгата е написана от широк екип доказани специалисти, работещи в партньорските фирми на Майкрософт – хора с опит в разработката на .NET приложения. Основният автор и ръководител на проекта, Светлин Наков, е изтъкнат .NET специалист, лектор в множество семинари и кон­ференции, търсен консул­тант и преподавател. Негови са заслугите за курсовете по програ­миране за платформа .NET във Факултета по матема­тика и информатика на Софийски университет. Негови са и основните заслуги за целия проект по изготвяне на изчерпателно учебно съдържа­ние и книга по програми­ране за .NET Framework.

Светлин Наков е носител на най-голямото отличие в областта на информа­ционните технологии – наградата "Джон Атанасов" на Президента Георги Първанов за принос към развитието на информационните техно­логии информационното общество. Той е автор на десетки статии и книги за програмиране, а настоящото издание е поредната му добра изява.

Настоящата книга е отлично учебно пособие както за начинаещи, така и за напреднали читатели, които имат желание и амбиции да станат профе­сионални .NET разработчици.

 

Теодор Милев,

Управляващ директор на "Майкрософт България"


Отзив от Божидар Сендов

 

Книгата е оригинално българско творение, с нищо неотстъпващо по каче­ство и обем на световните бестселъри с компютърна тематика. Мате­риалът е поднесен достъпно и е богато илюстриран с примери, което я прави не само отлично въведение в платформата .NET за начинаещия, но и отличен справочник за професионалиста-програмист на C#. Читателят може да се запознае в детайли не само с общите принципи, но и с редица тънкости на програмирането за .NET. Широко застъпени са редица "уни­версални" теми като обектно-ориентирано програмиране, регулярни изра­зи, XML, релаци­онни бази данни, програмиране в Интернет, многозадач­ност, сигурност и др.

Книгата се отличава със стегнат и ясен стил на изложението, като е постигнато завидно педагогическо майсторство. Това не бива да ни изне­надва – авторите са водещи специалисти с богат опит не само като профе­сионални софтуерни разработчици, но и като преподаватели във Факул­тета по математика и информатика (ФМИ) на СУ "Св. Климент Охридски". Самата книга в значителна степен се основава на работни лекции, изпол­звани и проверени в поредица от курсове по програмиране за .NET Framework във ФМИ. Сайтът на книгата съдържа над 2000 безплатни слайда, следващи стриктно съдържанието й, а книгата е напълно безплат­на в електронния си вариант, което максимално улеснява използването й в съответен курс по програмиране.

Не на последно място, заслужава да се отбележи систематичният опит за превод на всички термини на български език, съобразен с вече наложи­лата се българска терминология, но и с оригинални идеи при новите понятия.

Работата, която авторите са свършили, е наистина чудесна, а книгата е задължителна част от библиотеката на всеки с интерес към езика C# и изобщо към водещата платформа на Майкрософт .NET.

 

 

 

доц. д-р Божидар Сендов

Факултет по математика и Информатика,

Софийски Университет "Св. Климент Охридски"


Отзив от Стоян Йорданов

 

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

Обхващайки най-важните аспекти на .NET Framework, книгата започва от основите на езика C# и .NET платформата и постепенно достига до сложни концепции като уеб услуги, сигурност, сериализация, работа с отдалечени обекти, манипулиране на бази данни чрез ADO.NET, потреби­телски интерфейс с Windows Forms, ASP.NET уеб приложения и т.н. Информацията е поднесена изключително достъпно и подкрепена с много­бройни примери и илюстрации. Всяка тема включва и упражнения за самостоятелна работа – неотменим елемент за затвърдяване на придоби­тите от нея знания.

Авторският колектив включва утвърдени специалисти от софтуерните среди. Въпреки, че авторите са над 30, "Програмиране за .NET Framework" не е просто сборник от статии; напротив – всеки от тях е допринесъл с опита и труда си, за да може книгата да бъде това, което е – добре структурирано и изчерпателно ръководство.

Учебник за студента или справочник за специалиста – "Програмиране за .NET Framework" е задължителна за библиотеката на всеки който има досег с .NET.

 

 

 

 

 

Стоян Йорданов,

Software Design Engineer,

Microsoft Corpartion (Redmond)

 

* Мнението е лично на автора му и не обвързва Microsoft Corporation по никакъв начин


Национална академия по разработка на софтуер

Лекторите

» Светлин Наков е автор на десетки технически публи­ка­ции и ня­колко книги, свър­­зани с раз­работката на соф­ту­ер, заради което е тър­сен лектор и кон­султант.

Той е разработчик с дъл­гого­дишен опит, работил по раз­нообразни проекти, реали­зи­рани с раз­лични техноло­гии (.NET, Java, Oracle, PKI и др.) и преподавател по съвре­мен­ни софтуерни технологии в СУ "Св. Климент Охридски".

През 2004 г. е носител на награ­дата "Джон Атанасов" на прези­дента на България Ге­орги Пър­ва­нов.

Светлин Наков ръководи обу­чението по Java технологии в Академията.

 

» Мартин Кулов е софтуерен инженер и консул­тант с дългогодишен опит в изграждането на решения с платформите на Microsoft.

Мартин е опитен инструктор и сертифициран от Майкрософт разработчик по програмите MCSD, MCSD.NET, MCPD и MVP и меж­дународен лектор в световна­та организа­ция на .NET потре­бителски­те групи INETA.

Мартин Кулов ръководи обу­чението по .NET технологии в Академията.

Академията

» Национална академия по раз­ра­ботка на софтуер (НАРС) е център за професионално обу­чение на соф­ту­ерни специалисти.

 

» НАРС провежда БЕЗПЛАТНО кур­сове по разработка на софтуер и съв­ременни софтуерни тех­нологии в Со­фия и други градове.

 

» Предлагани специалности:

§  Въведение в програмирането (с езиците C# и Java)

§  Core .NET Developer

§  Core Java Developer

 

» Качествено обу­чение с много практически про­екти и индивиду­ално внимание за всеки.

 

» Гарантирана работа! Трудов до­говор при постъпване в Академията.

 

» БЕЗПЛАТНО!

Учите безплатно във въведителните курсове и по стипендии от работода­телите в следващите нива.

http://academy.devbg.org


Съдържание

Том 2

Кратко съдържание. 2

Съдържание. 13

Предговор към втория том. 33

За кого е предназначена тази книга? 33

Необходими начални познания. 33

Какво обхваща вторият том на тази книга? 34

Фокусът е върху .NET Framework 1.1. 34

Как е представена информацията? 34

Поглед към съдържанието на втория том. 35

Глава 15. Графичен потребителски интерфейс с Windows Forms. 35

Глава 16. Изграждане на уеб приложения с ASP.NET. 35

Глава 17. Многонишково програмиране и синхронизация. 36

Глава 18. Мрежово и Интернет програмиране. 36

Глава 19. Отражение на типовете (Reflection) 37

Глава 20. Сериализация на данни. 37

Глава 21. Уеб услуги с ASP.NET. 37

Глава 22. Отдалечено извикване на методи (Remoting) 38

Глава 23. Взаимодействие с неуправляван код. 38

Глава 24. Управление на паметта и ресурсите. 38

Глава 25. Асемблита и разпространение (deployment) 39

Глава 26. Сигурност в .NET Framework. 39

Глава 27. Mono - свободна имплементация на .NET. 39

Глава 28. Помощни инструменти за .NET разработчици. 39

Глава 29. Практически проект. 40

Авторският колектив. 40

Александър Русев. 40

Александър Хаджикръстев. 41

Антон Андреев. 41

Бранимир Ангелов. 41

Васил Бакалов. 41

Виктор Живков. 42

Деян Варчев. 42

Димитър Бонев. 42

Димитър Канев. 42

Галин Илиев. 43

Георги Пенчев. 43

Иван Митев. 43

Ивайло Димов. 44

Ивайло Христов. 44

Лазар Кирчев. 44

Манол Донев. 44

Мартин Кулов. 45

Михаил Стойнов. 45

Моника Алексиева. 45

Николай Недялков. 45

Панайот Добриков. 46

Преслав Наков. 46

Радослав Иванов. 47

Рослан Борисов. 47

Светлин Наков. 47

Стефан Добрев. 48

Стефан Кирязов. 48

Стефан Захариев. 48

Стоян Дамов. 49

Тодор Колев. 49

Христо Дешев. 49

Христо Радков. 49

Цветелин Андреев. 50

Явор Ташев. 50

Благодарности. 50

Светлин Наков. 50

Авторският колектив. 51

Българска асоциация на разработчиците на софтуер. 51

Microsoft Research. 51

SciForge.org. 51

Софийски университет "Св. Климент Охридски". 52

telerik. 52

Сайтът на книгата. 52

Лиценз 52

Общи дефиниции. 52

Права и ограничения на потребителите. 53

Права и ограничения на авторите. 53

Права и ограничения на БАРС. 54

Права и ограничения на Microsoft Research. 54

Глава 15. Изграждане на графичен потребителски интерфейс с Windows Forms  55

Автори. 55

Необходими знания. 55

Съдържание. 55

В тази тема ... 56

Какво е Windows Forms? 57

Windows Forms е базирана на RAD концепцията. 57

Windows Forms и другите библиотеки за изграждане на GUI 58

Контролите в Windows Forms. 58

Windows Forms и работа с данни. 59

Вградена поддръжка на Unicode. 59

Наследяване на форми и контроли. 59

ActiveX контроли. 59

Печатане на принтер. 60

Windows Forms контроли в Internet Explorer 60

Силна поддръжка на графика (GDI+) 60

Нашето първо Windows Forms приложение. 60

Библиотеките на .NET за изграждане на GUI 62

Пространството System.Windows.Forms. 62

Пространството System.Drawing. 63

Програмни компоненти. 63

Компонентен модел. 63

Компонентният модел на .NET Framework. 63

Компоненти и контейнери. 63

Преизползваемост на компонентите. 63

Пространството System.ComponentModel 64

Windows Forms и компонентният модел на .NET. 64

Контроли и контейнер-контроли. 64

Програмен модел на Windows Forms 64

Форми. 64

Контроли. 65

Събития. 65

Жизнен цикъл на Windows Forms приложенията. 65

Модел на пречертаване на контролите. 67

Управление на фокуса и навигация. 69

Основни класове в Windows Forms 69

Йерархия на класовете. 70

Класът Control 71

Свойства на класа Control 71

Методи на класа Control 73

Събития на класа Control 73

Класът ScrollableControl 74

Класът ContainerControl 75

Форми, прозорци и диалози. 75

Класът System.Windows.Forms.Form.. 75

По-важни свойства на класа Form.. 75

По-важни методи на класа Form.. 77

По-важни събития на класа Form.. 78

Основни контроли в Windows Forms 78

TextBox. 78

Label 79

Button. 79

Поставяне на контроли във формата. 79

Управление на събитията. 79

Прост калкулатор – пример. 80

Windows Forms редакторът на VS.NET. 83

Създаване на форма. 83

Добавяне на контрола. 84

Добавяне на неграфични компоненти. 84

Настройка на свойства. 84

Добавяне на обработчици на събития. 85

Създаване на калкулатор с Windows Forms редактора на VS.NET – пример. 86

Диалогови кутии. 88

Стандартни диалогови кутии. 88

Извикване на диалогови кутии. 89

DialogResult и предаване на данни между диалози – пример. 89

Други Windows Forms контроли. 92

CheckBox. 92

RadioButton. 92

Panel 92

TabControl и TabPage. 93

ListBox. 93

CheckedListBox. 93

ComboBox. 94

TreeView.. 94

RichTextBox. 94

LinkLabel 95

PictureBox. 95

Работа с някои Windows Forms контроли – пример. 95

Менюта. 99

MainMenu. 99

ContextMenu. 99

MenuItem.. 99

Ленти с инструменти. 100

ToolBar 100

ToolBarButton. 100

ImageList 100

Статус ленти. 101

StatusBar 101

StatusBarPanel 101

Диалог за избор на файл. 101

OpenFileDialog. 101

SaveFileDialog. 102

Работа с файлов диалог – пример. 102

MDI приложения. 103

MDI контейнери (MDI parents) 104

MDI форми (MDI children) 104

Създаване на многодокументов текстов редактор – пример. 104

Валидация на данни. 115

Валидация на данни – пример. 116

Свързване на данни. 121

Източници на данни. 122

Контроли, поддържащи свързване на данни. 122

Видове свързване. 122

Просто свързване. 123

Сложно свързване. 131

Контролата DataGrid. 133

Работа с DataGrid контролата – пример. 133

TableStyles и дефиниране на стилове – пример. 135

Master-Details навигация. 137

Master-Details навигация – пример. 138

Проблеми при Master-Details навигацията. 141

Релации "много към много". 141

Наследяване на форми. 142

Наследяване на форми – пример. 142

Пакетът System.Drawing и GDI+. 146

Класът Graphics. 147

Работа със System.Drawing – пример. 147

Анимация със System.Drawing – пример. 148

Печатане на принтер. 150

Потребителски контроли. 151

Създаване на нова контрола, която не наследява съществуваща. 151

Създаване на нова контрола като комбинация от други контроли. 151

Създаване на нова контрола, която наследява съществуваща контрола. 152

Създаване на контрола – пример. 152

Хостинг на контроли в Internet Explorer 157

Хостинг на контроли в Internet Explorer – пример. 157

Нишки и Windows Forms 160

Използване на нишки в Windows Forms приложения – пример. 161

Влачене (Drag and Drop) 165

Влачене и пускане в Windows Forms – пример. 165

Конфигурационен файл на приложението. 167

Извличане на настройки от конфигурационен файл – пример. 167

Упражнения. 169

Използвана литература. 172

Глава 16. Изграждане на уеб приложения с ASP.NET. 173

Автори. 173

Необходими знания. 173

Съдържание. 173

В тази тема ... 174

Въведение. 175

Изпълнение на ASP.NET уеб приложение. 175

Преглед на технологията ASP.NET. 175

Разлики между ASP и ASP.NET. 176

Фундаменти на ASP.NET. 176

Как работи ASP.NET?. 177

Разделяне на визуализация от бизнес логика. 178

Компоненти на ASP.NET. 179

Пример за уеб приложение. 180

ASP.NET Web Application проекти във VS.NET. 181

Модел на изпълнение на ASP.NET. 182

Уеб форми. 183

Какво е уеб форма (Web Form)?. 183

Създаване на уеб форма. 183

Директиви. 184

Директивата <@Page …>.. 185

Атрибути на директивата <@Page …>.. 185

Тагът <form>.. 186

Вградени обекти в ASP.NET. 186

Уеб контроли. 186

ASP.NET сървърни контроли. 187

HTML сървърни контроли (HTML server controls) 188

Уеб сървърни контроли (Web server controls) 190

Кои контроли да ползваме?. 191

Категории уеб сървърни контроли. 192

Code-behind. 195

Добавяне на код в уеб форма. 195

Inline code. 195

Code-behind класове. 196

Как работи code-behind?. 196

JIT компилация. 196

Събития. 197

Прихващане на събития. 197

Свойството AutoEventWireup. 197

Жизнен цикъл на ASP.NET страниците. 198

Свойството IsPostBack. 198

Свойството AutoPostBack. 199

HTML escaping проблеми. 200

HTML escaping проблеми – пример. 200

Свързване с данни (Data binding) 202

Как работи методът DataBind(…)?. 202

Свързване на контроли с данни – пример. 203

Работа с бази от данни от ASP.NET. 209

Обзор на ADO.NET. 209

Визуализиране на данни. 210

Свързване на данни (data binding) 210

Контроли за показване на данни. 212

Списъчни контроли. 213

Итериращи контроли. 219

Управление на състоянието. 228

Бисквитки (Cookies) 228

Скрити полета. 230

Параметризирани адреси (Query Strings) 231

Технологията ViewState. 232

Състояние на приложението. 234

Състояние на сесиите. 237

Валидация на данни. 239

RequiredFieldValidator – проверка за наличие на данни. 240

CompareValidator – проверка на входните данни. 241

RangeValidator – проверка попадане в интервал. 242

RegularExpressionValidator – сравняване с регулярен израз. 243

CustomValidator – произволна проверка. 243

ValidationSummary – списък на грешките. 246

Йерархия на класовете валидатори. 247

Общи свойства за валидаторите. 247

Кога и къде се извършва валидацията?. 248

Защо винаги на сървъра?. 248

Особености при валидацията при клиента. 249

Потребителски контроли. 250

Потребителски контроли и уеб форми. 250

Предимства при използването на потребителски контроли. 250

Споделяне на потребителски контроли. 250

Използване на потребителски контроли. 251

Създаване на потребителска контрола – пример. 251

Проследяване и дебъгване на уеб приложния. 254

Информация по време на изпълнение. 254

Проследяване. 254

Отдалечено дебъгване. 257

Оптимизация, конфигурация и разгръщане на ASP.NET приложения. 258

Оптимизиране чрез кеширане. 258

Конфигуриране на ASP.NET приложение. 262

Разгръщане на приложението. 266

Сигурност в ASP.NET. 268

Автентикация и оторизация. 268

Видове автентикация в ASP.NET. 269

Сигурност на ниво сървър (IIS Security) 276

Упражнения. 279

Използвана литература. 281

Глава 17. Многонишково програмиране и синхронизация. 283

Автори. 283

Необходими знания. 283

Съдържание. 283

В тази тема ... 284

Многозадачност 285

Проблемът. 285

Ползите от многозадачността. 285

Защо е нужна многозадачност – пример. 285

Решението – процеси и нишки. 287

Процеси и нишки. 287

Какво предлагат нишките?. 288

Кога са удобни нишките?. 288

Многозадачност – видове. 288

Имплементации на многозадачност. 289

Домейни на приложението (Application Domains) 290

Нишки. 291

Как работят нишките?. 291

Класът Thread. 293

Приоритет. 298

Състояния. 299

Живот на нишките. 300

Прекратяване на нишка. 300

Thread Local Storage (локални за нишката данни) 305

Thread-Relative Static Fields (статични полета, свързани с нишката) 306

Неудобства при работата с нишки. 308

Проблеми при работа с общи данни. 308

Синхронизация. 310

Най-доброто решение за общите данни. 310

Синхронизирани "пасажи" код (synchronized code regions) 311

Синхронизирани контексти (Synchronized Contexts) 315

MethodImplAttribute. 317

Неуправлявана синхронизация – класът WaitHandle. 317

Класът Mutex. 318

Класовете AutoResetEvent и ManualResetEvent 320

Класът Interlocked. 323

Класически синхронизационни задачи. 325

Пул от нишки (ThreadPool) 329

Предимства. 330

Недостатъци. 330

Класът ThreadPool 330

Методът ThreadPool.RegisterWaitForSingleObject() 331

Интерфейсът ISynchronizeInvoke. 333

Използване на ISynchronizeInvoke. 333

Windows Forms и ISynchronizeInvoke. 335

Таймери. 335

System.Timers.Timer 336

System.Threading.Timer 338

System.Windows.Forms.Timer 340

Как да изберем таймер?. 341

Volatile полета. 341

Асинхронни извиквания. 342

Какво е асинхронно извикване?. 342

Къде се ползва асинхронно извикване?. 342

Асинхронно извикване чрез делегат. 342

Модел за асинхронно програмиране. 343

Сигнатура на методите за асинхронни извиквания. 343

Интерфейсът IAsyncResult 344

Проверка за приключване на асинхронното извикване. 344

Упражнения. 348

Използвана литература. 348

Глава 18. Мрежово и Интернет програмиране. 349

Автори. 349

Необходими знания. 349

Съдържание. 349

В тази тема ... 349

OSI модел. 350

Физическо ниво. 351

Свързващо ниво (канално ниво) 351

Мрежово ниво. 351

Транспортно ниво. 351

Сесийно ниво. 351

Представително ниво. 351

Приложно ниво. 351

Основи на мрежовото програмиране. 352

IP адрес. 352

Domain Name Service (DNS) 352

Порт. 352

Основни мрежови услуги. 353

Мрежов интерфейс. 353

Loopback интерфейс. 353

Протоколът TCP. 354

Протоколът UDP. 354

Как две отдалечени машини си "говорят"?. 354

Класове за мрежово програмиране в .NET. 355

Пространството System.Net.Sockets. 355

Пространството System.Net 356

Представяне на IP адреси в .NET Framework. 357

Класът IPAddress. 357

Класът IPEndPoint 359

Комуникация по TCP сокет с TcpClient 359

Създаване и свързване на TcpClient 360

Създаване на прост TCP порт скенер – пример. 362

Предаване на данни по TCP сокет чрез TcpClient и NetworkStream.. 363

Комуникация с TcpClient – пример. 366

Настройки на TCP връзката чрез свойствата на TcpClient 370

Изграждане на TCP сървър с TcpListener 371

Създаване на TcpListener 371

Приемане на TCP връзки. 371

Прост TCP сървър – пример. 373

Обслужване на много клиенти едновременно. 375

Едновременно обслужване на клиенти с TcpListener – пример. 376

Комуникация по UDP с UdpClient 382

Конструктори на UdpClient 383

Задаване на отдалечен сървър по подразбиране. 383

Изпращане на UDP пакети – метод Send(…) 384

Получаване на UDP пакети – метод Receive(…) 385

Комуникация с UdpClient – пример. 385

Сокети на по-ниско ниво – класът Socket 387

Създаване на Socket обекти и тип на сокета. 387

Основни операции с класа Socket 388

Сокети с връзка по TCP. 389

Свойства на сокетите и задаване на опции. 396

Сокет по протокол UDP. 397

Няколко думи за асинхронните сокети. 403

Свойството Blocking. 403

Асинхронни методи. 403

Методите Poll(…) и Select(…) 404

Multicasting в .NET Framework. 406

Broadcasting сокети. 406

Multicasting сокети. 406

Използване на DNS услуги чрез класа Dns 408

Асинхронни DNS заявки. 409

Работа с уеб ресурси – класът WebClient 409

Извличане на данни по HTTP. 410

Изпращане на данни по HTTP. 413

Автентикация с Credentials. 414

Други полезни свойства на WebClient 415

HTTP заявки с класовете HttpWebRequest и HttpWebResponse. 416

Създаване на HHTP заявка. 416

Изпращане на данни към HTTP сървър. 416

Получаване на HTTP отговор. 417

Извличане на Cookies. 418

Други видове WebRequest и WebResponse. 419

Работа с HTTP заявки – пример. 419

Работа с електронна поща. 420

Протоколи за изтегляне на електронната поща. 421

Изтегляне на електронната поща с .NET Framework. 421

Изпращане на електронна поща. 421

Изпращане на електрона поща с .NЕТ Framework. 422

Упражнения. 428

Използвана литература. 429

Глава 19. Отражение на типовете (Reflection). 431

Автор. 431

Необходими знания. 431

Съдържание. 431

В тази тема ... 431

Какво е Global Assembly Cache? 432

Инсталиране на асемблита в GAC. 432

Поддръжка на много версии. 433

Преглед на GAC през Windows Explorer 433

Преглед на GAC през Administrative Tools. 435

Отражение на типовете. 437

Какво е Reflection?. 437

Зареждане на асемблита. 437

Извличане информация за асембли. 438

Премахване на асемблита от паметта. 440

Изучаване на типовете в асембли. 440

Reflection класове за видовете членове. 445

Извличане на методи и параметрите им. 446

Reflection Emit 453

Упражнения. 457

Използвана литература. 458

Глава 20. Сериализация на данни. 459

Автор. 459

Необходими знания. 459

Съдържание. 459

В тази тема ... 459

Сериализация. 460

Какво е сериализация (serialization)?. 460

Какво е десериализация (deserialization)?. 460

Кога се използва сериализация?. 460

Защо да използваме сериализация?. 461

Кратък пример за сериализация?. 462

Форматери (Formatters) 462

Процесът на сериализиране. 463

Кратък пример за сериализация. 464

Кратък пример за десериализация. 465

Бинарна сериализация – пример. 466

Сериализация по мрежата – пример. 469

Дълбоко копиране на обекти – пример. 475

IDeserializationCallback. 478

ISerializable и контролиране на сериализацията. 481

За ефективността на сериализацията. 487

XML сериализация. 488

Какво е XML сериализация?. 488

XML сериализация – пример. 488

Проста XML сериализация – пример. 489

Контролиране на изходния XML. 491

Контрол на XML сериализацията – пример. 492

Външен контрол на XML сериализацията. 496

Външен контрол на сериализацията – пример. 497

Приложение: FormatterServices 498

Методи за сериализация. 499

Методи за десериализация. 499

Упражнения. 499

Използвана литература. 500

Глава 21. Уеб услуги с ASP.NET. 501

Автори. 501

Необходими знания. 501

Съдържание. 501

В тази тема ... 502

Възникването на уеб услугите. 503

Разпределени приложения. 503

Модели за разпределени приложения. 503

Нуждата от уеб услуги. 504

Уеб услуги. 506

Какво е услуга?. 506

Какво е уеб услуга?. 506

Принцип на действие на уеб услугите. 507

Инфраструктура на уеб услугите. 508

Директории за уеб услуги. 509

Откриване на уеб услуги. 511

WSDL описания на услуги. 512

SOAP – формат на заявките. 515

Протоколен стек на уеб услугите. 520

Сценарии за използване на уеб услугите. 521

Доставяне на данни. 521

Услуги към клиентски приложения. 522

Интеграция на приложения. 522

В ролята на адаптери. 522

Връзка между отделните компоненти на Enterprise приложения. 523

Enterprise приложения. 523

Кои приложения са Enterprise?. 523

.NET Enterprise приложения. 524

Уеб услугите в ASP.NET. 526

Пространства от имена. 526

Архитектура на ASP.NET уеб услугите. 527

Създаване на уеб услуги. 528

Уеб услугите и уеб приложенията. 529

Публикуване на уеб услуги. 529

Използване на уеб услуги. 536

Уеб услугите и VS.NET – създаване и консумиране. 540

Атрибути за уеб услугите. 542

Прехвърляне на типове (marshalling) 544

Дебъгване на уеб услуги. 553

Моделът на изпълнение на уеб услугите в ASP.NET. 553

Асинхронно извикване на уеб услуги. 555

Уеб услуги и работа с данни. 558

Поддръжка на сесии. 562

Сигурност на уеб услугите. 566

Изключенията в уеб услугите. 572

Упражнения. 584

Използвана литература. 586

Глава 22. Отдалечени извиквания с .NET Remoting. 587

Автор. 587

Необходими знания. 587

Съдържание. 587

В тази тема ... 587

Разпределени приложения. 588

Какво е .NET Remoting? 588

Кога се използва Remoting? 588

Microsoft Indigo (WCF) 589

Remoting инфраструктурата. 589

Как работи Remoting инфраструктурата?. 590

Remoting канали. 590

Форматери (formatters) 592

Активация на обекти. 593

Регистрация на отдалечен обект. 594

Създаване на инстанция на отдалечен обект. 596

Маршализация (Marshaling) 598

Живот на обектите (Lifetime) 600

Remoting конфигурационни файлове. 606

Remoting сценарии. 617

Чиста мрежова комуникация. 619

XML уеб услуги. 619

.NET Remoting. 619

Remoting сървър и клиент – пример. 620

Създаване на общите типове. 620

Създаване на сървър. 622

Създаване на клиент. 624

Сървърът и клиентът в действие. 625

Проблемът с общите типове. 628

Споделено асембли с типове. 628

Споделено асембли с интерфейси. 628

Soapsuds.exe. 629

Хостинг на Remoting типове в IIS. 629

Упражнения. 629

Използвана литература. 630

Глава 23. Взаимодействие с неуправляван код. 631

Автор. 631

Необходими знания. 631

Съдържание. 631

В тази тема ... 631

Какво разбираме под взаимодействие с неуправляван код? 633

Обща среда или виртуална машина. 633

Среда за контролирано изпълнение .NET CLR (обща среда) 634

Виртуална машина JVM.. 634

Платформено извикване (P/Invoke) 636

Атрибут DllImport 636

Как работи P/Invoke?. 640

Командата DUMPBIN. 640

Зареждане на системна икона – пример. 641

Преобразуване на данни (marshalling) 643

Преобразуване на структури. 644

Разполагане на полетата от структурата. 644

Преобразуване на класове. 646

Преобразуване на низове. 646

Атрибут MarshalAs. 648

Имплементиране на функция за обратно извикване (callback) 649

Преобразуване на данни – пример. 650

Взаимодействие с COM (COM interop) 655

Какво е COM?. 655

Видове COM обекти и регистрация. 655

Структура на COM обектите. 656

Извикване на COM обект от управляван код. 657

Разкриване на .NET компонент като COM обект. 662

Взаимодействие със C++ чрез IJW.. 667

IJW извикване от C++ – пример. 667

Препоръки за използване на .NET типове от COM. 668

Immutable ли са наистина символните низове?. 669

Използване на броячи за производителност и CLRSpy – пример. 670

Упражнения. 673

Използвана литература. 673

Глава 24. Управление на паметта и ресурсите. 675

Автори. 675

Необходими знания. 675

Съдържание. 675

В тази тема... 676

Управление на паметта при различните езици и платформи. 677

Ръчно управление на паметта и ресурсите. 677

Предимства и недостатъци на ръчното управление на паметта и ресурсите. 679

Управление на паметта в .NET Framework. 681

Предимства и недостатъци на автоматичното управление на паметта. 682

Как се заделя памет в .NET?. 685

Как работи garbage collector?. 687

Поколения памет. 691

Блок памет за големи обекти. 695

Увеличаване размера на хийпа. 696

Финализацията на обекти в .NET. 696

Какво е финализация?. 697

Деструкторите в C#.. 697

Финализация – пример. 699

Зад кулисите. 699

Опашката Freachable. 701

Накратко за финализацията. 701

Тъмната страна на финализацията. 702

Какво да правим все пак?. 703

Съживяване на обекти. 703

Ръчно управление на ресурсите с IDisposable. 705

Интерфейсът IDisposable. 706

Операторът using. 706

IDisposable и Finalize. 707

Примерна имплементация на базов клас, обвиващ неуправляван ресурс. 709

Close() и експлицитна имплементация на IDisposable. 715

Кога да извикваме IDisposable.Dispose()?. 716

Взаимодействие със системата за почистване на паметта. 716

Почистване на паметта. 716

Потискане на финализацията. 720

Изчакване до приключване на финализацията. 720

Регистриране на обекта за финализация. 720

Определяне поколението на обект. 721

Pinning. 721

Удължаване живота на променливите при Interop. 722

Слаби референции. 725

Ефективно използване на паметта. 726

Техниката "пулинг на ресурси" 738

Примерна имплементация на пул от ресурси. 739

Упражнения. 745

Използвана литература. 746

Глава 25. Асемблита и разпространение. 747

Автор. 747

Необходими знания. 747

Съдържание. 747

В тази тема... 748

Асемблитата в .NET Framework. 749

Асемблитата съдържат IL код за изпълнение. 749

Асемблитата формират граница за сигурността (security boundary) 749

Асемблитата формират граница за типовете (type boundary) 750

Асемблитата формират граница на видимостта (reference scope boundary) 750

Асемблитата формират граница на версиите (version boundary) 750

Асемблитата са единица за споделяне. 750

Асемблитата са единици за разпространение (deployment units) 751

Метаданни и манифест на асембли. 751

Манифест на асембли. 751

Съдържание на манифеста. 752

Атрибути за работа с манифест. 753

Създаване на многомодулно асембли. 755

Разглеждане на манифеста на асембли с ildasm.. 757

Силно именуване на асембли. 759

Конфигурационни файлове в .NET Framework. 762

Как CLR намира асемблитата? 764

Пример 1: Търсене на асембли (probing) 764

Пример 2: Търсене на асембли с тага <codebase>.. 765

Създаване на Publisher Policy File. 766

Global Assembly Cache. 767

DLL адът (DLL Hell) 767

Side-by-side execution. 767

Предимства и недостатъци на GAC. 768

Работа с GAC – пример. 769

Разпространение и инсталиране на програмни пакети. 770

Файлове и папки. 770

Асемблита. 772

Инсталационни компоненти. 775

COM базирани обекти. 776

Сървърни компоненти (Serviced Components) 777

Настройки на Internet Information Server (IIS) 778

Промяна на регистрите на Windows. 782

Споделени инсталационни компоненти (Merge Modules) 782

CAB файлове. 783

Локализиране. 783

Debug Symbols. 784

Инсталационни стратегии. 786

No-Touch Deployment (.NET Zero Deployment) 786

Windows Installer 789

Колекция от файлове след компилация. 797

Създаване на MSI инсталационен пакет 799

Създаване на инсталационен пакет на Windows базирано приложение. 800

Създаване на инсталационен пакет на уеб услуга. 810

Допълнителни настройки на инсталационните проекти във VS.NET 2003. 812

Инсталиране/деинсталиране на MSI пакетите. 812

Упражнения. 814

Използвана литература. 815

Глава 26. Сигурност в .NET Framework. 816

Автори. 816

Необходими знания. 816

Съдържание. 816

В тази тема ... 817

Сигурността в .NET Framework. 818

Безопасност на типовете. 818

Проблемът "Buffer overrun". 818

Защита на паметта. 819

Прихващане на аритметични грешки. 820

Application Domains. 821

Основни криптографски понятия. 822

Силно-именувани асемблита. 825

Технологията Isolated Storage. 827

Сигурност на кода (Code Access Security) 828

Политиките за сигурност в .NET Framework. 828

Права (Permissions) 830

"Stack Walk" и контрол над правата. 831

Декларативно и програмно искане на права. 832

Сигурност базирана на роли (Role-Based Security) 834

Автентикация и оторизация. 834

Класовете Identity и Principal 834

Работа с WindowsIdentity и WindowsPrincipal 835

Информация за текущия потребител – пример. 835

Работа с GenericIdentity и GenericPrincipal 836

Оторизация по Principal обект. 836

Оторизация с потребители и роли – пример. 838

Криптография в .NET Framework. 841

Извличане на хеш стойност. 841

Симетрични криптиращи схеми. 843

Асиметрични криптиращи схеми. 846

Работа с цифрови подписи. 849

XML подписи. 851

Упражнения. 861

Използвана литература. 863

Глава 27. Mono – свободна имплементация на .NET Framework. 864

Автори. 864

Необходими знания. 864

Съдържание. 864

В тази тема... 865

Проектът Mono. 866

Значение на проекта. 866

Статус на проекта. 866

Поддържани операционни системи и архитектури. 866

Инсталиране и конфигуриране на Mono. 867

Инсталиране на Mono върху Linux дистрибуции. 867

Инсталиране на Mono под Windows. 870

Инсталиране на Mono под Mac OS X. 870

Инсталиране на Mono под FreeBSD. 870

Среди за разработка. 871

MonoDevelop. 871

Eclipse. 872

Emacs и Vim.. 873

X-Develop. 873

KDevelop. 873

Какво включва Mono? 873

Виртуална машина. 873

Компилатор за C# – mcs. 875

Mono gmcs. 875

Visual Basic .NET компилатор – mbas. 876

Mono асемблер и дизасемблер – ilasm и monodis. 876

Mono дебъгерът – mdb. 876

Документацията Monodoc. 877

Mono класовете. 878

Полезни инструменти. 879

‘Hello Mono’ с Mono. 879

Сорс кодът. 880

Компилиране. 880

Стартиране. 880

Дизасемблиране. 880

Дебъгване с mdb – Hello Mono ред по ред. 881

ADO.NET и Mono. 882

Npgsql – Data Provider за PostgreSQL. 882

MySQL Data Provider 884

OracleClient – The Oracle Data Provider 885

SqlClient – Data Provider за Microsoft SQL Server 885

Уеб технологиите в Mono. 887

ASP.NET под Mono. 887

Уеб услуги. 891

Графични интерфейси в Mono. 895

Windows Forms. 895

Gtk#.. 896

Glade#.. 897

Gnome#.. 903

QT#.. 903

Cocoa# за Mac OS. 904

Как да пишем преносим код? 904

Програмиране на игри и Tao Framework. 905

Tao Framework. 905

SDL.NET. 906

AXIOM.. 906

Java, Python, PHP и Mono. 907

Java за .NET CLR. 907

Python и PHP под Mono. 908

Упражнения. 908

Полезни Mono ресурси. 908

Използвана литература. 908

Глава 28. Помощни инструменти за .NET разработчици. 910

Автори. 910

Необходими знания. 910

Съдържание. 910

В тази тема ... 910

Помощни инструменти за разработка. 911

.NET Reflector 911

Функции. 911

Разширяемост. 913

FxCop. 914

Правила в FxCop. 915

FxCop – графично приложение. 915

FxCopCmd – приложение за командния ред. 917

Ползи от употребата на FxCop. 917

Използвана литература. 918

CodeSmith. 918

Генериране на код. 918

Въведение в шаблоните на CodeSmith. 920

CodeSmith приложения. 923

Използвана литература. 925

NUnit 925

Какво е автоматизиран unit тест?. 925

Писане на тестове с Nunit 926

Изпълнение на тестовете. 929

Характеристики на добрите тестове. 931

Какво да тестваме като програмисти?. 931

Улесняване на тестването. 932

Mock обекти (Mock objects) 934

Работа с NMock. 934

Разширения на NUnit 936

Използвана литература. 939

Log4net 940

За техниката "логинг". 940

Предизвикателствата пред log4net 940

Компоненти на log4net 941

Други характеристики на log4net 945

log4net пример. 946

Използвана литература. 950

NHibernate. 950

Взаимодействие между обекти и релационни СУБД. 950

ADO.NET и силно типизирани DataSets. 951

Обектно-релационен преход. 952

Демонстрационен пример с NHibernate. 953

Помощни инструменти за NHibernate. 959

Други възможности. 959

Използвана литература. 959

NAnt 959

Защо ни е нужен NAnt?. 960

Основни функции. 960

Основни понятия. 961

Изпълнение на NAnt скриптове. 962

Конфигурация на скриптовете. 963

Организация на сложни скриптове. 964

Интеграция с Microsoft Visual Studio.NET. 965

Интеграция с NUnit 966

Използвана литература. 967

Други помощни средства. 967

NDoc. 967

GhostDoc. 967

Snippet Compiler 968

ASP.NET Web Matrix. 968

Tree Surgeon. 968

NDepend. 968

CruiseControl.NET. 968

Портали за инструменти. 969

Упражнения. 969

Глава 29. Практически проект. 972

Автори. 972

Необходими знания. 972

Съдържание. 972

В тази тема ... 973

Система за запознанства в Интернет – визия. 974

Какво е функционална спецификация? 974

Функционални възможности на системата за запознанства. 975

Функционални възможности на ASP.NET уеб приложението. 975

Функционални възможности на Windows Forms клиентското приложение. 978

Нефункционални изисквания към системата за запознанства по Интернет. 978

Архитектура на системата. 979

Имплементация на системата. 980

Слой за данни. 980

Бизнес слой – ASP.NET уеб услугата. 985

Имплементация на ASP.NET уеб услугата. 987

Клиентски слой – Windows Forms GUI приложение. 994

Имплементация на Windows Forms клиента. 995

Клиентски слой – ASP.NET уеб приложението. 1005

Имплементация на ASP.NET уеб приложението. 1008

Инсталиране и внедряване на системата. 1025

Системни изисквания. 1026

От къде да изтеглим системата и сорс кода й?. 1026

Възстановяване на базата данни в SQL Server 1026

Инсталиране и внедряване на ASP.NET уеб услугата. 1028

Инсталиране на Windows Forms клиента. 1030

Инсталиране на ASP.NET уеб приложението. 1030

Използвана литература. 1030

Заключение към втория том. 1032


Национална академия по разработка на софтуер

Лекторите

» Светлин Наков е автор на десетки технически публи­ка­ции и ня­колко книги, свър­­зани с раз­работката на соф­ту­ер, заради което е тър­сен лектор и кон­султант.

Той е разработчик с дъл­гого­дишен опит, работил по раз­нообразни проекти, реали­зи­рани с раз­лични техноло­гии (.NET, Java, Oracle, PKI и др.) и преподавател по съвре­мен­ни софтуерни технологии в СУ "Св. Климент Охридски".

През 2004 г. е носител на награ­дата "Джон Атанасов" на прези­дента на България Ге­орги Пър­ва­нов.

Светлин Наков ръководи обу­чението по Java технологии в Академията.

 

» Мартин Кулов е софтуерен инженер и консул­тант с дългогодишен опит в изграждането на решения с платформите на Microsoft.

Мартин е опитен инструктор и сертифициран от Майкрософт разработчик по програмите MCSD, MCSD.NET, MCPD и MVP и меж­дународен лектор в световна­та организа­ция на .NET потре­бителски­те групи INETA.

Мартин Кулов ръководи обу­чението по .NET технологии в Академията.

Академията

» Национална академия по раз­ра­ботка на софтуер (НАРС) е център за професионално обу­чение на соф­ту­ерни специалисти.

 

» НАРС провежда БЕЗПЛАТНО кур­сове по разработка на софтуер и съв­ременни софтуерни тех­нологии в Со­фия и други градове.

 

» Предлагани специалности:

§  Въведение в програмирането (с езиците C# и Java)

§  Core .NET Developer

§  Core Java Developer

 

» Качествено обу­чение с много практически про­екти и индивиду­ално внимание за всеки.

 

» Гарантирана работа! Трудов до­говор при постъпване в Академията.

 

» БЕЗПЛАТНО!

Учите безплатно във въведителните курсове и по стипендии от работода­телите в следващите нива.

http://academy.devbg.org


 

 

 

 

 

www.devbg.org

 

 

Българска асоциация на разработчиците на софтуер (БАРС) е нестопанска организация, която подпомага про­фе­сионалното развитие на българските софтуерни специ­а­листи чрез образо­вателни и други инициативи.

БАРС работи за насърчаване обмяната на опит между раз­работ­чиците и за усъвършенстване на техните знания и умения в областта на проектирането и разработката на софтуер.

Асоциацията организира специализирани конференции, семи­нари и курсове за обучение по разработка на софту­ер и софту­ерни технологии.

БАРС организира създаването на Национална академия по раз­работка на софтуер – учебен център за професионал­на подго­товка на софтуерни специалисти.

 


Предговор към втория том

Ако по принцип не четете уводите на книгите, пропуснете и този. В него ще научите най-вече какво ви предстои в следващите глави и как се стигна до написването на настоящата книга.

Това е втори том на първата чисто българска книга за програмиране с .NET Framework и C#, но въпреки, че фокусира върху .NET Framework 1.1, тя е едно от най-полезните четива в тази област. Написана от специа­листи с опит както в практическата работа с .NET, така и в обучението по програ­миране, книгата ще ви даде не само основите на .NET програми­рането, но и ще ви запознае с някои по-сложни концеп­ции и ще ви предаде от опита на авторите.

За кого е предназначена тази книга?

Вторият том на книгата е предназначен за всички, които са прочели първия том и той им допада. Тя е за всички, които искат да продължат обогатяването на знанията и уменията си за разработка на софтуер за .NET платформата.

Вторият том е просто продължение на първия и включва няколко много важни техно­логии от .NET Framework, а именно Windows Forms, ASP.NET уеб приложения и уеб услуги.

Тази книга ще ви даде много повече от начални знания. Тя ще ви предаде опит, натрупан в продъл­жение години, и ще ви запознае с утвър­дените практики при използването на .NET технологиите.

Книгата е полезна не само за .NET програмисти, но и за всички, които имат желание да се занимават сериозно с разработка на софтуер. В нея се обръща внимание не само на специфичните .NET технологии, но и на някои фундамен­тални концепции, които всеки програмист трябва добре да знае и разбира.

Необходими начални познания

Тази книга не е подходяща за хора, които никога не са програмирали в живота си. Ако сте абсолютно начинаещ, спрете да четете и просто започ­нете с друга книга!

Том 2 на книгата не е подходящ за хора, които не са чели (или поне прегледали набързо) първия том. Вторият том е естествено продължение на първия том и е силно свързан с материала, изложен в него. И двете части на книгата са свободно достъпни от Интернет (от адрес http://www. devbg.org/dotnetbook/), така че нямате оправдание да започвате направо от втората. Не ви го препоръчваме!

Какво обхваща вторият том на тази книга?

Програмирането за .NET Framework изисква познания на неговите базови концепции (модел на изпълнение на кода, обща система от типове, управ­ление на паметта, масиви, колекции, символни низове и др.), както и познаване на често използваните технологии – ADO.NET (за достъп до бази от данни), Windows Forms (за приложения с графичен потребителски интерфейс), ASP.NET (за уеб приложения и уеб услуги) и др.

Първият том на книгата обхваща основните концепции в .NET програми­рането (от езика C# до ADO.NET), а вторият – по-сложните технологии като Windows Forms, ASP.NET, уеб услуги, нишки, мрежово програмиране, сигурност и др.

Във втория том се обръща внимание на създа­ването на графичен пот­ребителски интерфейс с Windows Forms и уеб-бази­рани при­ложения с ASP.NET. Ще бъдат разгледани и някои по-сложни концепции като отра­жение на типовете, сериализация, много­нишково програмиране, уеб услуги, отдалечено извикване на методи (remoting), взаимодей­ствие с неуправляван код, асемблита, управление на сигурността, по-важни инструменти за разработка и др. Ще бъде разгледана и свободната имплементация на .NET Framework за Linux и други операци­онни системи Mono. Накрая ще бъде описана разра­ботката на един цялостен практи­чески проект, който обхваща всички по-важни технологии и демонстрира добрите прак­тики при изграждането на .NET приложения.

Фокусът е върху .NET Framework 1.1

Всички теми са базирани на .NET Framework 1.1, Visual Studio .NET 2003 и MS SQL Server 2000. За съжаление по време на изготвянето на текста на книгата (през 2004-2005 г.) версия 2.0 на .NET платформата едва прохож­даше и това наложи да не бъдат включени новостите от него.

Надяваме се в следващото издание на книгата авторският колектив да намери време и сили да обнови съдържанието с новостите от .NET 2.0 и да отправи поглед към .NET 3.0.

Как е представена информацията?

Въпреки големия брой автори, съавтори и редактори, стилът на текста в книгата е изключително достъпен. Съдържанието е представено в добре структуриран вид, разделено с множество заглавия и подзаглавия, което позволява лесното му възприемане, както и бързото търсене на инфор­мация в текста.

Настоящата книга е написана от програмисти за програмисти. Авто­рите са действащи софтуерни разработчици, хора с реален опит както в разра­ботването на софтуер, така и в обучението по програмиране. Благо­даре­ние на това качеството на изложението е на мно­го високо ниво.

Всички автори ясно съзнават, че примерният сорс код е едно от най-важните неща в една книга за програ­ми­ране. Именно поради тази причи­на текстът е съпроводен с много, много примери, илюстрации и картинки.

Въобще някой чете ли текста, когато има добър и ясен пример? Повечето програмисти първо гледат дали примерът ще им свърши работа, и само ако нещо не е ясно, се зачитат в текста (това всъщност не е никак добра практика, но такава е реалността). Ето защо многото и добре подбрани примери са един от най-важните принципи, залегнали в тази книга.

Поглед към съдържанието на втория том

Книгата се състои от 29 глави, които поради големия обем са разделени в два тома. Том 1 съдържа първите 14 глави, а том 2 – остана­лите 15. Това важи само за хартиеното издание на книгата. В електронния вариант тя се разпространява като едно цяло.

Нека направим кратък преглед на всяка една от главите и да се запознаем с нейното съдържание, за да разберем какво ни очаква по-нататък. Гла­вите от втория том можете да намерите в настоящото издание, а остана­лите – в първи том.

Глава 15. Графичен потребителски интерфейс с Windows Forms

В глава 15 се разглеждат средствата на Windows Forms за създаване на прозоречно-базиран графичен потребителски интерфейс (GUI) за .NET приложенията. Представят се програмният модел на Windows Forms, него­вите базови контроли, средствата за създаване на прозорци, диалози, менюта, ленти с инструменти и статус ленти, както и някои по-сложни концепции като: MDI приложения, data-binding, наследяване на форми, хостинг на контроли в Internet Explorer, работа с нишки във Windows Forms и др.

Автори на главата са Радослав Иванов (по-голямата част) и Светлин Наков. Текстът е базиран на лекцията на Светлин Наков по същата тема. Редактори са Светлин Наков и Пламен Табаков.

Глава 16. Изграждане на уеб приложения с ASP.NET

В глава 16 се разглежда разработката на уеб приложения с ASP.NET. Представят се програмният модел на ASP.NET, уеб формите, кодът зад тях, жизненият цикъл на уеб приложенията, различните типове контроли и техните събития. Показва се как се дебъгват и проследяват уеб прило­жения. Отделя се внимание на валидацията на данни, въведени от потре­бителя. Разглежда се концепцията за управление на състоянието на обек­тите – View State и Session State. Демонстрира се как могат да се визуа­лизират и редактират данни, съхранявани в база от данни. Диску­тират се разгръщането и конфигурирането на ASP.NET уеб приложе­нията в Internet Information Server (IIS) и сигур­ността при уеб приложенията.

Автори на главата са Михаил Стойнов, Рослан Борисов, Стефан Добрев, Деян Варчев, Иван Митев и Христо Дешев. Текстът е базиран на лекцията на Михаил Стойнов по същата тема. Редактори са Иван Митев и Пламен Табаков.

Тази глава беше най-обемната, най-трудната и най-бавно написаната. Поради някои проблемни ситуации в авторския колектив се наложи на няколко пъти да се сменят авторите и това реално забави целия втори том. За радост всичко приключи успешно.

Глава 17. Многонишково програмиране и синхронизация

В глава 17 се разглежда многозадачността в съвременните опе­рационни системи и средствата за паралелно изпълнение на програ­мен код, които .NET Framework предоставя. Обръща се внимание на ниш­ките (threads), техните състояния и управлението на техния жизнен цикъл – стартиране, приспиване, събуждане, прекратяване и др.

Разглеждат средствата за синхронизация на нишки при достъп до общи данни, както и начините за изчакване на зает ресурс и нотификация при освобождаване на ресурс. Обръща се внимание както на синхронизацион­ните обекти в .NET Framework, така и на неуправляваните синхронизаци­онни обекти от операционната система.

Изяснява се концепцията за работа с вградения в .NET Framework пул от нишки (thread pool), начините за асинхронно изпълнение на задачи, сред­ствата за контрол над тяхното поведение и препоръчваните практики за работа с тях.

Автор на главата е Александър Русев. Текстът е базиран в голямата си част на лекцията на Михаил Стойнов и авторските бележки в нея. редак­тори са Иван Митев, Георги Митев, Георги Митев, Яни Георгиев и Минчо Колев.

Глава 18. Мрежово и Интернет програмиране

В глава 18 се разглеждат някои основни средства, предлагани от .NET Framework за мрежово програмиране. Главата започва със съвсем кратко въведение в прин­ципите на работа на съвременните компютърни мрежи и на Интернет и продължава с протоколите, чрез които се осъществява мре­жовата комуни­кация. Обект на дискусия са както класовете за работа с TCP и UDP сокети, така и някои класове, предлагащи по-специфични въз­можности, като представяне на IP адреси, изпълняване на DNS заявки и др. В края на главата ще се представят средствата за извли­чане на уеб-ресурси от Интернет и на класовете за работа с e-mail в .NET Framework.

Автори на главата са Ивайло Христов и Георги Пенчев. Текстът широко използва лекцията на Ивайло Христов по същата тема. Редактори са Венцислав Попов, Стефан Чанков, Лъчезар Георгиев и Теодор Стоев.

Глава 19. Отражение на типовете (Reflection)

В глава 19 се представя понятието Global Assembly Cache (GAC) и отра­жение на типовете (reflection). Разглеждат се начините за зареждане на асембли. Демонстрира се как може да се извлече информация за типове­те в дадено асембли и за членовете на даден тип. Разглеждат се начини за динамич­но извикване на членове от даден тип. Обяснява се как може да се създаде едно асембли, да се дефинират типове в него и асемблито да се запише във файл по време на изпълнение на програмата.

Автор на главата е Димитър Канев. Текстът е базиран на лекцията на Ивайло Христов по същата тема. Редактор е Светлин Наков.

Глава 20. Сериализация на данни

В глава 20 се разглежда сериализацията на данни в .NET Framework. Обяснява се какво е сериализация, за какво се използва и как се контро­ли­ра процесът на сериализация. Разглеждат се видовете форматери (formatters). Обяснява се какво е XML сериализация, как работи тя и как може да се контролира изходният XML при нейното използване.

Автор на главата е Радослав Иванов. Текстът е базиран на лекцията на Михаил Стойнов по същата тема. Редактор е Светлин Наков.

Глава 21. Уеб услуги с ASP.NET

В глава 21 се разглеждат уеб услугите, тяхното изграждане и консумация чрез ASP.NET и .NET Framework. Обект на дискусия са основните техноло­гии, свързани с уеб услу­гите, и причината те да се превърнат в стандарт за интеграция и между­плат­формена комуникация. Представят се различни сценарии за изпол­зването им. Разглежда се програмният модел за уеб услуги в ASP.NET и сред­ствата за тяхното изграждане, изпълнение и раз­гръщане (deployment). Накрая се дискутират някои често срещани проблеми и утвърдени практики при разработката на уеб услуги чрез .NET Framework.

Автори на главата са Стефан Добрев и Деян Варчев. В текста са изпол­звани материали от лекцията на Светлин Наков по същата тема. Техни­чески редактор е Мартин Кулов.

Глава 22. Отдалечено извикване на методи (Remoting)

В глава 22 се разглежда инфраструктурата за отдалечени извик­вания, която .NET Framework предоставя на разработчиците. Обясняват се осно­вите на Remoting технологията и всеки един от нейните компо­ненти: канали, форматери, отдалече­ни обекти и активация. Дискутират се разли­ките между различните типове отдалечени обекти. Обясняват се техният жизнен цикъл и видовете маршали­зация. Стъпка по стъпка се достига до създаването на приме­рен Remoting сървър и клиент. Накрая се представя един гъвкав и практичен начин за конфигуриране на цялата Remoting инфраструктура чрез конфигурационни файлове.

Автор на главата е Виктор Живков. В текста са използвани материали от лекцията на Светлин Наков. Редактори са Иван Митев и Светлин Наков.

Глава 23. Взаимодействие с неуправляван код

Глава 23 разглежда как можем да разширим възможностите на .NET Framework чрез употреба на предоставените от Windows приложни прог­рамни интер­фейси (API). Дискутират се средствата за извикване на функ­ци­оналност от динамични Win32 библиотеки и на проблемите с прео­бразу­ва­нето (маршализацията) между Win32 и .NET типовете.

Обръща се внимание на връзката между .NET Framework и COM (компо­нентният модел на Windows). Разглеждат се както извикването на COM обекти от .NET код, така и разкриването на .NET компонент като COM обект. Демонстрира се и технологията IJW за използване на неуправляван код от програми, написани на Managed C++.

Автор на главата е Мартин Кулов. Текстът е базиран на неговата лекция по същата тема. Технически редактор е Галин Илиев.

Глава 24. Управление на паметта и ресурсите

В глава 24 се разглежда писането на правилен и ефективен код по отно­шение използването на паметта и ресурсите в .NET Framework. В началото се прави сравнение на предимствата и недостатъците на ръчното и авто­матичното управление на памет и ресурси. След това се разглежда по-обстойно авто­матич­ното им управление с фокус най-вече върху системата за почистване на паметта в .NET (т. нар. garbage collector). Обръща се внимание на взаимо­действието с нея и практиките, с които можем да й помогнем да работи възможно най-ефективно.

Автори на главата са Стоян Дамов и Димитър Бонев. Технически редактор е Светлин Наков.

Глава 25. Асемблита и разпространение (deployment)

В глава 25 се разглежда най-малката съставна част на .NET приложе­нията – асембли, различните техники за разпространение на готовия соф­туерен продукт на клиентските работни станции и някои избрани техники за създаване на инсталационни пакети и капаните, за които трябва да се внимава при създаване на инсталационни пакети.

Автор на тази глава е Галин Илиев. В текста е използвана частично лекцията на Михаил Стойнов. Редактор е Явор Янев.

Глава 26. Сигурност в .NET Framework

В глава 26 се разглежда как .NET Framework подпомага сигурността на създаваните приложения. Това включва както безопасност на типовете и защита на паметта, така и средствата за защита от изпъл­нение на неже­лан код, автентикация и оторизация, електронен подпис и криптогра­фия. Разглеждат се технологиите на .NET Framework като Code Access Security, Role-Based Security, силно-именувани асемблита, цифрово подписване на XML документи (XMLDSIG) и други.

Автори на главата са Тодор Колев и Васил Бакалов. В текста е широко използвана лекцията на Светлин Наков по същата тема. Технически редактор е Станислав Златинов.

Глава 27. Mono - свободна имплементация на .NET

В глава 27 се разглежда една от алтернативите на Microsoft .NET Framework – проектът с отворен код Mono. Обясняват се накратко начи­ните за инсталиране и работа с Mono, използването на вградените техно­логии ASP.NET и ADO.NET, както и създаването на графични приложения. Дават се и няколко съвети и препоръки за писането на преносим код.

Автори на главата са Цветелин Андреев и Антон Андреев. Текстът е бази­ран на лекцията на Антон Андреев по същата тема. Технически редактор е Светлин Наков. Като редактори участват още Соня Бибиликова, Мартин Кирицов, Николай Митев и Александър Николов.

Глава 28. Помощни инструменти за .NET разработчици

В глава 28 се разглеждат редица инструменти, използвани при разработ­ката на .NET приложения. С тяхна помощ може значително да се улесни изпълнението на някои често срещани програмистки задачи. Изброените инструменти помагат за повишаване качеството на кода, за увеличаване продуктивността на разработка и за избягване на някои традиционни трудности при поддръжката. Разглеждат се в детайли инструментите .NET Reflector, FxCop, CodeSmith, NUnit (заедно с допълненията към него NMock, NUnitAsp и NUnitForms), log4net, NHibernate и NAnt.

Автори на главата са Иван Митев и Христо Дешев. Текстът е по техни авторски материали. Редактори са Теодора Пулева и Борислав Нановски.

Глава 29. Практически проект

В глава 29 се дискутира как могат да се приложат на практика техно­логиите, разгледани в предходните теми. Поставена е задача да се раз­работи един сериозен практически проект – система за запознанства в Интернет с възможност за уеб и GUI достъп.

При реализа­цията на системата се преминава през всичките фази от раз­работката на софтуерни проекти: анализиране и дефиниране на изисква­нията, изготвяне на системна архитектура, проектиране на база от данни, имплементация, тестване и внедряване на системата.

При изготвяне на архитектурата приложението се разделя на три слоя – база от данни (която се реализира с MS SQL Server 2000), бизнес слой (който се реализира като ASP.NET уеб услуга) и клиентски слой (който се реализира от две приложения – ASP.NET уеб клиент и Windows Forms GUI клиент).

Ръководител на проекта е Ивайло Христов. Автори на проекта са: Ивайло Христов (отговорен за Windows Forms клиента), Тодор Колев и Ивайло Димов (отговорни за уеб услугата и базата данни) и Бранимир Ангелов (отговорен за ASP.NET уеб клиента). Инсталаторът на проекта е създаден от Галин Илиев. Технически редактори на кода са Мартин Кулов, Светлин Наков, Стефан Добрев и Деян Варчев.

Автори на текста са Ивайло Христов, Тодор Колев, Ивайло Димов и Бранимир Ангелов. Технически редактор е Иван Митев. Редактор на текста е Вера Моллова.

Авторският колектив

Авторският колектив се състои от над 30 души – автори, съавтори, редак­тори и други. Ще представим всеки от тях с по няколко изречения (под­редбата е по азбучен ред).

Александър Русев

Александър Русев е програмист във фирма Johnson Controls (www.jci.com), където се занимава с разработка на софтуер за леки автомобили. Завър­шил е Тех­нически университет – София, специалност компютърни системи и техно­логии. Александър се е занимавал и с разработка на софтуер за мобилни теле­фони. Професионалните му интереси включват Java техноло­гиите и .NET платформата. Можете да се свържете с Александър по e-mail: arussev@gmail.com.

Александър Хаджикръстев

Александър Хаджикръстев е софтуерен архитект със сериозен опит в областта на проектирането и разработката на уеб базирани системи и e-commerce приложения. Той е сътрудник и консултант на PC Magazine България (www.sagabg.net/PCMagazine/) и почетен член на Бъл­гарската асоциация на софтуерните разработчици (www.devbg.org). Александър има дългогодишен опит като ръководител на софтуерни проекти във фирми, базирани в България и САЩ. Професионалните му интереси са свързани с проектирането и изграждането на .NET прило­жения, разработ­ването на експертни системи и софтуер за управление и автоматизация на бизнес процеси.

Антон Андреев

Антон Андреев работи като ASP.NET уеб разработчик във фирма Elements of Art (www.eoa.bg). Той се интересува се от всичко, свързано с компют­рите и най-вече с .NET и Linux. Като ученик се е занимавал с алгоритми и е участвал в олимпиади по информа­тика. Завършил е математическа гим­назия и езикова гимназия с английски език, а в момента е студент в специалност информатика във Факул­тета по матема­тика и информатика (ФМИ) на Софийски университет "Св. Климент Охридски". Работил е и като системен админи­стратор във ФМИ и сега продължава да подпомага проектите на факул­тета, разработвайки нови сайтове. Неговият личен сайт е достъпен от адрес: http://debian.fmi.uni-sofia.bg/~toncho/portfolio/. Можете да се свър­жете с Антон по e-mail: anton.andreev@fmi.uni-sofia.bg.

Бранимир Ангелов

Бранимир Ангелов е софтуерен разработчик във фирма Gugga (www.gugga.net) и студент във Факултета по Математика и информатика на Софийски университет "Св. Климент Охридски", специалност компю­търни науки. Неговите професионални интереси са в областта на обектно-ориен­тирания анализ, моделиране и програмиране, уеб технологиите и в част­ност изграждането на RIA (Rich Internet Applications) и разработката на софтуер за мобилни устройства. Бранимир е печелил грамоти и отли­чия от различни състе­зания, както и първо място на Националната олим­пиада по информаци­онни технологии, на която е бил и жури година по-късно.

Васил Бакалов

Васил Бакалов е студент, последен курс, в Американския университет в България, специалност Информатика. Той е председател на студентския клуб по информационни технологии и е студент-консултант на Microsoft България за университета. В рамките на клуба се занимава с управление на проекти и консултации по изпълнението им. Като студент-консултант на Microsoft България Васил подпомага усилията на Microsoft да поддържа тясна връзка със студентите и да ги информира и обучава по най-новите й продукти и технологии. Васил работи и като сътрудник на PC Magazine България от няколко години и има редица статии и коментари в изда­нието. В университета той предлага и изготвя план за курс по практи­ческо изучаване на роботика, като разширение на обучението по изкуст­вен интелект, който е одобрен и внедрен. Той работи и с няколко ИТ фирми, където изгражда решения, базирани на .NET плат­формата. Прите­жава професио­нална сер­тифика­ция от Microsoft. Можете да се свържете с Васил по e-mail: dotnetbook@vassil.info.

Виктор Живков

Виктор Живков е софтуерен инженер в Интерконсулт България (www.icb.bg). В момента е студент в Софийски Университет "Св. Климент Охридски", специалност информатика. Професионалните му интереси са основно в областта на решенията, базирани на софтуер от Microsoft. Виктор има сериозен опит в работата с .NET Framework, Visual Studio .NET и Microsoft SQL Server. Той участва в проекти за различни информационни системи, главно за Норвегия. Членува в БАРС от 2005 година. За връзка с Виктор можете да използвате неговия e-mail: viktor.zhivkov@gmail.com.

Деян Варчев

Деян Варчев е старши уеб разработчик във фирма Vizibility (www.vizibility.net). Неговите отговорности включват проектиране­то и разработката на уеб базирани приложения, използващи последните тех­нологии на Microsoft, проучване на новопоявяващи се технологии и пла­ниране на тяхното внедряване в производството, както и обучение на нови колеги. Неговите професионални интереси са свързани тясно с технологиите на Microsoft – .NET платформата, SQL Server, IIS, BizTalk и др. Деян е студент по информатика във Факултета по математика и информатика на Софийски университет "Св. Климент Охридски".

Димитър Бонев

Димитър Бонев е софтуерен разработчик във фирма Formula Telecom Solutions (www.fts-soft.com). Той отговаря за разработването на уеб бази­рани приложения за корпоративни клиенти, както и за някои модули и инструменти, свързани с вътрешния процес на разработка във фирмата. Професионалните му интереси са насочени предимно към .NET платфор­мата, методологията extreme programming и софтуерния дизайн. Димитър е завършил ВВВУ "Г. Бенковски", специалност компютърна техника. Той има богат опит в разработването на софтуерни решения, предимно с тех­нологиите на Microsoft и Borland.

Димитър Канев

Димитър Канев е разработчик на софтуер във фирма Медсофт (www.medsoft.biz). Той е завършил Факултета по математика и информа­тика на Софийски университет "Св. Кли­мент Охридски", специалност информатика. Професио­налните му интере­си са основно в областта на решенията, базирани на софтуер от Microsoft. Димитър има сериозен опит в работата с Visual Studio .NET, Microsoft SQL Server и ГИС системи. Рабо­тил е в проекти за изграждане на големи информационни системи, свър­зани с ГИС решения, и експертни системи за медицински лаборатории.

Галин Илиев

Галин Илиев е ръководител на проекти и софтуерен архитект в бъл­гарския офис на Technology Services Consulting Group (www.wordassist.  com). Галин е участвал в проектирането и разработ­ването на големи информационни системи, Интернет сайтове с управление на съдържа­нието, допълнения и интеграция на MS Office със системи за управление на документи. Той притежава степен бакалавър по менидж­мънт и инфор­ма­ционни технологии, а също и сертификация MCSD за Visual Studio 6.0 и Visual Studio .NET. Той има сериозен опит с работата с Visual Studio .NET, MS SQL Server, MS IIS и MS Exchange. Личният му сайт е достъпен от адрес www.galcho.com, а e-mail адресът му е Iliev@galcho.com.

Георги Пенчев

Георги Пенчев е софтуерен разработчик във фирма Symex България (www.symex.bg), където отговаря за разработка на финансово ориенти­рани графични Java приложения и на Интернет финансови портали с Java и PHP. Участвал е в изграждането на продукти за следене и обработка на борсови индекси и котировки за Българската фондова борса. Георги е студент по информатика във Факултета по математика и инфор­матика на Софийски университет "Св. Климент Охридски". Професионалните и ака­де­мичните му инте­реси са насочени към Java и .NET технологиите, биоин­форматикатa, тео­ретичната информатика, изкуствения интелект и базите от знания. През 2004 и 2005 г. е асистент в курса по "Информационни технологии" за студенти с нарушено зрение и в практическия курс по "Структури от данни и програ­миране" в Софийски университет. Можете да се свържете с Георги по e-mail: pench_wot@yahoo.com.

Иван Митев

Иван Митев е софтуерен разработчик във фирма EON Technologies (www.eontechnologies.bg). Той е завършил Факултета по математика и информатика на Софийски университет "Св. Климент Охридски", специал­ност информатика. Иван е участвал в проектирането и реализацията на множество информа­ционни системи, основно ГИС решения. Професионал­ният му опит е в разработки предимно с продукти и технологии на Microsoft. Основните интереси на Иван са в създаването на качествени и ефективни софтуерни решения чрез използването на подходящи прак­тики, технологии и инстру­менти. Технически уеблог, който той поддържа от началото на 2004 година, е с акцент върху .NET програмирането и е достъпен на адрес http://immitev.blogspot.com. Можете да се свържете с Иван по e-mail: immitev@gmail.com.

Ивайло Димов

Ивайло Димов е софтуерен разработчик във фирма Gugga (www.gugga.com). Неговите интереси са в областта на обектно-ориенти­раното моделиране, програмиране и анализ, базите от данни, уеб прило­женията и приложения, базирани на Microsoft .NET Framework. В момента Ивайло е студент във Факултета по математика и информатика на Софий­ски университет "Св. Климент Охридски", специалност Компютърни науки. Той е сертифициран от Microsoft разработчик и е печелил редица грамоти и отличия от състе­зания по програмиране. През 2004 г. е победител в Националната олим­пиада по информационни технологии и е участвал в журито на същата олимпиада година по-късно.

Ивайло Христов

Ивайло Христов е преподавател в Софийски университет "Св. Климент Охридски", където води курсове по "Програмиране за .NET Framework", "Качествен програмен код", "Увод в програмирането", "Обектно-ориенти­рано програмиране" и "Структури от данни в програмирането". Неговите професионални инте­реси са в областта на .NЕТ технологиите и Интернет технологиите. Като ученик Ивайло е участник в редица национални състе­зания и конкурси по програмиране и е носител на престижни награди и отличия. Той участва в екип, реализирал образователен проект на Microsoft Research в областта на .NET Framework. Личният сайт на Ивайло е достъпен от адрес: www.ivaylo-hristov.net.

Лазар Кирчев

Лазар Кирчев е завършил Факултета по математика и информатика на Софийски университет "Св. Климент Охридски" и в момента е дипломант в специализация "Информационни системи". Той работи в Института за паралелна обра­ботка на информацията към БАН по съвместен проект между Факултета по математика и информатика и БАН за изграждане на grid система. Неговите интереси включват .NET платформата, grid систе­мите и базите от данни.

Манол Донев

Манол Донев е софтуерен разработчик във фирма telerik (www.telerik.  com). Той е част от екипа, който разработва уеб-базираната система за управление на съдържание Sitefinity (www.sitefinity.com). Манол е студент във Факултета по математика и информатика на Софийски университет "Св. Климент Охридски", специалност Информатика. Неговите професио­нални интереси обхващат най-вече .NET технологиите (в частност ASP.NET уеб приложе­ния, XML и уеб услуги). Можете да се свържете с Манол по e-mail: manol.donev@gmail.com.

Мартин Кулов

Мартин Кулов е сертифициран инструктор и разработчик по програмите Microsoft Certified Trainer (MCT) и MCSD.NET. През 2006 г. е награден от Майкрософт с наградата Most Valuable Professional (MVP). Той е директор направление .NET към Национална академия по разработка на софтуер, където е отговорен за разработка на курсове, обучение и проучване на най-новите технологии на Майкрософт като Visual Studio Team System, Indigo, WSE, ASP.NET, Analysis Services 2005, VSTO, Atlas и др. Мартин е почетен член на Българската асоциация на разра­ботчиците на софтуер (БАРС), член на SofiaDev .NET потребителската група, лектор при меж­ду­народната .NET асоциация - INETA и лектор на редица семинари на Майкрософт. Той е регионален президент на Междуна­родната асоциация на софтуерните архитекти (IASA) за България. Неговият личен дневник (блог) може да намерите на адрес http://www.codeattest.com/blogs/martin.

Михаил Стойнов

Михаил Стойнов е софтуерен разработчик във фирма MPS (www.mps.bg), която е подизпълнител на Siemens A.G. Той се занимава професи­онално с програмиране за платформите Java и .NET Framework от няколко години. Участва като лектор в преподава­телския екип на курсовете "Програмира­не за .NEТ Framework" и "Качес­твен програмен код". Той е студент-кон­султант на Майкро­софт България за Софийски университет през послед­ните 2 години и подпомага раз­пространението на най-новите продукти и технологии на Microsoft в университета. Михаил е бил лектор на меж­дународни конференции за ГИС сис­теми. Интересите му обхващат разра­ботка на уеб приложения, прило­же­ния с бази от данни, изграждане на сървърни системи и участие в ака­де­мични дейности.

Моника Алексиева

Моника Алексиева е софтуерен разработчик във фирма Солвер / Мидакс (www.midax.com). В момента следва специалност информатика във Факул­тета по математика и информатика на Софийски университет "Св. Климент Охридски". Моника има професионален опит в разработката за .NET Framework с езика C# и е сертифициран от Microsoft разработчик за .NET платформата. Нейните интереси са в областта на технологиите за изграж­дането на графичен пот­ребителски интерфейс и разработката на прило­жения за мобилни уст­ройства. През 2004 година Моника е асистент по "Структури от Данни" в Софийски университет.

Николай Недялков

Николай Недялков е президент на Асоциацията за информационна сигур­ност (www.iseca.org) която е създадена с цел прилагане на най-добрите практики за осигуряване на информационната сигурност на национално ниво и при извършването на електронен бизнес. Николай е професиона­лен разработчик на софтуер, консултант и преподавател с дългогодишен опит. Той е автор на статии и лектор на множество конференции и семи­нари в област­та на софтуерните техноло­гии и информационна си­гурност. Преподавателският му опит се простира от асистент по "Струк­тури от данни в програмирането", "Обектно-ориентирано програ­ми­ране със C++" и "Visual C++" до лектор в курсовете "Мрежова сигур­ност", "Сигурен програмен код", "Интернет програмиране с Java", "Кон­струиране на качествен програмен код", "Програмиране за платформа .NET" и "Раз­работка на приложения с Java". Интересите на Николай са концентрирани върху техническата и бизнес страната на информацион­ната сигурност, Java и .NET технологиите и моделирането и управлението на бизнес про­цеси в големи организации. Николай има бакалавърска степен от Факул­тета по математика и информатика на Софийски университет "Св. Климент Охридски". Като ученик е дългогодишен състеза­тел по програмиране, с редица призови отличия. През 2004 г. е награден от Президента на България Георги Първанов за приноса му към развитието на информаци­онните технологии и информационното общество. Той е почетен член на БАРС. Личният му сайт е достъпен от адрес: www.nedyalkov.com.

Панайот Добриков

Панайот Добриков е софтуерен архитект в SAP A.G., Java Server Technology (www.sap.com), Германия и е отговорен за координа­цията на софтуерните разработки в SAP Labs България. Той е завършил Факултета по математика и информатика на Софийски университет "Св. Климент Охридски", специалност информатика. Панайот е дългогодишен участник (като състе­зател и ръководител) в ученически и студентски състезания по програми­ране и е носител на много престижни награди в страната и чужбина. Той е автор на книгите "Програмиране = ++Алгоритми;" (www. algoplus.org) и "Java Programming with SAP Web Application Server", както и на десетки научно-технически публикации. През периода 2001-2003 води курсовете "Проек­ти­ране и анализ на компютърни алгоритми" и "Прагматика на обектното програмиране" в Софийски университет. Може­те да се свържете с Панайот по e-mail: dobrikov@gmail.com.

Преслав Наков

Преслав Наков е аспирант по изкуствен интелект в Калифорнийския университет в Бъркли (www.berkeley.edu), САЩ. Неговият профе­сионален опит включва шестгодишна работа като софтуерен разработчик във фир­мите Комсофт (www.comsoft.bg) и Рила Солюшънс (www.rila.bg). Инте­ре­сите му са в областта на компютърната лингвистика и биоинформа­тикатa. Преслав получава магистърската си степен по информатика от Софийски университет "Св. Климент Охридски". Той е носител е на бронзов медал от Балканиада по инфор­матика, заемал призови места в десетки национални състезания по прог­рамиране като ученик и студент. Състезател е, а по-късно и тре­ньор на отбора на Софийския университет, участник в Светов­ното между­университетско състезание по програмиране (ACM International Collegiate Programming Contest). Той е асистент в мно­жество курсове във Факултета по математика и информатика на Софийски университет, лектор-основател на курсовете "Проектиране и анализ на компютърни алгоритми" и "Моделиране на данни и проектиране на бази от данни". Преслав е автор на книгите "Основи на компютър­ните алгорит­ми" и "Прог­рамиране = ++Алгоритми;" (www.algoplus.org). Той има десетки научни и научнопопулярни публикации в престижни между­народни и национални издания. Той е първият носител на наградата "Джон Атанасов" за принос към развитието на информационните техно­логии и информационното общество, учредена от президента на България Георги Първанов.

Радослав Иванов

Радослав Иванов е софтуерен разработчик във фирма Медсофт (www.  medsoft.biz) и студент в специалност информатика във Факултета по мате­матика и информатика на Софийски университет "Св. Климент Охридски". Професио­налните му интереси са в областта на информационната сигур­ност и про­дуктите и технологиите на Microsoft.

Рослан Борисов

Рослан Борисов е софтуерен инженер във фирма Сирма Груп (www.sirma.bg), звено на Сирма Бизнес Консултинг. Професионалните му интереси са свързани основно с изграждане на приложения, базирани на технологии на Microsoft. Специализирал е в областта на билинг системи, като и основни и сателитни банкови системи. Има сериозен опит с платформата .NET Framework и сървърите за бази от данни Microsoft SQL Server и Oracle. Участва в различни проекти, свързани с български и чужди банки. В момента Рослан е студент в Нов български университет, специалност информатика. Можете да се свържете с него на e-mail: rosborisov@gmail.com.

Светлин Наков

Светлин Наков е директор на направление "обучение" на Националната академия по разработка на софтуер (http://academy.devbg.org), където обучава софтуерни специа­листи за практическа работа в ИТ индустрията с Java и .NET платформите. Той е хоноруван пре­подавател по съвременни софтуерни технологии в Софийски университет "Св. Климент Охридски", където води курсове по "Проектиране и анализ на компютърни алго­ритми", "Интернет програмиране с Java", "Мрежова сигурност", "Програми­ране за .NET Framework", "Качествен програмен код" и "Разработка на уеб приложения с Java". Светлин има сериозен професио­нален опит като софтуерен разра­ботчик и консултант. Неговите интереси обхващат Java технологиите, .NET платформата и информационната сигурност. Той е завършил бакалавър­ската и магистърската си степен във Факултета по математика и информа­тика на Софийски университет "Св. Климент Охридски". Като ученик и студент Светлин е победител в десетки национални състе­зания по програ­миране и е носител на 4 медала от международни олимпи­ади по информа­тика. Той има десетки научни и технически публикации, свързани с раз­работката на софтуер, в български и чуждестранни списа­ния и е автор на книгите "Интернет програмиране с Java", "Java за цифрово подпис­ване на документи в уеб" и ръководител на двата тома на настоящата книга. През 2003 г. той е носител на наградата "Джон Атанасов" на фондация Еврика. През 2004 г. получава награда "Джон Атанасов" от президента на България Георги Първанов за приноса му към развитието на информационните тех­нологии и информа­ционното общест­во. Светлин е един от учредителите на Българската асо­циация на разра­ботчиците на софтуер (www.devbg.org) и понастоящем неин пред­седател.

Стефан Добрев

Стефан Добрев е старши уеб разработчик във фирма Vizibility (www.vizibility.net). Той отговаря за голяма част от .NET продук­тите, раз­работвани в софтуерната компания, в това число уеб базирана система за изграждане на динамични сайтове и управление на тяхното съдържание, уеб система за управление на контакти и др. Негова отго­ворност е и внедряването на утвърдените практики и методологии за раз­работка на софтуер в производствения процес. Професионалните му интереси са насочени към уеб технологиите, в частност ASP.NET, XML уеб услугите и цялостната разработка на приложения, базирани на .NET Framework. Стефан следва информа­тика във Факултета по математика и информатика на Софийски университет "Св. Климент Охридски".

Стефан Кирязов

Стефан Кирязов е софтуерен разработчик във фирма Верео Технолъджис (www.vereo.bg). Той се занимава професионално с разработка на .NET решения за бизнеса и държавната администрация. Опитът му включва изграждане на уеб и настолни приложения с технологии на Microsoft, а също и Java и Oracle. Завършил е Факултета по математика и информа­тика на Софийски университет "Св. Климент Охридски", специалност информатика. Неговите професионални интереси включват архитектура, дизайн и методологии за разработка на големи корпоративни приложения. За контакти със Стефан можете да използвате неговия e-mail: stefan.kiryazov@gmail.com.

Стефан Захариев

Стефан Захариев работи като софтуерен разработчик в Интерконсулт България (www.icb.bg), където е отговорен за създаването на инструменти за автоматизиране на процеса на разработка. Той има дълго­годишен опит в създаването на ERP системи, който натрупва при работата си в различни фирми в България. Основните му интереси са свързани със системите за управление на бази от данни, платформата .NET, ORM инструментите, J2ME, както и Borland Delphi. При завършването си на средното образова­ние в "Технологично училище – Електронни системи", печели отличителна награда за цялостни постижения. През 2005 г. завър­шва "Технически университет – София", където се дипломира като бака­лавър във факулте­та по "Компютърни системи и управление". Той членува в БАРС и в Софийската .NET потребителска група Можете да се свържете със Стефан по e-mail: stephan.zahariev@gmail.com.

Стоян Дамов

Стоян Дамов е софтуерен консултант, пич, поет и революционер. Можете да се свържете с него по e-mail: stoyan.damov@gmail.com или от неговия личен сайт: http://spaces.msn.com/members/stoyan/.

Тодор Колев

Тодор Колев е софтуерен разработчик в Gugga (www.gugga.com) и сту­дент във Факултета по математика и информатика на Софийски универ­ситет "Св. Климент Охридски", специалност Информатика. Неговите про­фесио­нални интереси са в областта на обектно-ориентирания анализ, моделиране и програми­ране, уеб технологиите, базите данни и RIA (Rich Internet Applications). Тодор е дългогодишен участник в състезания по информатика и информа­ционни технологии, печелил редица грамоти и отличия, както и сребърен медал на международна олимпиада по инфор­мационни технологии. Той е носител на първо място от националната олимпиада по информационни технологии и е участвал в журито на същата олимпиада година по-късно. Тодор има множество разработки в сферата на уеб технологиите и е участвал в изследователски екип в Масачузетският технологичен инсти­тут (MIT). Той е сертифициран Microsoft специалист.

Христо Дешев

Христо Дешев е разработчик на ASP.NET компоненти във фирма telerik (www.telerik.com). Той е завършил Американския университет в България, специалност информатика. Основните му интереси са в областта на подо­бряването на процеса на разработка на софтуер. Той е запален привър­женик на Agile методологиите, основно на Extreme Programming (XP). Про­фесионалният му опит е предимно в разработката на решения с кратък цикъл за обратна връзка, високо покритие от тестове и почти пълна автоматизация на всички нива от работния процес.

Христо Радков

Христо Радков е управител на фирма за софтуерни консултантски услуги Calisto ID (www.calistoid.com). Той е бакалавър от английската специал­ност "Manufacturing Engineering" в Технически Университет – София и магистър по информаци­онни и комуникационни технологии във Факултета по математика и информатика на Софийски университет "Св. Климент Охридски". Притежава сертификационна степен от Microsoft - MCSD.NET.  Христо има дългогодишен опит с различни сървъри за бази от данни и сериозен опит с различни технологии на Microsoft, Borland, Sun и Oracle. Участник и ръководител е в проекти за изграждане на няколко големи информа­ционни системи, динамични Интернет портали и др. Под негово ръковод­ство е създаден най-успешния складово-счетоводен соф­туер за фарма­цевтични предприятия в страната. Като ученик Христо има множес­тво участия и награди от олимпиади по мате­матика в страната и чужбина.

Цветелин Андреев

Цветелин Андреев е софтуерен инженер във фирма Dreamix Ltd. (www.dreamix.eu). Той е член на Българската асо­циация на разработчи­ците на софтуер и е инструктор към Националната академия по разработ­ка на софтуер. Цветелин участва като лектор в редица курсове и семи­нари. Изявява се и като консултант по използване на модерни уеб техно­логии. Част от интересите му са свързани с платформата FreeBSD, в част­ност използването й за разработка на софтуер. Член е на групата на бъл­гарските потребители на FreeBSD (freebsd-bg.org). Цветелин е завършил бакалавърска степен по информатика във Факултета по математика и информатика на Софийски университет "Св. Климент Охридски", а сега е студент по Стопанско Управление в същия университет. Личният му уеб сайт е достъпен от адрес: www.flowerlin.net.

Явор Ташев

Явор Ташев е софтуерен разработчик във фирма ComMetric (www. commetric.com). Той е завършил Факултета по математика и информа­тика на Софийски университет "Св. Климент Охридски", специалност информа­тика. Участвал е в разработката на големи корпоративни сайтове, комуни­ка­ционни системи и решения за обработка на статистически данни и прогнозиране с методи на изкуствен интелект, използвайки технологиите и платформите на Microsoft. Интере­сите му са насо­чени към .NET платфор­мата, Java и из­куствения интелект. Професионал­ният му опит е свързан предимно с .NET Framework, Visual Studio .NET, Microsoft SQL Server и Microsoft Internet Information Server.

Благодарности

Настоящата книга стана реалност благодарение на много хора и няколко организации, които помогнаха и допринесоха за проекта. Нека изкажем своята благодарност и уважение към тях.

Светлин Наков

На първо място трябва да благодарим на главния орга­низатор и ръково­дител на проекта, Светлин Наков, който успя да мотивира над 30 души да участват в начи­нанието и успя да ги ръководи успешно през всичките месеци на работата по проекта. Той успя да реализира своята идея за създаване на чисто българска книга за програмиране с .NET Framework най-вече благодарение на всички доб­роволни участници, които дариха своя труд за проекта и отделиха от малкото си свободно време за да спо­делят своите знания и опит безвъзмездно, за каузата.

Авторският колектив

Авторският колектив е наистина главният виновник за съществуването на тази книга. Текст с такъв обем и такова качество не може да бъде написан от един или двама автора за по-малко от няколко години, а до тогава инфор­мацията може вече да остаряла.

Идеята за участие на толкова много автори се оказа успешна, макар и координацията между тях да не беше лесна. Въпреки, че отделните глави от книгата са писани от различни автори, те следват единен стил и високо качество. Всички глави са добре структурирани, с много заглавия и подза­главия, с много и подходящи примери, с добър стил на изказ и еднакво форматиране.

Българска асоциация на разработчиците на софтуер

Проектът получи силна подкрепа от Българската асоциация на разработ­чиците на софтуер (БАРС), тъй като е в синхрон с нейните цели и идеи.

БАРС официално държи правата за издаване и разпространение на кни­гата в хартиен вид, но няма право да реализира печалба от тази дей­ност. Асоциацията чрез своите контакти успя да намери финансиране за отпе­чатването на книгата, както и хостинг за нейния уеб сайт и форум.

Microsoft Research

В ранните си фази, когато бяха изготвени лекциите за курса "Програ­миране за .NET Framework", проектът получи подкрепа и частично финан­сиране от Microsoft Research. Ако не беше тази подкрепа, вероятно няма­ше да се стигне до създаването на лекциите и до написването на книгата.

SciForge.org

Порталът за организиране на работата в екип SciForge.org даде своя при­нос към проекта, като предостави среда за съвместна работа, включваща система за контрол над версиите, форум, пощенски списък (mailing list) и някои други средства за улеснение на работата.

Благодарностите са отправени главно към създателя на портала и негов главен администратор Калин Наков (www.kalinnakov.com), който указваше редовно съдействие в случай на технически проблеми.

Софийски университет "Св. Климент Охридски"

Факултетът по математика и информатика (ФМИ) на Софийски универ­ситет "Св. Климент Охридски" подпомогна проекта глав­но в началната му фаза, като подкрепи предложението на преподавателския екип от курса "Програми­ране за платформа .NET" за участие в конкурса на Microsoft Research. По-късно факултетът продължи да подкрепя инициативите на авторския колектив на книгата като им позволи да провеждат изборни курсове по програмиране за .NET Framework 1.1 и 2.0 за студентите от Софийски университет.

telerik

Софтуерната компания telerik (www.telerik.com) подкрепи проекта чрез осигуряване на финансиране за отпечатване на книгата на хартия. Изказ­ваме благодарности от името на целия авторски колектив.

Сайтът на книгата

Официалният уеб сайт на книгата "Програмиране за .NET Framework" е достъпен от адрес: http://www.devbg.org/dotnetbook/. От него можете да изтеглите цялата книга в електронен вид, лекциите, на които тя е бази­рана, както и сорс кода на практическия проект от глава 29, за който има специално изготвена инсталираща програма.

Към книгата е създаден и дискусионен форум, който се намира на адрес: http://www.devbg.org/forum/index.php?showforum=30. В него можете да дискутирате всякакви технически и други проблеми, свързани с книгата, да отправяте мнения и коментари и да задавате въпроси към авторите.

Лиценз

Книгата и учебните материали към нея се разпространяват свободно по следния лиценз:

Общи дефиниции

1.  Настоящият лиценз дефинира условията за използване и разпрост­ранение на комплект учебни материали и книга по "Програмиране за .NET Framework", разработени от екип под ръководството на Светлин Наков (www.nakov.com) с подкрепата на Българска асоциа­ция на разработ­чиците на софтуер (www.devbg.org) и Microsoft Research (research.microsoft.com).

2.  Учебните материали се състоят от:

-     презентации;

-     примерен сорс код;

-     демонстрационни програми;

-     задачи за упражнения;

-     книга (учебник) по програмиране за .NET Framework с езика C#.

3.  Учебните материали са достъпни за свободно изтегляне при усло­вията на настоящия лиценз от официалния сайт на проекта:

http://www.devbg.org/dotnetbook/

4.  Автори на учебните материали са лицата, взели участие в тяхното изработване. Всеки автор притежава права само над продуктите на своя труд.

5.  Потребител на учебните материали е всеки, който по някакъв начин използва тези материали или части от тях.

Права и ограничения на потребителите

1.  Потребителите имат право:

-     да използват учебните материали или части от тях за всякакви цели, включително да ги да променят според своите нужди и да ги използват при извършване на комерсиална дейност;

-     да използват сорс кода от примерите и демонстрациите, включени към учебните материали или техни модификации, за всякакви нужди, включително и в комерсиални софтуерни продукти;

-     да разпространяват безплатно непроменени копия на учебните материали в електронен или хартиен вид;

-     да разпространяват безплатно оригинални или променени части от учебните материали, но само при изричното споменаване на източника и авторите на съответния текст, програмен код или друг материал.

2.  Потребителите нямат право:

-     да разпространяват срещу заплащане учебните материали или части от тях (включително модифицирани версии), като изклю­чение прави само програмният код;

-     да премахват настоящия лиценз от учебните материали.

Права и ограничения на авторите

1.  Всеки автор притежава неизключителни права върху продуктите на своя труд, с които взима участие в изработката на учебните мате­риали.

2.  Авторите имат право да използват частите, изработени от тях, за всякакви цели, включително да ги изменят и разпространяват срещу заплащане.

3.  Правата върху учебните материали, изработени в съавторство, са притежание на всички съавтори заедно.

4.  Авторите нямат право да разпространяват срещу заплащане учебни материали или части от тях, изработени в съавторство, без изрич­ното съгласие на всички съавтори.

Права и ограничения на БАРС

Ръководството на Българска асоциация на разработчиците на софтуер (БАРС) има право да разпространява учебните материали или части от тях (включително модифицирани) безплатно или срещу заплащане, но без да реализира печалба от продажби.

Права и ограничения на Microsoft Research

Microsoft Research има право да разпространява учебните материали или части от тях по всякакъв начин – безплатно или срещу заплащане, но без да реализира печалба от продажби.

 

Светлин Наков,

01.11.2006 г.


Глава 15. Изграждане на графичен потребителски интерфейс с Windows Forms

Автори

Светлин Наков

Радослав Иванов

Необходими знания

-     Базови познания за .NET Framework

-     Базови познания за езика C#

-     Базови познания за делегатите и събитията в .NET Framework

-     Начални умения за работа с Visual Studio .NET и Windows Forms редактора му

Съдържание

-     Какво е Windows Forms?

-     Програмни компоненти. Компонентен модел на .NET

-     Програмен модел на Windows Forms. Модел на пречертаване на контролите

-     Основни класове. Йерархия на класовете

-     Класът Control. Други базови контроли

-     Форми, прозорци и диалози – класът Form

-     Основни контроли – TextBox, Label, Button

-     Поставяне на контроли във формата

-     Управление на събитията

-     Windows Forms редакторът на VS.NET

-     Стандартни диалогови кутии

-     Извикване на диалогови кутии

-     Други Windows Forms контроли. Менюта. Ленти с инструменти. Статус ленти

-     Диалог за избор на файл

-     MDI приложения

-     Валидация на данни

-     Свързване на данни (Data Binding). Навигация с CurrencyManager

-     Контролата DataGrid

-     Master-Details навигация

-     Наследяване на форми

-     Пакетът System.Drawing и GDI+

-     Печатане на принтер

-     Потребителски контроли

-     Хостинг на контроли в Internet Explorer

-     Нишки и Windows Forms

-     Влачене (Drag and Drop)

-     Конфигурационен файл на приложението

В тази тема ...

В настоящата тема ще разгледаме средствата на Windows Forms за създа­ване на прозоречно-базиран графичен потребителски интерфейс (GUI) за .NET приложенията. Ще се запознаем с програмния модел на Windows Forms, неговите базови контроли, средствата за създаване на прозорци, диалози, менюта, ленти с инструменти и статус ленти, както и с някои по-сложни концепции: MDI приложения, data-binding, наследяване на форми, хостинг на контроли в Internet Explorer, работа с нишки в Windows Forms и др.


Какво е Windows Forms?

Windows Forms е стандартната библиотека на .NET Framework за изграж­дане на прозоречно-базиран графичен потребителски интерфейс (GUI) за настолни (desktop) приложения. Windows Forms дефинира набор от класове и типове, позволяващи изграждане на прозорци и диалози с графични контроли в тях, чрез които се извършва интерактивно взаимо­дей­ствие с потребителя.

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

Windows Forms е базирана на RAD концепцията

В .NET Framework и особено в Windows Forms се поддържа концепцията за Rapid Application Development (RAD).

Какво е RAD?

RAD е подход за разработка, при който приложенията се създават визу­ално чрез сглобяване на готови компоненти посредством помощници и инструменти за автоматично генериране на голяма част от кода. В резул­тат приложенията се разработват много бързо, с малко ръчно писане на код и с намалени усилия от страна на програмиста.

При компонентно-ориентираната разработка всеки компонент решава някаква определена задача, която е част от проекта. Компонентите се поставят в приложението, след което се интегрират един с друг чрез настройка на техните свойства и събития. Свойствата на всеки компонент определят различни негови характеристики, а събитията служат за управ­ление на действията, които са предизвикани от него.

Windows Forms позволява бърза визуална разработка

Windows Forms е типична компонентно-ориентирана библиотека за създа­ване на GUI, която предоставя възможност с малко писане на програмен код да се създава гъвкав графичен потребителски интерфейс.

Windows Forms позволява създаването на формите и другите елементи от графичния интерфейс на приложенията да се извършва визуално и интуи­тивно чрез подходящи редактори, като например Windows Forms Designer във Visual Studio .NET. По-нататък в настоящата тема ще разгледаме по-подробно конкретните въз­можности, които VS.NET предоставя за създа­ване на Windows Forms приложения.

Windows Forms и другите библиотеки за изграждане на GUI

Windows Forms прилича на много други библиотеки за изграждане на графичен потребителски интерфейс (GUI), но и сериозно се различава от повечето от тях.

Windows Forms и VCL

На идейно ниво Windows Forms много прилича на библиотеката Visual Component Library (VCL) от Delphi. Приличат си в голяма степен дори самите контроли, техните имена, свойства и събития. Това вероятно се дължи до голяма степен на участието на главния архитект на Delphi Андерс Хейлсбърг в разработката на Windows Forms и .NET Framework.

Windows Forms и Visual Basic 6

По начина на разработка Windows Forms прилича много и на Visual Basic 6, който позволява визуално изграждане на интерфейса, чрез влачене на компоненти и настройка на свойства и събития, също както в Delphi.

Windows Forms и MFC

По своята мощ Windows Forms не отстъпва на по-старите средства за изграждане на GUI, например MFC (Microsoft Foundation Classes) библиоте­ката, която се използваше във Visual C++ преди Microsoft да вземат стратегическото решение разработката на GUI за Windows да преминава постепенно към .NET Framework и Windows Forms.

За разлика от MFC, при Windows Forms, интерфейсът се изгражда няколко пъти по-бързо, по-лесно и почти без да се пише програмен код.

Windows Forms и Java AWT/Swing

AWT и Swing са библиотеки за изграждане на прозоречно-базиран GUI, които се използват при Java платформата. Програмният модел на Windows Forms има съществени разлики от програмния модел на AWT и Swing и причините за това произхождат най-вече от факта, че AWT и Swing са преносими библиотеки, предназначени да работят на много операционни системи, докато Windows Forms е базирана на Win32 API.

Контролите в Windows Forms

Windows Forms съдържа богат набор от стандартни контроли: форми, диалози, бутони, контроли за избор, текстови полета, менюта, ленти с инструменти, статус ленти и много други. В допълнение към стандартните контроли Windows Forms позволява на разработчиците по лесен начин да създават допълнително собствени контроли, които да използват като части в приложенията си.

В Интернет могат да се намерят безплатно или срещу лицензна такса голям брой библиотеки от контроли, които решават често срещани проб­леми и спестяват време на разработчика при реализацията на често сре­щани задачи. Съществуват дори цели софтуерни компании, които профе­сионално се занимават с производството на компоненти и контроли (като Infragistics, ComponentOne и българската telerik).

Windows Forms и работа с данни

Windows Forms предоставя много контроли за визуализация и редактира­не на данни – текстови, списъчни и таблични. За спестяване на време на разработчика е въведена концепцията "свързване на данни" (data binding), която позволява автоматично свързване на данните с контролите за тяхната визуализация. Ще обърнем специално внимание на концепци­ята "data binding" по-късно в настоящата тема.

Вградена поддръжка на Unicode

В Windows Forms поддръжката на Unicode е вградена. Всички контроли са съобразени с Unicode стандарта и позволяват използване на много езици и азбуки (латиница, кирилица, гръцки, арабски и др.) без допълнителни настройки на Windows или на приложението.

Наследяване на форми и контроли

Windows Forms е проектирана така, че да позволява лесно наследяване и разширяване на форми и контроли. Това дава възможност за преизполз­ване на общите части на потребителския интерфейс. По-нататък в настоя­щата тема ще демонстрираме как точно се реализира това.

ActiveX контроли

Преди появата на .NET Framework Windows приложенията са били бази­рани на програмния модел "Win32". В Win32 среда се използват т. нар. ActiveX контроли, които се реализират чрез компонентния модел на Windows (COM – Component Object Model).

ActiveX контролите представляват графични компоненти. Те имат свой­ства, чрез които им се задават различни характеристики, и събития, управляващи поведението им.

ActiveX контролите много приличат на Windows Forms контролите от .NET Framework, но за разлика от тях се реализират с неуправляван код и преди използване трябва да се регистрират чрез добавяне в регистрите на Windows (Windows Registry).

Поради дългия период на развитие на Win32 платформата, има изключи­телно много ActiveX контроли, които са създадени с течение на годините от различни софтуерни производители.

В .NET Framework по лесен начин, без да се пише ръчно програмен код, могат да се използват вече разработени ActiveX контроли. Например можем да вградим уеб браузъра Internet Explorer или четеца на PDF документи Adobe Acrobat Reader като част от наше приложение. Как точно се използват ActiveX контроли в Windows Forms ще разгледаме в темата "Взаимодействие с неуправляван код".

Печатане на принтер

В Windows Forms са предоставени удобни средства за печатане на доку­менти на принтер. Те предоставят достъп до всички стандартни диалози за печат, чрез които потребителите избират печатащо устройство и настрой­ват неговите характеристики. Самото печатане се извършва със стандарт­ните средства­ на .NET Framework за чертане върху повърхности.

Windows Forms контроли в Internet Explorer

При проектирането на .NET Framework е заложено Windows Forms контро­лите да могат да се изпълняват в средата на Internet Explorer или други уеб браузъри, без да се застрашава сигурността на потребителя.

Тази технология е една добра съвременна алтернатива на Java аплетите и позволява разширяване на функционалността на уеб приложенията с гъвкав интерактивен потребителски интерфейс. На практика се дава въз­можност .NET приложения да се изпълняват в браузъра на клиента като се вградят в най-обикновена уеб страница (подобно на Flash технологията).

Силна поддръжка на графика (GDI+)

Библиотеката Windows Forms широко използва средствата на Windows плат­формата за чертане и работа с графични обекти (GDI+). Windows Forms позволява тези средства да се използват за създаване на собствени изображения върху различни повърхности – в прозорец, върху принтер, плотер и др. Дава се достъп до всички по-важни примитиви за чертане –текст, графични изображения, геометрични фигури (точки, линии, право­ъгълници, елипси) и т. н.

Нашето първо Windows Forms приложение

За да илюстрираме как се използва на практика Windows Forms, да разгледаме следното просто приложение:

using System;

using System.Windows.Forms;

 

public class SampleForm : System.Windows.Forms.Form

{

  static void Main()

  {

     SampleForm sampleForm = new SampleForm();

     sampleForm.Text = "Sample Form";

     Button button = new Button();

     button.Text = "Close";

     button.Click +=

       new EventHandler(sampleForm.button_Click);

     sampleForm.Controls.Add(button);

     sampleForm.ShowDialog();

     sampleForm.Dispose();

  }

 

  private void button_Click(object sender, EventArgs e)

  {

     Close();

  }

}

В него се създава прозорец, който съдържа бутон с текст "Close". При натискане на бутона прозорецът се затваря (това се реализира чрез при­хващане и обработка на събитието "натискане на бутона").

Как да компилираме и стартираме примера?

За да компилираме горното приложение, можем да ползваме конзолния компилатор на .NET Framework за езика C#:

csc SampleForm.cs

Можем да компилираме примера и от VS.NET, но за целта трябва да създадем нов Windows Application проект и да копираме кода в него.

При изпълнение на приложението се получава следния резултат:

Как работи примерът?

Нашето първо Windows Forms приложение е доста просто. То е изградено по следния начин:

-     Дефиниран е клас SampleForm, който наследява класа System. Windows.Forms.Form. Този клас представлява главната форма на приложението.

-     В главния метод Main() първо се задава заглавие за формата. След това се създава бутон, който се добавя в списъка с контролите на формата и се прихваща събитието "щракване върху бутона". Накрая формата се показва в модален режим (модален режим означава, че другите форми на приложението не са активни, докато не се затвори текущата) и след затварянето й се унищожава.

-     При натискане на бутона се извиква събитие, което затваря формата, и приложението завършва.

Примерът е доста прост и показва основните моменти при изграждането на потребителски интерфейс с Windows Forms – създаване на форми, поставяне на контроли във формите, настройка на свойствата на контро­лите, прихващане и обработване на събития.

Библиотеките на .NET за изграждане на GUI

Средствата на .NET Framework за изграждане на графичен потребителски интерфейс са дефинирани в пространствата от имена System.Drawing и System.Windows.Forms, които са реализирани съответно в асемблитата System.Drawing.dll и System.Windows.Forms.dll. Тези пространства за­едно с пространствата, съдържащи се в тях, са изобразени на фигурата:

Пространството System.Windows.Forms

Класовете и типовете от пространството System.Windows.Forms осигу­ря­ват средства за работа с прозорци, диалози, контроли за въвеж­дане на текст, контроли за избор, менюта, ленти с инструменти, таблици, дървета и др.

Пространството System.Windows.Forms.Design

Пространството System.Windows.Forms.Design съдържа класове, които поддържат конфигурирането на компонентите и дефинират поведението на Windows Forms контролите по време на дизайн.

Пространството System.Drawing

Класовете и типовете от пространството System.Drawing и неговите под­пространства осигуряват достъп до GDI+ функциите на Windows: работа с повърхности, точки, линии, четки, моливи, геометрични фигури, картин­ки, текст и шрифтове и др.

Програмни компоненти

В софтуерното инженерство компонентите са преизползваеми (reusable) програмни единици (класове), които решават специфична задача. Всеки компонент има ясно дефиниран интерфейс, който описва неговите свой­ства, методи и събития. Компонентите се използват като части от други компоненти или програми – те са градивните елементи на софтуера.

Компонентен модел

В софтуерното инженерство компонентният модел дефинира стандартите за разработка и използване на програмните компоненти и техния жизнен цикъл. Тези стандарти описват чрез интерфейси модела на поведение и взаимодействие на всички компоненти в дадена среда.

Компонентният модел на .NET Framework

Компонентният модел на .NET Framework дефинира програмния модел (система от правила) за създаване и използване на .NET компоненти. Този програмен модел се реализира чрез определени класове и интерфейси, които поддържат описанието на компонентите.

В .NET Framework компонентният модел позволява дефиниране на пове­дението на компонентите по време на дизайн (design-time behavior) и по време на работа (runtime behavior).

Компоненти и контейнери

В .NET Framework са дефинирани два вида преизползваеми обекти: ком­поненти и контейнери. Компонентите са функционални единици, които решават някаква задача, а контейнерите са обекти, които съдържат спи­сък от компоненти.

Преизползваемост на компонентите

Благодарение на междуезиковата съвместимост, която CLR осигурява, .NET компонентите могат директно да се преизползват във всички .NET езици за програмиране. Възможно е .NET компоненти да бъдат използвани и от Win32 приложения, но за целта трябва да се публикуват във вид на COM обекти.

Пространството System.ComponentModel

Компоненти се използват не само в Windows Forms, а навсякъде в .NET Framework. По тази причина основната функционалност на компонентния модел на .NET се намира в пространството System.ComponentModel. В него са дефинирани основните интерфейси IComponent и IContainer и техните имплементации Component и Container.

Windows Forms и компонентният модел на .NET

В архитектурата на Windows Forms залягат концепциите на компонентния модел на .NET Framework. Компонентният модел на .NET дефинира компо­ненти и контейнери. По подобен начин Windows Forms дефинира контроли и контейнер-контроли.

Контроли и контейнер-контроли

Контролите в Windows Forms са всички компоненти, които са видими за потребителя (имат графично изображение). Те биват два вида: контей­нер контроли (форми, диалози, панели и т.н.) и контроли (бутони, тексто­ви полета, етикети, списъчни контроли и т.н.). Контейнерите са предназ­начени да съдържат в себе си други контроли (включително и други кон­тейнер контроли), докато контролите са предназначени да се съдържат в контей­нер контролите.

В Windows Forms всяка контрола може да се използва като контейнер-контрола, но за някои контроли това е безсмислено. Няма смисъл и не е правилно в бутон да се поставят други бутони или текстови полета.

Програмен модел на Windows Forms

Програмният модел на Windows Forms дефинира класовете за работа с форми, диалози и контроли, събитията на контролите, жизнения цикъл на приложенията, модела на пречертаване на контролите, модела на получа­ване и обработка на събитията и модела на управление на фокуса. Нека разгледаме всички тези елементи от програмния модел.

Форми

Windows Forms предлага стандартни класове за работа с форми (това са прозорците и диалозите в GUI приложенията). Формите могат да бъдат модални и немодални (по една или по много активни едновременно). Формите са контейнер-контроли и могат да съдържат други контроли, например етикети, текстови полета, бутони и т.н. Базов клас за всички форми е класът System.Windows.Forms.Form.

Контроли

Контролите в Windows Forms са текстовите полета, етикетите, бутоните, списъците, дърветата, таблиците, менютата, лентите с инструменти, статус лентите и много други. Windows Forms дефинира базови класове за кон­тролите и класове-наследници за всяка контрола. Базов клас за всички контроли е класът System.Windows.Forms.Control. Пример за контрола е например бутонът (класът System.Windows.Forms.Button).

Събития

Всички контроли от Windows Forms дефинират събития, които програмис­тът може да прихваща. Например контролата Button дефинира събитието Click, което се активира при натискане на бутона. Събитията в Windows Forms управляват взаимодействието между програмата и контролите и между самите контроли.

Жизнен цикъл на Windows Forms приложенията

Жизненият цикъл на GUI приложенията е базиран на съобщения. Графич­ната среда на операционната система прихваща всички потребителски действия (напр. движението на мишката, натискането на клавиши от клавиатурата и т.н.) и ги натрупва в специална опашка. След това всяко съобщение се предава към приложението, за което се отнася и по-точно към нишката (thread) от приложението, за която се отнася.

Нишки и многозадачност

В многозадачните операционни системи (каквито са например Windows и Linux) е възможно едно приложение да изпълнява няколко задачи пара­лелно, като използва няколко нишки (threads) в рамките на процеса, в който работи програмата.

За целите на настоящата тема можем да си мислим, че нишките са нещо като отделни задачи в програмата, които се изпълняват едновременно (паралелно) в даден момент. По-нататък, в темата "Многонишково програ­миране и синхронизация", ще обърнем специално вни­мание на многоза­дачността, използването и синхронизацията на нишки.

Опашката от събития

Всяка нишка от всяко приложение си има своя собствена опашка, в която постъпват съобщенията за всички събития, идващи от потребителя или от други източници. Всяко съобщение носи информация за събитието, което е настъпило – часът на настъпване, идентификатор на прозорец, за който се отнася събитието, тип на събитието, параметри на събитието (напр. номер на натиснатия клавиш при събитие от клавиатурата или позиция на курсора при събитие от мишката) и т.н. В Windows Forms съобщенията са инстанции на структурата System.Windows.Forms.Message.

Главната нишка на всяко Windows Forms приложение извършва една единствена задача: в безкраен цикъл обработва опашката от съобщения за приложението и предава постъпилите съобщения на контролата, за която са предназначени.

В Windows Forms приложенията винаги имат точно една нишка, която обработва всички съобщения, идващи от графичните контроли, и това е главната нишка на приложението. Графичният потребителски интерфейс на цялото приложение се управлява от тази нишка. При настъпване на събитие, свързано с някоя от формите на приложението или контролите в нея, в опашката на главната нишка постъпва съответно съобщение и то се обработва, когато му дойде редът.

Само главната нишка трябва да взаимодейства с опашката от събития

Много е важно, когато разработваме Windows Forms приложения, да се съобразяваме със следното правило:

Графичният потребителски интерфейс на приложението трябва да се управлява само и единствено от неговата главна нишка.

Ако не спазваме това правило, ще се сблъскаме с много странни и неприятни проблеми. Например, ако стартираме едновременно няколко нишки и от всяка от тях от време на време променяме съдържанието на определено текстово поле, е възможно в дадени моменти приложението да "зависва".

Всяка контрола обработва собствените си събития

Когато главната нишка на Windows Forms приложение получи съобщение, свързано с някоя от неговите форми, тя препраща съобщението до обра­ботчика на съобщения на съответната форма. Този обработчик от своя страна проверява дали съобщението е за самата форма или за някоя нейна контрола. Ако съобщението е за формата, то се обработва директно от съответния обработчик на събития. Ако съобщението е за някоя от контролите във формата, то се предава на нея. Контролата, която получи съобщението, може да е обикновена контрола или контейнер-контрола. Когато обикновена контрола получи съобщение, тя го обработва директ­но. Когато контейнер-контрола получи съобщение, тя проверява дали то е за нея или е за някоя от вложените контроли. Процесът продъл­жава, докато съобщението достигне до контролата, за която е предназ­начено.

По описаната схема всяко съобщение преминава от главната нишка на приложението през формата, за която се отнася, и евентуално през още една или няколко други контроли, докато си намери обработчика.

Обработка на събитие – пример

Нека имаме някакво приложение, което се състои от една форма, в която има един бутон. Да предположим, че натиснем левия бутон на мишката, докато курсорът е върху бутона във формата. Какво се случва?

Главната нишка на приложението получава съобщение "натиснат ляв бутон на мишка", в което са записани координатите, в които е бил курсорът на мишката в момента на натискането. Операционната система подава тези координати относително спрямо горния ляв ъгъл на формата.

Докато обработва съобщението, главната нишка на приложението открива формата, за която се отнася събитието (това е най-горната от всички форми, в които попада курсорът на мишката) и го предава на нейния обработчик на събития.

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

Бутонът получава събитието и вижда, че то е предназначено точно за него. Събитието бива погълнато (консумирано) от обработчика на събития на бутона и съответно бутонът преминава в състояние "натиснат". Самият бутон малко след това изпраща събитие за пречертаване до самия себе си (на пречертаването ще обърнем внимание след малко). Когато това събитие достигне по същия път до бутона, той се пречер­тава в натиснато състояние.

Прекратяване на Windows Forms приложение

При затваряне на главната форма на Windows Forms приложение, към нея се изпраща съобщение за затваряне. Формата се затваря в момента, в който получи съобщението и го обработи. В резултат на затварянето на формата се прекратява цикълът, в който главната нишка на приложението обработва пристигащите за нея съобщения и приложението приключва изпълнението си.

Модел на пречертаване на контролите

В Windows Forms контролите често се пречертават, например при пре­местване на прозорец, при смяна на активния прозорец или при промяна на размера, позицията или състоянието на някоя контрола. При всяко от изброените действия една или няколко контроли, които попадат в обсега на даден засегнат регион, се обявяват за невалидни и се активира проце­сът на пречертаване.

Процесът на пречертаване

Процесът на пречертаване на контрола, която е засегната от промяна в нея самата, от промяна на контейнер-контролата, в която се намира, или от промяна в други съседни контроли, се извършва на два етапа:

1.  За контролата се извиква методът Invalidate(), който обявява за невалидна дадената контрола или отделен неин участък и изпраща заявка за пречертаване. Invalidate() реално маркира регионите от контролата, които по някаква причина имат нужда от пречертаване и след това й изпраща съобщение "пречертай" (WM_PAINT), което се изпълнява по-късно.

2.  В някакъв момент цикълът за обработка на съобщения на текущата нишка получава съобщението "пречертай" и в резултат изпълнява метода Paint() на съответната контрола. Този метод извършва самото графично обновяване на всички невалидни участъци от контролата или в частност я пречертава цялата.

Друг интересен метод, свързан с пречертаването на контролите, е Update() методът. Той може да се използва след Invalidate() за незабавно пречертаване на дадена контрола чрез насилствено извикване на Paint(), без да се изчаква Paint() да бъде извикан от цикъла за обработка на съобщения за текущата нишка.

Съобщението "пречертай"

Съобщението "пречертай" (WM_PAINT) е специално съобщение. То се обра­ботва последно, едва след като всички останали съобщения от опашката на главната нишка вече са обработени и в нея останат само съобщения "пречертай". Това осигурява намаляване на претрепванията на контроли­те, когато те се променят много пъти за кратко време.

Например, ако при обработката на дадено събитие на дадена контрола бъде изпратено 5 пъти съобщение "пречертай", контролата ще изпълни само едно пречертаване и то едва след като формата е обработила всички останали съобщения и е станало ясно кои контроли в момента са невалидни и трябва да се пречертаят.

Реалното графично изобразяване на заявените за пречертаване контроли се извършва, когато те обработват съобщението "пречертай", което може да е много след като пречертаването е заявено.

Когато се пречертават няколко контроли последователно, те винаги се пречертават в реда, в който контролите са поставени в контейнер-контролата (т. нар. Z-order). Първи се пречертават най-рано поставените контроли, а последни – най-късно поставените.

Реализация на пречертаването

Всяка Windows Forms контрола може да дефинира програмен код, който реализира изчертаването на нейното съдържание (метод Paint()).

Windows Forms контролите могат да се поставят една върху друга със застъпване. Понеже при пречертаване контролите се изобразяват една след друга по реда на поставянето им, ако има застъпвания, последно поставената контрола закрива (частично или напълно) всички контроли, с които се застъпва.

По-нататък в настоящата тема ще дадем примерен код, който реализира пречертаването на контрола чрез използване на графичните примитиви от GDI+.

Управление на фокуса и навигация

В една форма в даден момент може някоя от контролите да е активна, т.е. да държи фокуса. Контролата, която е на фокус, обикновено показва това по някакъв начин – бутонът променя графичния си вид, текстовото поле показва мигащ курсор и т.н.

При настъпване на събитие от клавиатурата, то се получава първо от контролата, която е на фокус. Например, ако едно текстово поле е на фокус и потребителят натисне клавиш, който съответства на някоя буква, текстовото поле обикновено приема буквата и я изписва на позицията на курсора. Ако текстовото поле не обработи натиснатия клавиш (например,  ако това е клавиш за навигация [Tab]), той се обработва от контейнер-контролата.

Windows Forms осигурява навигация между контролите чрез клавишите [Tab] и [Shift+Tab], които преместват фокуса към следващата или пред­ходната контрола. Коя е следващата и коя е предишната контрола се определя от т. нар. "Tab Order", който зависи от реда на поставяне на контролите във формата и от някои свойства на контролите.

Формите също могат да са на фокус (да са активни) или да не са. Фокусът между формите може да се променя от потребителя само при немодални форми. Модалните форми не позволяват друга форма да приема фокуса, докато не бъдат затворени.

Текущата фокусирана контрола и форма могат да се променят, както в резултат от потребителски действия от клавиатурата и мишката, така и програмно - чрез изпращане на подходящи съобщения или извикване на подходящи методи. Има контроли, които не могат да приемат фокуса, и контроли, които могат да го приемат, но се прескачат при натискане на [Tab] и [Shift+Tab].

Основни класове в Windows Forms

Библиотеката Windows Forms дефинира съвкупност от базови класове за контролите, контейнер-контролите, както и множество графични контроли и неграфични компоненти.

Основните базови класове, използвани в Windows Forms, са:

-     System.ComponentModel.Component – представлява .NET компонент. Използва се за реализацията на неграфични компоненти. Например компонентата System.Windows.Forms.Timer е наследник на класа Component.

-     System.Windows.Forms.Control – представлява графична контрола. Графични контроли са компонентите, които имат графичен образ. Всички Windows Forms контроли са наследници на класа Control, включително и контейнер-контролите.

-     System.Windows.Forms.ScrollableControl – представлява контрола, която поддържа скролиране на съдържанието си. Може да съдържа в себе си други контроли.

-     System.Windows.Forms.ContainerControl – представлява контрола, която съдържа в себе си други контроли и осигурява управление на фокуса. Не всички контейнер-контроли наследяват този клас. Напри­мер панелът (System.Windows.Forms.Panel) може да съдържа в себе си други контроли, но е наследник на класа ScrollableControl, а не на ContainerControl.

Йерархия на класовете

На клас-диаграмата по-долу е показана част от класовата йерархия на библиотеката Windows Forms:

Забелязва се, че не всички класове от Windows Forms са контроли. Някои са обикновени .NET компоненти, например Menu, Timer и ImageList. Из­глежда малко странно защо менюто не е контрола, но това е така, защото компонентата Menu реално няма графичен образ и представлява списък от MenuItem елементи. MenuItem класът вече има графичен образ и следова­телно е контрола.

Типичните контроли (Label, TextBox, Button, ToolBar, StatusBar и др.) са наследници на класа Control. Общото за всички тях е, че имат графичен образ и се управляват чрез съобщения.

Контролите, които могат да се скролират (например панелите) са наслед­ници на ScrollableControl. Контролите, които съдържат други контроли и се грижат за управление на фокуса (например формите и диалозите), наследяват ContainerControl.

Класът Control

Класът System.Windows.Forms.Control заема много централна роля в библиотеката Windows Forms. Той е базов клас, основа за всички графич­ни контроли, и определя единна рамка за контролите – програмен модел, по който да се разработват и изпълняват. В него са дефинирани общите за всички контроли свойства и събития.

Свойства на класа Control

Нека сега разгледаме по-важните свойства на класа Control:

-     Anchor, Dock – задават по какъв начин контролата се "закотвя" за контейнера си. Тези свойства са много полезни, ако искаме да упра­вляваме размерите и позицията на контролата при промяна на раз­мерите на контейнера, в който е поставена. Например чрез свойст­вото Anchor можем да закотвим дадена контрола на определено разстояние от долния десен ъгъл на формата, в която стои, и при преоразмеряване това разстояние ще се запазва и контролата ще се движи заедно с движението на долния десен ъгъл на контейнера, в който е поставена.

-     Bounds – задава размера (ширина и височина) и позицията на горния ляв ъгъл на контролата в рамките на нейния контейнер. Ако контро­лата е форма, позицията се задава спрямо горния ляв ъгъл на екра­на. Ако контролата е елемент от форма (например бутон), позицията се отчита спрямо горния ляв ъгъл на формата (или контейнер-контролата), в която е оставена. Размерът включва цялото графично пространство на контролата. Например, ако контролата е форма, се включва и нейната рамка.

-     BackColor – задава цвета на фона. Цветовете са инстанции на струк­турата System.Drawing.Color, която дефинира множество стандарт­ни цветове и позволява потребителски дефинирани цветове, състоящи се от 4 на брой 8-битови компонента (яркост, червено, зелено и синьо).

-     ContextMenu – задава контекстно меню (popup menu) за контролата. Контекстното меню обикновено се появява при натискане на десния бутон на мишката върху контролата.

-     Controls – съдържа колекция от вложените в контролата други контроли (ако има такива). Например формите (инстанции на класа Form) съдържат в колекцията си Controls контролите, които са разположени в тях. По принцип всички Windows Forms контроли имат колекция Controls и могат да съхраняват в нея други контроли, но за някои от тях не е коректно това да се прави. Например не е коректно в бутон да поставяме друг бутон или текстово поле. Ако го направим, се появяват неприятни аномалии.

-     CanFocus – връща дали контролата може да получава фокуса. Почти всички видове контроли могат да бъдат фокусирани, стига да не са забранени (Enabled=false).

-     Enabled – позволява забраняване на контролата. Когато една кон­трола бъде забранена (Enabled=false), тя остава видима, но става неактивна. Обикновено забранените контроли се изобразяват с из­бледнял цвят, за да се различават от останалите. Забранените кон­троли не могат да получават фокуса. В частност забранен бутон не може да бъде натиснат, в забранено текстово поле не може да се пише и т.н. Ако забраним контейнер-контрола, която съдържа в себе си други контроли, всички тези контроли стават забранени.

-     Font – задава шрифта, с който се изписва текстът в контролата (ако контролата по някакъв начин визуализира текст). При текстови полета това е шрифтът на текста в полето. При бутон това е шрифтът на текста в бутона. При етикет това е шрифтът на текста на етикета. Ако се зададе свойството Font за формата, всички контроли, които не дефинират изрично Font, го наследяват от формата. Шрифтът, с който е изобразено заглавието на формите, не може да се променя от Windows Forms. Той се настройва от графичната среда на опера­ционната система (от контролния панел при Windows).

Шрифтовете имат следните характеристики: наименование на шрифт (например Arial) или фамилия шрифтове (например Monospace, SansSerif или Serif), стил (например Bold, Italic, ...), размер (например 12 pt или 10 px) и кодова таблица (Cyrillic, Western, Greek, ...). Кодовата таблица е необходима рядко – само за старите шрифтове, които не поддържат Unicode.

-     ForeColor – задава цвета на контролата.

-     Location – съдържа позицията на контрола в нейния контейнер (координатите на горния й ляв ъгъл). За форми това е позицията на екрана, а за други контроли това е позицията във формата или контейнер-контролата.

-     Parent – задава контейнер-контролата, в която се намира текущата контрола. Може и да няма такава (стойност null). Формите най-често имат стойност null за свойството Parent.

-     Size – съдържа размерите на контролата (ширина и височина).

-     TabIndex – определя реда при навигация с [Tab] и [Shift+Tab].

-     TabStop – задава дали контролата трябва да се фокусира при нави­гация с [Tab] и [Shift+Tab]. Ако се зададе TabStop=false, фокусът не спира в контролата при преминаване към следващата контрола (контролата се прескача).

-     Text – задава текст, свързан с контролата. При етикет това е тек­стът, изобразен в етикета. При бутон това е текстът, изобразен в бутона. При текстово поле това е текстът, въведен в полето. При форма това е заглавието на формата. Текстът е в Unicode и това позволява да се използват свободно букви и знаци на латиница, кирилица, гръцки, арабски и други азбуки, стига избраният шрифт да съдържа съответните знаци.

-     Visible – задава видимост на контролата. Ако за дадена контрола се зададе Visible=false, тя се скрива (изчезва, все едно не съще­ствува). Скрита контрола може да се покаже отново, като й се зададе Visible=true.

Методи на класа Control

Публичните методи на класа Control се наследяват и са достъпни във всички Windows Forms контроли. По-важните от тях са:

-     Focus() – фокусира контролата (ако е възможно).

-     Hide(), Show() – скрива/показва контролата (ефектът е като да зададем Visible=false / Visible=true).

Събития на класа Control

Знаем колко са важни събитията за Windows Forms контролите. Благо­дарение на тях програмистът може да пише код, който се задейства при различни промени в състоянието на контролите. Ще разгледаме по-важ­ните събития на класа Control:

-     Click – настъпва при щракване с мишката върху контролата. При бутон това събитие се извиква при натискане на бутона. При форма Click се извиква при щракване с левия бутон на мишката върху формата, ако в съответната позиция няма друга контрола. Събитието не подава допълнителна информация в аргументите си.

-     Enter, Leave – настъпват съответно при активиране и деактивиране на дадена контрола, т.е. когато контролата получи и загуби фокуса. При форми тези събития не се извикват.

-     KeyDown, KeyUp – настъпват при натискане и отпускане на произ­волен клавиш (включително специалните клавиши като [F1], [Alt], [Caps Lock], [Start] и др.). Събитието подава в аргументите си инстанция на класа KeyEventArgs, която съдържа информация за натиснатия клавиш – име на клавиша (инстанция на изброения тип System.Windows.Forms.Keys) и информация за състоянието на кла­вишите [Shift], [Alt] и [Ctrl].

-     KeyPress – настъпва при натискане на неспециален клавиш или комбинация от клавиши. Това събитие се активира само ако натис­на­тата клавишна комбинация се интерпретира като символ. Напри­мер натискането на клавиша [Alt] не води до получаване на символ и не задейства това събитие, докато натискането на клавиша [V] генерира някакъв символ в зависимост от текущия език. Събитието подава в аргументите си инстанция на KeyPressEventArgs класа, която съдържа символа, генериран в резултат от натискането на клавиша.

-     MouseDown, MouseMove, MouseUp, MouseWheel – настъпват при събития от мишката, извършени върху контролата – натискане на бутон, движение на показалеца на мишката или преместване на колелото. Събитията подават в аргументите си инстанция на MouseEventArgs класа, която съдържа информация за състоянието на бутоните и колелото на мишката и за координатите на показалеца (изчислени спрямо горния ляв ъгъл на контролата).

-     MouseEnter, MouseLeave, MouseHover – настъпват при навлизане, излизане и преместване на позицията на показалеца на мишката в рамките на контролата.

-     Move – настъпва при преместване на контролата. Преместването може да се предизвика от потребителя (например преместване на форма) или програмно (чрез промяна на свойството Location).

-     Paint – настъпва при пречертаване на контролата (при обработката на съобщението WM_PAINT). В това събитие контролата трябва да извърши пречертаването на графичния си образ. Събитието получа­ва в аргументите си инстанция на PaintEventArgs, която съдържа Graphics обекта, върху който трябва да се извърши чертането.

-     Resize – настъпва при промяна на размера на контролата. Може да се предизвика както от потребителя (при преоразмеряване на форма), така и програмно (при промяна на свойството Size).

-     TextChanged – настъпва при промяна на свойството Text на контролата.

-     Validating – използва се за валидация на данните, въведени в контролата. Валидацията на данни ще бъде дискутирана по-късно в настоящата тема.

Класът ScrollableControl

Класът ScrollableControl е наследник на класа Control и добавя към него функционалност за скролиране. Ето по-важните му свойства:

-     AutoScroll – задава дали при нужда контролата ще получи автома­тично скролиращи ленти.

-     HScroll, VScroll – задават дали контролата да има хоризонтална и вертикална скролираща лента.

Класът ContainerControl

Класът ContainerControl осигурява функционалност за управление на фокуса. Свойството му ActiveControl съдържа във всеки един момент кон­тролата, която е на фокус.

Форми, прозорци и диалози

Формите и диалозите в Windows Forms са прозорци, които съдържат контроли. Те могат да бъдат различни видове: да имат или нямат рамка, да са модални или не, да са разтегливи или не, да са над всички други прозорци или не и т.н.

Класът System.Windows.Forms.Form

Класът System.Windows.Forms.Form е базов клас за всички форми в Windows Forms GUI приложенията. Той представлява графична форма - прозорец или диалогова кутия, която съдържа в себе си контроли и управлява навигацията между тях.

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

Класът Form е наследник на класовете Control, ScrollableControl и ContainerControl и наследява от тях цялата им функционалност, всич­ките им свойства, събития и методи.

По-важни свойства на класа Form

Всички прозорци и диалози в Windows Forms наследяват класа Form и придобиват от него следните свойства:

-     FormBorderStyle – указва типа на рамката на формата. По-често използваните типове рамка са следните:

o   Sizable – стандартна разширяема рамка. Потребителят може да променя размерите на такива рамки.

o   FixedDialog – диалогова рамка с фиксирани размери. Такива рамки не могат да се преоразмеряват от потребителите.

o   None – липса на рамка. Цялото пространство на формата се използва за нейното съдържание.

o   FixedToolWindow – кутия с инструменти с фиксиран размер. Рамката не може да се преоразмерява от потребителите и е малко по-тясна от стандартната. Прозорци с такива рамки не се виждат в лентата на задачите (taskbar) на Windows Explorer и при натискане на [Alt+Tab].

-     Controls – съдържа списък с контролите, разположени във формата. От реда на контролите в този списък зависи редът, в който те се чертаят на екрана (Z-order) и редът, в който се преминава от една контрола към друга при навигация (tab order). Редът на преместване на фокуса може да се настройва и допълнително от свойствата TabStop и TabIndex.

-     Text – заглавие на прозореца. Използва се Unicode, т.е. можем да използваме, кирилица, латиница, гръцки и други азбуки от Unicode стандарта.

-     Size – размери на прозореца (ширина и височина). Включва цялото пространство, заемано от формата (рамката + вътрешността).

-     ClientSize – размери на вътрешността на формата (без рамката й).

-     AcceptButton – бутон по подразбиране. Този бутон се натиска авто­матично, когато потребителят натисне клавиша [Enter], независимо от това в коя контрола от формата е фокусът в този момент. Целта е да се улесни потребителя при попълването на форми с информация.

-     ActiveControl – съдържа контролата, която държи фокуса. При промяна на това свойство се променя текущата фокусирана контро­ла.

-     ControlBox – задава дали формата трябва да съдържа стандартните контроли за затваряне, минимизация и т. н.

-     Icon – задава икона на прозореца.

-     KeyPreview – ако се зададе true, позволява формата да обработва събитията от клавиатурата, преди да ги предаде на фокусираната контрола. Ако стойността е false, всяко събитие от клавиатурата се обработва само от контролата, която е на фокус.

-     MinimumSize, MaximumSize – задава ограничения за размера на формата – максимална и минимална ширина и височина. При опит за преоразмеряване не се позволява потребителят да задава размер, който не е в тези граници.

-     Modal – връща дали формата е модална. Когато една форма е модал­на, докато тя е активна, потребителят не може да работи с други форми от същото приложение. Всеки опит за преминаване в друга форма не успява, докато потребителят не затвори модалната форма. Ако дадено приложение покаже едновременно няколко форми, които не са модални, потребителят ще може да преминава свободно между тях, без да ги затваря. Свойството Modal е само за четене. Модал­ността може да се задава първоначално, но не може да се променя, след като формата е вече показана.

-     Opacity – задава прозрачност на формата (число от 0.00 до 1.00). Възможно е да не се поддържа или да работи много бавно при някои по-стари видеоадаптери.

-     MdiChildren – в MDI режим извлича / задава подчинените форми на текущата форма. MDI (Multiple-Document Interface) е режим, при който дадена форма на приложението (обикновено главната форма) може да съдържа в себе си други форми, които са разположени в нейното работно пространство (като обикновени контроли).

-     MdiParent – в MDI режим извлича / задава формата, която е собст­веник на текущата форма. Важи само за подчинени (child) форми.

-     TopMost – задава дали формата стои над всички други прозорци (always on top). В такъв режим, дори ако формата не е активна, тя остава видима и стои над всички останали форми.

-     WindowState – извлича състоянието на формата. Формата във всеки един момент е в някое от състоянията на изброения тип FormWindowState – нормално, минимизирано или максимизирано. По подразбиране формите са в нормално състояние – имат нормалния си размер. В максимизирано състояние формите временно променят размера си и заемат целия екран без лентата за задачи (task bar) на Windows Explorer. В минимизирано състояние формите са скрити и се виждат само в лентата за задачи (task bar).

По-важни методи на класа Form

Прозорците и диалозите в Windows Forms наследяват от класа Form следните базови методи:

-     Show() – показва формата и я прави активна (фокусира я). Формата се показва в немодален режим. Извикването на този метод е еквива­лентно на присвояването Visible=true. Изпълнението на този метод приключва веднага.

-     ShowDialog() – показва формата в модален режим и след като тя бъде затворена, връща като резултат стойност от тип DialogResult. Тази стойност съдържа информация за причината за затваряне на формата. Изпълнението на метода ShowDialog() приключва едва след затваряне на формата, т.е. методът е блокиращ. По-нататък в настоящата тема ще обърнем специално внимание на извикването на модални форми и получаването на стойностите от контролите в тях.

-     Close() – затваря формата. Когато една форма бъде затворена, тя изчезва и се освобождават използваните от нея ресурси. След като една форма бъде затворена, тя не може да бъде повече показвана. За временно скриване на форма трябва да се използва методът Hide(), а не Close().

-     LayoutMdi(…) – в MDI режим този метод пренарежда дъщерните (child) форми, съдържащи се в текущата форма. Начинът на прена­реждане се задава от програмиста. Поддържат се няколко вида пренареждане - каскадно, хоризонтално, вертикално и др.

По-важни събития на класа Form

Всички прозорци и диалози в Windows Forms поддържат съвкупност от стандартни събития, които наследяват от класа Form:

-     Activated / Deactivate – извикват се при активиране / деакти­виране на формата (когато формата получи / загуби фокуса).

-     Closing – извиква се при опит за затваряне на формата (например, когато потребителят натисне стандартния бутон за затваряне). Реа­лизацията може да предизвиква отказване на затварянето. Събити­ето подава в аргументите си инстанция на класа CancelEventArgs, която има булево свойство Cancel, чрез което може да се откаже затварянето.

-     Load – извиква се еднократно преди първото показване на формата. Може се ползва за инициализиране на състоянието на контролите.

Основни контроли в Windows Forms

Да разгледаме най-често използваните контроли в Windows Forms: TextBox, Label и Button.

TextBox

TextBox контролата е поле за въвеждане на текст. Може да бъде едно­редово или многоредово. По-важните свойства на TextBox са:

-     Multiline – задава дали контролата представлява само един ред или допуска въвеждането на няколко реда текст.

-     Text – съдържа въведения в контролата текст. Когато свойството Multiline е true, за достъп до въведения текст може да се използва и свойството Lines.

-     Lines – масив от символни низове, съдържащ въведения текст. Всеки елемент от масива съдържа един от редовете на текста.

Label

Контролата Label се използва за изобразяване на текст във формата. Свойството й Text съдържа текста, който се изобразява.

Button

Контролата Button представлява бутон, който може да бъде натискан. По-важни нейни свойства и събития са:

-     Click – активира се при натискане на бутона.

-     Text – задава текста, изобразяван върху бутона.

Поставяне на контроли във формата

Поставянето на контроли във форма става чрез добавянето им към колекцията от контроли на формата. Това може да се извърши чрез метода Controls.Add(…):

Form form = new Form();

Button button = new Button();

button.Text = "Close";

form.Controls.Add(button);

Редът на контролите (т. нар. Z-order, който споменахме по-рано в тази тема) се определя от реда на поставянето им – последната контрола е най-отгоре. Когато използваме Windows Forms дизайнерът на Visual Studio .NET, той се грижи за правилното поставяне на контролите.

Управление на събитията

Прихващането на събитие става чрез добавянето на обработчик за него. За целта създаваме метод, който ще обработва събитието, и след това се абонираме за него. Ето пример:

Form form = new Form();

Button button = new Button();

button.Click += new EventHandler(this.button_Click);

...

private void button_Click(object sender, EventArgs e)

{

  // Handle the "click" event

}

Windows Forms дизайнерът на Visual Studio .NET улеснява прихващането на събития, като генерира автоматично обработчиците при избор на събитие от страницата "Events" на прозореца "Properties".

В Windows Forms има няколко типа събития:

-     EventHandler – извършва проста нотификация, без да подава допълни­телни данни за възникналото събитие.

-     KeyEventHandler – събития от клавиатурата. Подава се информация кой е натиснатият клавиш, както и информация за състоянието на клавишите [Ctrl], [Shift] и [Alt].

-     MouseEventHandler – събития от мишката. Подава се информация за позицията на мишката и състоянието на нейните бутони.

-     CancelEventHandler – събития, които могат да откажат започнатото действие. Примерно, ако прихващаме събитието Closing на дадена форма, което е от тип CancelEventHandler, и потребителят се опита да затвори формата, можем да откажем затварянето, ако данните не са запазени.

Прост калкулатор – пример

Настоящият пример илюстрира използването на Windows Forms за създа­ва­нето на просто приложение – калкулатор за събиране на цели числа:

using System;

using System.Drawing;

using System.Windows.Forms;

 

public class CalculatorForm : Form

{

  private TextBox TextBoxNumber1;

  private TextBox TextBoxNumber2;

  private TextBox TextBoxSum;

  private Button ButtonCalc;

  private Label LabelPlus;

  private Label LabelEquals;

 

  public CalculatorForm()

  {

     TextBoxNumber1 = new TextBox();

     TextBoxNumber1.Bounds = new Rectangle(

       new Point(16, 16), new Size(72, 20));

     TextBoxNumber1.MaxLength = 10;

 

     LabelPlus = new Label();

     LabelPlus.AutoSize = true;

     LabelPlus.Location = new Point(94, 19);

     LabelPlus.Text = "+";

 

     TextBoxNumber2 = new TextBox();

     TextBoxNumber2.Bounds = new Rectangle(

       new Point(112, 16), new Size(72, 20));

     TextBoxNumber2.MaxLength = 10;

 

     LabelEquals = new Label();

     LabelEquals.AutoSize = true;

     LabelEquals.Location = new Point(191, 18);

     LabelEquals.Text = "=";

 

     TextBoxSum = new TextBox();

     TextBoxSum.Bounds = new Rectangle(

       new Point(208, 16), new Size(72, 20));

     TextBoxSum.ReadOnly = true;

 

     ButtonCalc = new Button();

     ButtonCalc.Bounds = new Rectangle(

       new Point(16, 48), new Size(264, 23));

     ButtonCalc.Text = "Calculate sum";

     ButtonCalc.Click += new EventHandler(

       this.ButtonCalc_Click);

 

     this.AcceptButton = ButtonCalc;

     this.ClientSize = new Size(298, 87);

     this.Controls.Add(TextBoxNumber1);

     this.Controls.Add(LabelPlus);

     this.Controls.Add(TextBoxNumber2);

     this.Controls.Add(LabelEquals);

     this.Controls.Add(TextBoxSum);

     this.Controls.Add(ButtonCalc);

     this.FormBorderStyle = FormBorderStyle.FixedDialog;

     this.MaximizeBox = false;

     this.MinimizeBox = false;

     this.Text = "Calculator";

  }

 

  private void ButtonCalc_Click(object aSender, EventArgs aArgs)

  {

     try

     {

       int value1 = Int32.Parse(TextBoxNumber1.Text);

       int value2 = Int32.Parse(TextBoxNumber2.Text);

       int sum = value1 + value2;

       TextBoxSum.Text = sum.ToString();

     }

     catch (FormatException)

     {

       TextBoxSum.Text = "Invalid!";

     }

    

     TextBoxNumber1.SelectAll();

     TextBoxNumber2.SelectAll();

 

     TextBoxNumber1.Focus();

  }

 

  static void Main()

  {

     CalculatorForm CalcForm = new CalculatorForm();

     Application.Run(CalcForm);

  }

}

Как да компилираме и стартираме примера?

За да компилираме примера, можем да ползваме конзолния компилатор на .NET Framework за езика C#:

csc CalculatorForm.cs

Можем да извършим компилацията и от VS.NET, но за целта трябва да създадем нов Windows Application проект и да копираме кода в него.

Ето как изглежда примерното приложение в действие:

Как работи примерът?

В примера сме дефинирали класа CalculatorForm, който наследява класа System.Windows.Forms.Form. Този клас представлява главната форма на нашето приложение.

В класа дефинираме необходимите ни контроли – три TextBox контроли (две за въвеждане на числа и една за извеждане на сумата им), две Label контроли и един бутон, при натискането на който ще се изчислява резул­татът от събирането на числата.

В конструктора на формата инициализираме контролите и ги добавяме в нея. За целта им задаваме размери, местоположение и някои други свойства. За текстовите полета, в които потребителят ще въвежда числа­та, които ще събираме, задаваме максималната им дължина в брой симво­ли. За Label контролите задаваме текста, който ще визуализират. За бутона задаваме заглавие. Накрая задаваме начина, по който ще изглеж­да нашата форма.

В метода CalcButton_Click(…) обработваме събитието Click на буто­на за изчисляване на сумата. В него парсваме съдържанието на двете текстови полета, сумираме числовите стойности, получени от тях, и записваме сумата в третото текстово поле. При грешка задаваме невалиден резултат.

Windows Forms редакторът на VS.NET

Създаването на форми, добавянето на контроли, настройката на разме­рите и местоположението на контролите и други такива операции, можем да извършваме, пишейки директно кода за нашето приложение, както в предходния пример. Разработка­та на приложения и създаването на потре­бителски интерфейс по този начин, обаче, е трудоемък и времеотнемащ процес.

Windows Forms редакторът на VS.NET ни дава възможност да правим всички тези неща визуално, ускорявайки процеса на разработка. Той улеснява значително извършването на следните операции:

-     създаване на форми

-     добавяне на контроли във формите

-     добавяне на неграфични компоненти във формите

-     настройка на свойствата на форми, компоненти и контроли

-     добавяне на събития за форми, компоненти и контроли

Създаване на форма

Създаването на форма във VS.NET става, като от менюто File изберем Add New Item. В появилия се диалогов прозорец избираме Windows Form, в полето за име въвеждаме името на формата и натискаме бутона Open. Нашата нова форма се отваря в редактора на VS.NET:

Добавяне на контрола

Добавянето на контрола става, като отворим формата, щракнем върху контролата в Toolbox, след това щракнем върху формата там, където искаме да е горният ляв ъгъл на контролата, и изтеглим мишката до там, където искаме да е долният й десен ъгъл. Контролата се добавя във формата с определеното местоположение и размери:

Всички контроли имат подразбиращ се размер. Ако желаем да добавим контрола с подразби­ращия се размер, можем просто да я изтеглим от Toolbox и да я пуснем във формата (drag and drop).

Добавяне на неграфични компоненти

За да добавим неграфична компонента, отваряме формата, щракваме върху компонентата в Toolbox и я изтегляме върху формата. Тъй като неграфичните компоненти нямат потребителски интерфейс, те не се показват върху формата, а се изобразяват в специална област под нея:

Настройка на свойства

Настройката на свойства се извършва в прозореца Properties на редактора. Ако прозорецът не е видим, можем да го покажем, като изберем View | Properties Window от менюто, натиснем [F4] или изберем Properties от контекст­но­то меню, появяващо се при щракване с десния бутон на мишката върху контролата. От падащия списък, намиращ се най-отгоре в прозореца, избираме обекта, чиито свойства ще настройваме. След това избираме свойството, което ще променяме, и му задаваме стойност. В зависимост от свойството ще зададем текст, числова стойност или ще изберем стойността от списък. Ето как изглежда прозорецът Properties на VS.NET:

Добавяне на обработчици на събития

Добавянето на обработчици на събития също става от прозореца Properties на VS.NET:

За целта от падащия списък, намиращ се най-отгоре в прозореца, избираме обекта, чиито свойства ще настройваме, и натискаме бутона Events, намиращ се под падащия списък. Появяват се събитията на обекта. От падащия списък срещу събитието, за което искаме да добавим обработчик, избираме метода, който ще обработва събитието. Ако ще дефинираме нов метод за обработка на събитието, изписваме неговото име в полето. Друга възможност е да щракнем 2 пъти с мишката и VS.NET ще избере име по подразбиране (името на контролата + "_" + името на събитието, примерно OkButton_Click). При създаване на обработчик за събитие Windows Forms редакторът добавя или намира метода и отваря редактора за код, позициониран точно върху него.

Създаване на калкулатор с Windows Forms редактора на VS.NET – пример

С настоящия пример ще илюстрираме използването на Windows Forms редактора на VS.NET за създаването на просто приложение – калкулатор, който събира цели числа. Функционалността на калкулатора ще е същата като на калкулатора от предишния пример, но този път ще използваме Windows Forms редактора, който ще генерира по-голямата част от кода на приложението.

Ето стъпките за създаването на нашия калкулатор:

1.  Стартираме VS.NET и създаваме нов Windows Forms проект.

2.  Задаваме на главната форма име Calculator и заглавие "Simple Calculator". Променяме и името на файла от Form1.cs на Calculator.cs.

3.  Вземаме от Toolbox на VS.NET три TextBox, две Label и една Button контроли и ги поставяме в главната форма. Задаваме подходящи имена на поставените компоненти. Препоръчително е името на една контрола да съдържа нейното предназначение и тип (или префикс, указващ типа). В нашия случай подходящи имена са: TextBoxNumber1, TextBoxNumber2, TextBoxSum, LabelPlus, LabelEquals и ButtonCalcSum.

4.  Задаваме празен низ в свойството Text на текстовите полета. За полето TextBoxSum задаваме ReadOnly да е true. На свойството Text на ButtonCalcSum задаваме стойност "Calculate sum". На свойствата Text на LabelPlus и LabelEquals задаваме съответно стойности "+" и "=". Ето как изглежда формата на нашия калку­латор в този момент:

5.  Остава да дефинираме събитието за натискане на бутона. С двойно щракване върху бутона VS.NET ни дава възможност да напишем кода за обработка на събитието му Click:

private void ButtonCalcSum_Click(object sender,

  System.EventArgs e)

{

  try

  {

     int value1 = Int32.Parse(TextBoxNumber1.Text);

     int value2 = Int32.Parse(TextBoxNumber2.Text);

     int sum = value1 + value2;

     TextBoxSum.Text = sum.ToString();

  }

  catch (FormatException)

  {

     TextBoxSum.Text = "Invalid!";

  }

 

  TextBoxNumber1.SelectAll();

  TextBoxNumber2.SelectAll();

 

  TextBoxNumber1.Focus();

}

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

6.  Приложението вече е готово и можем да го стартираме и тестваме. Ето как изглежда нашият калкулатор:

Диалогови кутии

При разработката на Windows Forms приложения често пъти се налага да извеждаме диалогови кутии с някакви съобщения или с някакъв въпрос. Нека разгледаме стандартните средства за такива ситуации.

Стандартни диалогови кутии

Класът MessageBox ни позволява да извеждаме стандартни диалогови кутии, съдържащи текст, бутони и икони:

-     съобщения към потребителя

-     въпросителни диалози

Показването на диалогова кутия се извършва чрез извикване на статич­ния метод Show(…) на класа MessageBox. Следният код, например, ще покаже диалогова кутия със заглавие "Предупреждение" и текст "Няма връзка с интернет":

MessageBox.Show("Няма връзка с Интернет.", "Предупреждение");

Ето как изглежда диалоговата кутия:

Нека разгледаме още един пример за стандартна диалогова кутия с малко повече функционалност:

bool confirmed =

  MessageBox.Show("Наистина ли ще изтриете това?",

  "Въпрос", MessageBoxButtons.YesNo,

  MessageBoxIcon.Question) == DialogResult.Yes;

Този код ще покаже диалогова кутия със заглавие "Въпрос" и текст "Наистина ли ще изтриете това?". Преди текста ще има икона с въпросителен знак в нея, а под него – бутони Yes и No. Ако потребителят натисне Yes, променливата confirmed ще има стойност true, в противен случай ще има стойност false. Ето как изглежда диалоговата кутия от примера:

Повече информация за класа MessageBox може да се намери в MSDN.

Извикване на диалогови кутии

Освен стандартните диалогови кутии можем да използваме и потреби­телски дефинирани диалогови кутии. Те представляват обикновени форми и се извикват модално по следния начин:

DialogResult result = dialog.ShowDialog();

Методът ShowDialog() показва формата като модална диалогова кутия. Типът DialogResult съдържа резултата (OK, Yes, No, Cancel и др.) от извикването на диалога. Задаването на DialogResult може да става авто­матично, чрез свойството DialogResult на бутоните, или ръчно – преди затварянето на диалога чрез свойството му DialogResult.

Ако извиквате форма модално, след това задължително трябва да й извиквате Dispose() метода, за да освободите ресурсите, които тя е използвала. В противен случай те ще се освободят едва когато се активира Garbage Collector и ще се използват ненужно дълго.

DialogResult и предаване на данни между диалози – пример

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

В примера ще създадем един диалог, съдържащ текстово поле за въвеж­дане на име и два бутона – OK и Cancel. Този диалог ще се показва при натискане на бутон от главната форма. Ако потребителят въведе име и натисне OK, ще се показва диалог, съдържащ въведеното име, а ако потребителят затвори диалога, натискайки Cancel, ще се появи диалог, указващ, че е натиснат Cancel.

Ето и стъпките за изграждане на нашия пример:

1.  Стартираме VS.NET и създаваме нов Windows Forms проект. В редактора се появява главната форма на приложението. На нея ще се спрем след малко.

2.  Създаваме нова форма (File | Add New Item … | Windows Form). Сменяме името й на DialogForm, а името на нейния файл – на DialogForm.cs. Задаваме на свойствата й MinimizeBox и MaximizeBox стойности false, а на свойството FormBorderStyle стойност FixedDialog. Тази форма ще служи за въвеждане на името на потребителя.

3.  Вземаме от Toolbox на VS.NET една Label, една TextBox и две Button контроли и ги подреждаме върху формата. Задаваме им подходящи имена. В нашия случай подходящи са имената: LabelYourName, TextBoxName, ButtonOK и ButtonCancel.

4.  Задаваме свойството Text на LabelYourName да е "Enter your name:", на ButtonOk да е "OK", на ButtonCancel да е "Cancel", а на TextBoxName – празен низ.

5.  Задаваме на свойството DialogResult на бутона ButtonOk стойност OK. По този начин при натискането му формата ще се затвори и ще бъде върнат резултат DialogResult.OK. Аналогично на свойството DialogResult на бутона ButtonCancel задаваме стойност Cancel. Ето как изглежда нашият диалог:

6.  Остава да добавим на тази форма едно свойство UserName, което да извлича съдържанието на текстовото поле за въвеждане на потребителско име:

public string UserName

{

  get

  {

     return TextBoxName.Text;

  }

}

7.  Поставяме върху главната форма бутон с име ButtonCallDialog и задаваме на свойството му Text стойност "Call Dialog". Чрез този бутон ще извикваме диалога, който създадохме по-рано.

8.  Добавяме обработчик на събитието Click на бутона:

private void ButtonCallDialog_Click(object sender,

  System.EventArgs e)

{

  DialogForm dialog = new DialogForm();

  if (dialog.ShowDialog() == DialogResult.OK)

  {

     string userName = dialog.UserName;

     MessageBox.Show("You entered: " + userName);

  }

  else

  {

     MessageBox.Show("You canceled the dialog.");

  }

  dialog.Dispose();

}

В него първо създаваме инстанция на DialogForm. След това извик­ваме модално формата DialogForm и проверяваме дали е била затво­рена с бутона OK чрез върнатия DialogResult. Ако е така, извличаме от DialogForm свойството UserName, с което взимаме въведеното в нея име и го показваме в диалогова кутия. Ако не е бил натиснат бутонът OK, това означава, че е бил натиснат бутонът Cancel. В този случай показваме диалогова кутия, указваща, че е натиснат бутон Cancel.

9.  Задаваме на главната форма име MainForm и заглавие "Main Form". Променяме и името на файла от Form1.cs на MainForm.cs.

10.   Нашето приложение е готово и можем да го стартираме и тестваме:

Други Windows Forms контроли

Вече разгледахме най-основните контроли в Windows Forms – текстовите полета и бутоните. Нека сега разгледаме и някои други контроли, които също се използват често при изграждането на потребителски интерфейс.

CheckBox

CheckBox е кутия за избор в стил "да/не". Свойството й Checked задава дали е избрана.

RadioButton

RadioButton е контрола за алтернативен избор. Тя се използва в групи. Всички RadioButton контроли в даден контейнер (например форма) обра­зуват една група и в нея само един RadioButton е избран в даден момент.

За да създадем няколко групи в една форма, трябва да поставим всяка група в свой собствен контейнер, като например GroupBox, Panel или TabPage. Свойството Checked задава дали контролата е избрана. При про­мяна на Checked свойството се активира събитието CheckedChanged.

Panel

Panel представлява контейнер, който съдържа група други контроли. Служи за групиране на контроли. Когато преместим даден панел на друга позиция, всички контроли, които са в него, също се преместват. Ако стойността на свойството Enabled на Panel контролата има стойност false, то всички контроли, съдържащи се в нея, ще бъдат деактивирани.

TabControl и TabPage

Контролите TabControl и TabPage осигуряват ползването на табове със страници. TabControl съдържа множество TabPage контроли, които се добавят в него чрез свойството Controls.

ListBox

ListBox контролата се използва за изобразяване на списък със символни низове, които потребителят може да избира чрез щракване с мишката върху тях. По-важните свойства на тази контрола са:

-     Items – колекция, която задава списъка от елементи, съдържащи се в контролата.

-     SelectionMode – разрешава/забранява избирането на няколко еле­мента едновременно.

-     SelectedIndex, SelectedItem, SelectedIndices, SelectedItems – връщат избра­ния елемент (или избраните елементи).

CheckedListBox

CheckedListBox изобразява списък от възможности за избор "да/не". По-важни свойства са:

-     Items – задава възможностите, от които потребителят ще избира.

-     CheckedItems – връща избраните елементи.

ComboBox

ComboBox представлява кутия за редакция на текст с възможност за drop-down алтернативен избор.

-     Text – съдържа въведения текст.

-     Items – задава възможните стойности, от които потребите­лят може да избира.

-     DropDownStyle – задава стила на контролата – дали само се избира стойност от списъка или може да се въвежда ръчно и друга стойност.

TreeView

TreeView контролата изобразява дървовидни данни. Основни нейни свойства са:

-     Nodes – съдържа дървото (списък от TreeNode елементи).

-     SelectedNode – съдържа текущо избрания възел в дървото.

RichTextBox

RichTextBox е кутия за редакция на текст с форматиране (Rich Text Format). Методите LoadFile(…) и SaveFile(…) позволяват зареждане и записване на текста от контролата в Rich Text Format (RTF) файл или в текстов файл. Свойствата SelectionStart и SelectionEnd служат за извличане и задаване на областта от текста, която е маркирана. Чрез свойствата SelectionFont, SelectionColor и SelectionAlignment могат да се задават шрифт, цвят и подравняване на текущия маркиран текст.

LinkLabel

LinkLabel контролата е подобна на Label контролата, но изглежда като пре­пратка (hyperlink). Свойството Text задава текстовото съдържание на контролата. При щрак­ване с мишката върху препратката се активира събитието LinkClicked.

PictureBox

PictureBox се използва за изобразяване на картинки. Картинката, която ще се изобразява, се задава чрез свойството Image. Свойството SizeMode задава дали картинката да се разшири/намали или центрира при изобра­зяването в контролата.

Картинките, използвани в контролата PictureBox, се запазват като ресур­си. Те се записват в XML формат в .resx файла на съответната форма и при компилация се запазват като ресурси в асем­блито на приложението.

Работа с някои Windows Forms контроли – пример

В настоящия пример ще демонстрираме използването на някои от Windows Forms контролите, които разгледахме: TabControl, TabPage, Panel, RadioButton, GroupBox, CheckedListBox. За целта ще създадем малко приложение, което събира информация от потребителя и след това я показва в диалогов прозорец.

Ето стъпките за изграждане на нашето приложение:

1.  Стартираме VS.NET и създаваме нов Windows Forms проект.

2.  Задаваме на главната форма име MainForm и заглавие "Main Form". Променяме и името на файла от Form1.cs на MainForm.cs.

3.  Вземаме от ToolBox на VS.NET един TabControl, поставяме го в горната част на главната форма и му задаваме име TabControl. Под него поставяме един Panel и му задаваме име PanelButtons. На свойствата Dock на поставените контроли задаваме съответно стойности Fill (за таб контролата) и Bottom (за панела). По този начин, при оразмеряване (Resize) на формата, панелът ще си оста­ва отдолу, като се разширя­ва/на­ма­лява само странично, а поставе­ният TabControl ще заема цялото останало пространство. Ето как изглежда формата в този момент:

4.  В TabControl контролата добавяме 3 страници (TabPage контроли)– първата за избиране на списък с продукти, втората за въвеждане на адрес и третата за избор на начин на доставка за поръчката. Подходящи имена за тези контроли са съответно TabPageItems, TabPageAddress и TabPageShipping. Добавянето на TabPage става, като щракнем с десния бутон на мишката върху TabControl контро­лата и от появилото се меню изберем Add Tab.

5.  В страницата за избор на продукти добавяме една CheckedListBox контрола с име CheckedListBoxItems и я закотвяме за четирите страни на TabPage контролата чрез свойството Anchor от прозореца Properties на редактора. По този начин контролата ще се преораз­ме­рява заедно с формата. Задаваме списък от продукти чрез свой­ството Items и добавяме над контролата един Label с текст "Select items to order:" и име LabelSelectItem.

6.  В страницата за въвеждане на адрес добавяме една TextBox контрола с име TextBoxAddress, закотвяме я към четирите страни на страницата чрез свойството Anchor, задаваме на свойството Multiline стойност true, а на свойството Text задаваме празен низ. Добавяме над контролата един Label с текст "Enter your shipping address:" и име LabelEnterAddress.

7.  В страницата за избор на начина на доставка добавяме една GroupBox контрола с име GroupBoxShippingMethod и текст Select shipping method. В нея добавяме три RadioButton контроли с име­на RadioButtonMail, RadioButtonDHL и RadioButtonFedEx и текст съответно "Mail", "DHL" и "FedEx". Тази комбинация от контроли ни осигурява алтернативен избор на един от въз­можните доставчици. Най-отдолу в тази страница добавяме и една CheckBox контрола с име CheckBoxTrackShipping и текст "Track shipping". Ето как изглеждат нашите табове в този момент:

8.  В панела за бутоните добавяме два бутона с имена ButtonOK и ButtonCancel и текст съответно "OK" и "Cancel". Чрез двукратно щракване върху бутона ButtonCancel добавяме обработчик за съ­битието му Click, в който добавяме код за затваряне на формата:

private void ButtonCancel_Click(object sender,

  System.EventArgs e)

{

  Close();

}

9.  Остана само да дефинираме обработчик на събитието Click на бутона ButtonOK:

private void ButtonOK_Click(object sender, System.EventArgs e)

{

  StringBuilder order = new StringBuilder("Ordered items:\n");

  foreach (object item in CheckedListBoxItems.CheckedItems)

  {

     order.Append(item.ToString());

     order.Append("\n");

  }

      

  order.Append("Shipping address:\n");

  order.Append(TextBoxAddress.Text);

 

  order.Append("\nShipping method: ");

  if (RadioButtonMail.Checked)

  {

     order.Append("Mail");

  }

  if (RadioButtonDHL.Checked)

  {

     order.Append("DHL");

  }

  if (RadioButtonFedEx.Checked)

  {

     order.Append("FedEx");

  }

 

  order.Append("\nTrack shipping: ");

  if (CheckBoxTrackShipping.Checked)

  {

     order.Append("Yes");

  }

  else

  {

     order.Append("No");

  }

 

  MessageBox.Show(order.ToString(), "Info");

 

  Close();

}

При натискане на бутона извличаме стойностите, въведени във всич­ки контроли, от всички страници, и ги записваме в символен низ. След това ги извеждаме на екрана в стандартна диалогова кутия. За да направим това, първо създаваме един StringBuilder обект, в който ще ги добавяме. След това добавяме стойностите на всички избрани еле­менти от CheckedListBoxItems контролата, като след всеки от тях добавяме нов ред. Добавяме адреса за доставка, после проверяваме кой RadioButton е избран и добавяме съответния метод за доставка към StringBuilder обекта. Накрая проверяваме състоя­ни­ето на CheckBox контролата от страницата за начин на доставка и извеж­даме извлечената от контролите информация в стандартна диалогова кутия.

10.  Нашето приложение е готово и можем да го стартираме и тестваме:

Менюта

Менютата са важно средство, чрез което потребителят по удобен начин указва започването на дадена операция. Те са на практика стандарт при прило­женията с графичен потребителски интерфейс. В Windows Forms за работа с менюта се използват класовете MainMenu, ContextMenu и MenuItem.

MainMenu

MainMenu компонентата представлява стандартно падащо меню. Тя съдър­жа в себе си списък от MenuItem елементи, които представят отделните възможности за избор (команди) от менюто.

ContextMenu

ContextMenu компонентата представлява контекстно меню (popup меню), което се появява, когато потребителят щракне с десния бутон на мишката върху контрола или някъде във формата. Тя съдържа списък от MenuItem елементи, представляващи отделните команди от менюто.

MenuItem

MenuItem елементите представляват отделните възможности за избор, показвани в MainMenu или ContextMenu. Всеки MenuItem елемент може да бъде команда в приложението или родителско меню за други елементи, (менютата могат да се влагат). По-важни събития и свойства на класа MenuItem са:

-     Text – задава заглавието на елемента, например "&New", "&Open…" или "-". Символът "&" задава горещ клавиш за бързо избиране на съответния елемент. Поставя се преди дадена буква от текста на елемента. Елемент от менюто с текст "-" задава разделител.

-     ShortCut – кратък клавиш, асоцииран с този елемент. Например може да се укаже, че [Ctrl+S] съответства на елемента от менюто File | Open. В такъв случай указаната клавишна комбинация, независимо кога е натисната, активи­ра този елемент от менюто, стига това да се е случило при активна форма.

-     Click – събитие, което се активира при избиране на елемента от менюто.

Ленти с инструменти

Лентите с инструменти са често използвани при приложенията с графичен интерфейс. Нека разгледаме стандартните средства на Windows Forms за работата с тях.

ToolBar

ToolBar контролата представлява лента с инструменти (с бутони). По-важни нейни свойства и събития са:

-     Buttons – съдържа списък от бутоните (ToolBarButton елементите), асоциирани с контролата.

-     ImageList – задава картинките за бутоните от лентата.

-     ButtonClick – събитие, активиращо се при натискане на бутон от лентата. Като параметър то приема ToolBarButtonClickEventArgs с информация кой бутон е бил натиснат.

Не е ясно по каква причина, но проектантите на библиотеката Windows Forms са направили работата с ленти с инструменти доста неудобна. Вместо всеки бутон от лентата да си има собствено събитие Click, има едно общо събитие за цялата лента с инструменти, което се активира при натискане на някой от бутоните. Другият проблем е, че вместо всеки бутон да си има свойство Picture, картинките трябва да се слагат в ImageList компонента и да се ползват по индекс.

ToolBarButton

ToolBarButton компонентата представлява бутон от лентата с инструмен­ти. За всеки бутон от лентата може да се задава картинка, която да се изобразява върху него, текстът за бутона, както и някои други свойства като ToolTipText, който да се показва при задържане на показалеца на мишката върху бутона.

Задаването на изображение на ToolBarButton ста­ва, като асоциираме ImageList с лентата с инструменти, в която се намира бутонът, и след това зададем на свойството ImageIndex на бутона стойност с индекса на изо­бра­же­нието. 

ImageList

ImageList компонентата съдържа списък с картинки. Тя често се използва от други компоненти като ListView, TreeView или ToolBar.

Статус ленти

Статус лентите са още една от типичните контроли в приложенията с графичен интерфейс. Те се използват за визуализация на информация, свързана със състоянието на приложението. Например в текстовите редак­тори много често в статус лентата се показва номерът на текущия ред и на колона.

StatusBar

StatusBar контролата представлява лента за състоянието. Тя  обикновено се състои от StatusBarPanel обекти, показващи текст или икони. Тя може да съдържа и потребителски дефинирани панели, показващи информация за състоянието на приложението. По-важни свойства на контролата са:

-     Panels – съдържа секциите, на които е разделена лентата. На фигурата по-горе статус лентата е разделена на 2 секции. Статус лентата може и да няма отделни секции, а да е едно цяло.

-     ShowPanels – включва/изключва показването на панелите. Ако сек­циите са изключени, статус лентата е едно цяло.

StatusBarPanel

StatusBarPanel компонентата представлява секция в лентата за състоя­нието. Тя може да съдържа текст и/или икона. Чрез свойството Text се задава текстът, който се показва в панела, а чрез свойството Icon се задава икона.

Диалог за избор на файл

При графичните приложения често се налага да се избира файл от локалната файлова система, напри­мер, когато трябва да бъде зареден или записан документ във файл. За тази цел Windows Forms предоставя стандартни диалози, които могат да се настройват по гъвкав начин.

OpenFileDialog

OpenFileDialog представлява диалог за избор на файл (при отваряне). Този клас ни позволява да проверим дали файл съществува и да го отворим. По-важни свойства на диалога са:

-     Title – задава заглавие на диалога.

-     InitialDirectory – задава началната директория, от която започва изборът на файл. Ако не бъде зададена изрично, се използва последната директория, от която потребителят е избирал файл по време на работа с текущото приложение.

-     Filter – задава възможните файлови разширения, измежду които потребителят може да избира (например *.txt, *.doc, ...).

-     FilterIndex – задава активния филтър.

-     MultiSelect – указва дали в диалога могат да бъдат избирани много файлове едновременно или само един.

-     FileName, FileNames – съдържа избраните файлове.

SaveFileDialog

SaveFileDialog представлява диалог за избор на файл (при записване). Този клас ни позволява да презапишем съществуващ или да създадем нов файл. Работата с него е аналогична на работата с OpenFileDialog.

Работа с файлов диалог – пример

Настоящият пример илюстрира работата с файловия диалог на Windows Forms (компонентата OpenFileDialog). За целта ще създадем приложение, което позволява на потребителя да избере текстов файл с помощта на OpenFileDialog, чете съдържанието му и го показва в текстова контрола.

Ето стъпките за изграждане на нашето приложение:

1.  Стартираме VS.NET и създаваме нов Windows Forms проект.

2.  Задаваме на главната форма име MainForm и заглавие "FileOpenDialog - Demo". Променяме името на файла от Form1.cs на MainForm.cs.

3.  Вземаме от ToolBox на VS.NET един TextBox, поставяме го в горната част на главната форма и му задаваме име textBox. Зада­ваме на свойството му Multiline стойност true и на свой­ството  му ScrollBars стойност Vertical. Така си осигуряваме многоредово текстово поле с възможност за скролиране. Под него поставяме един Panel и му задаваме име PanelBottom. На свойствата Dock на поставените контроли задаваме съответно стойности Fill и Bottom. По този начин, при оразмеряване (Resize) на формата, панелът ще си остава отдолу, като се разширя­ва/на­ма­лява само странично, а поставеният TextBox ще заема цялото останало пространство. Ето как изглежда формата в този момент:

4.  Поставяме във формата един OpenFileDialog с име openFileDialog. Задаваме на свой­ството Filter стойност "Text files (*.txt)|*.txt|Log files (*.log)|*.log". Този филтър указва търсене само на текстови (.txt) и log (.log) файлове. На свойството Title задаваме стойност "Choose text file".

5.  В панела добавяме един бутон с име ButtonLoadFile и текст "Load file". Чрез двукратно щракване върху бутона добавяме обработ­чик за събитието му Click:

private void ButtonLoadFile_Click(object sender,                  System.EventArgs e)

{

  if (openFileDialog.ShowDialog() == DialogResult.OK)

  {

     string fileName = openFileDialog.FileName;

     using (StreamReader reader = File.OpenText(fileName))

     {

       string fileContents = reader.ReadToEnd();

       textBox.Text = fileContents;

     }

  }

}

При натискане на бутона показваме диалог за избор на файл и ако потребителят избере файл и натисне бутона [OK], отваряме файла, четем съдържанието му и го показваме в текстовото поле.

6.  Нашето приложение е готово и можем да го стартираме и тестваме:

MDI приложения

MDI (Multiple Document Interface) приложенията поддържат работа с няколко документа едновременно, като всеки документ се показва в свой собствен прозорец, разположен във вътрешността на главния прозорец.

MDI контейнери (MDI parents)

MDI контейнерите са форми, които съдържат други форми. За да укажем, че една форма е MDI контейнер, задаваме на нейното свойство IsMdiContainer стойност true. Тези форми обикновено имат меню Window за смяна на активната форма (на свойството му MdiList е зададена стойност true).

MDI форми (MDI children)

MDI формите се съдържат в контейнер-формата. За да укажем, че една форма е MDI форма, задаваме на свойство MdiParent=<контейнер>, къде­то контейнер е MDI контейнер.

Създаване на многодокументов текстов редактор – пример

С настоящия пример ще демонстрираме изграждане на многодокументов текстов редактор със средствата на Windows Forms и Visual Studio .NET. Редакторът трябва да може да създава, редактира, зарежда и записва текстови доку­менти (файлове) и да позволява работа едновременно с много документи в отделни MDI прозорци.

Чрез примерния текстов редактор ще демонстрираме употребата на някои от Windows Forms контролите, които разгледахме: менюта (MainMenu, MenuItem), ленти с инструменти (ToolBar, ImageList, ToolBarButton) и статус ленти (StatusBar, StatusBarPanel). Ще покажем как се създават приложения, работещи в MDI режим. Ще демонстрираме работата с диалога за избор на файл.

Ето стъпките за изграждането на нашия текстов редактор:

1.  Стартираме VS.NET и създаваме нов Windows Forms проект.

2.  Взимаме от ToolBox на VS.NET едно MainMenu, един ToolBar, един ImageList, един StatusBar и един OpenFileDialog и ги поставяме в главната форма. Задаваме подходящи имена на поставените компо­ненти. Препоръчително е името на една контрола да съдържа нейното предназначе­ние и тип (или префикс, указващ типа). В нашия случай подходящи имена са: MenuMainForm, ToolBarMainForm, ImageListToolBar, StatusBarMainForm и OpenFileDialog.

3.  Задаваме за филтър на OpenFileDialog контролата стойността "Text files (*.txt)|*.txt". Този филтър указва търсене само на текстови файлове (.txt).

4.  Дефинираме File и Window менюта в главното меню (засега ще ги оставим празни, без елементи в тях).

5.  Задаваме на главната форма име MainForm и заглавие "Text Editor Demo". Променяме и името на файла от Form1.cs на MainForm.cs. На картинката по-долу е показано как изглежда разработваното прило­жение в този момент.

6.  Преди да дефинираме бутоните в лентата с инструменти, трябва да заредим подходящи иконки за тях в ImageList контролата. Трябват ни иконка за нов файл, за отваряне на файл и за запис на файл. Можем да използваме стандартните иконки, идващи с VS.NET. Те се намират в директория: C:\Program Files\Microsoft Visual Studio .NET 2003\Common7\Graphics\bitmaps\OffCtlBr\Small\Color (при стандартна инсталация на Visual Studio .NET).

7.  От редактора за свойствата на компонентите избираме свойството Images на ImageList контролата. Появява се Image Collection Editor, от който можем да добавим иконки в списъка. Добавяме подходящи иконки за нов файл, за отваряне на файл и за запис на файл:

8.  За да дефинираме бутоните в лентата с инструменти, първо свързваме ImageList свойството на ToolBar контролата с ImageList компонентата, която заредихме с иконки в предната стъпка. След това използваме свойството Buttons на поставената във формата ToolBar контрола, за да дефинираме бутоните. За редакция на това свойство се използва ToolBarButton Collection Editor, който се появява при опит за редактиране на свойството Buttons:

Добавяме три бутона (за нов файл, за отваряне на файл и за запис на файл) и задаваме за всеки от тях подходящо име и ImageIndex, който го свързва с неговата иконка от ImageList контролата. В този момент в лентата с инструменти се появяват трите бутона с иконки върху тях:

9.  Статус лентата ще разделим на две части. В лявата част ще показваме информация за извършените от приложението действия, а в дясната – номера на реда в текущия файл. За целта задаваме на статус лентата ShowPanels=true и добавяме в нея два панела (чрез свойството Panels). Задаваме им имената StatusBarPanelInfo и StatusBarPanelLine и им настройваме размерите:

Статус лентата добива следния вид:

10.   За да направим главната форма MDI форма, й задаваме IsMdiContainer=true.

11.   Създаваме елементите на главното меню File: New, Open, Save и Exit. За да създадем разделител преди елемента Exit, задаваме на съответната MenuItem контрола Text="-". За Window менюто задава­ме MdiList=true, за да показва списък от MDI прозорците в главната форма. За елементите на менюто избираме подходящи имена (напри­мер MenuItemFileNew, MenuItemFileOpen, ...). Задава­ме и подходящи бързи клавиши (shortcuts) за често използваните команди чрез свойството Shortcut на MenuItem контролата – [Ctrl+N] за File | New, [Ctrl+O] за File | Open, [Ctrl+S] за File | Save и [Alt-F4] за File | Exit. Ето как изглежда главното меню в този момент:

Цялата форма на приложението добива следния вид:

12.   Вече имаме главната форма. Остава да добавим формата за редак­тиране на файловете и да реализираме логиката на прило­жението. Започваме от дефиниране на събитията за елементите от менюто. С двойно щракване върху елемент от менюто VS.NET ни дава въз­можност да напишем кода за обработка на събитието му Click:

private void MenuItemFileNew_Click(object sender,

  System.EventArgs e)

{

  CreateNewFile();

}

 

private void MenuItemFileOpen_Click(object sender,

  System.EventArgs e)

{

  OpenExistingFile();

}

 

private void MenuItemFileSave_Click(object sender,

  System.EventArgs e)

{

  SaveCurrentFile();

}

 

private void MenuItemFileExit_Click(object sender,

  System.EventArgs e)

{

  Close();

}

Методите CreateNewFile(), OpenExistingFile() и SaveCurrentFile() ще разгледаме след малко.

13.   Дефинираме и обработчик на събитието натискане на бутон от лентата с инструменти:

private void ToolBarMainForm_ButtonClick(object sender,

  System.Windows.Forms.ToolBarButtonClickEventArgs e)

{

  if (e.Button == ToolBarButtonNew)

  {

     CreateNewFile();

  }

  else if (e.Button == ToolBarButtonOpen)

  {

     OpenExistingFile();

  }

  else if (e.Button == ToolBarButtonSave)

  {

     SaveCurrentFile();

  }

}

Понеже контролата ToolBar не предоставя отделни събития за всеки от бутоните си, трябва да се прихване събитието й ButtonClick и да се проверява за кой от бутоните се отнася то (чрез свойството Button на ToolBarButtonClickEventArgs параметъра).

14.   Остава да дефинираме формата за редакция на документ и да реализираме логиката за създаване, редактиране, зареждане и за­писване на документи. Създаваме нова форма (File | Add New Item … | Windows Form). Сменяме й името на EditorForm, а името на нейния файл – на EditorForm.cs. Тази форма ще служи за редак­ция на документите. Тя ще се използва като подчинена MDI форма.

15.   Добавяме RichTextBox контрола в новата форма. Тя ще служи за редакция на текста на документите. Използваме RichTextBox вмес­то TextBox, защото RichTextBox позволява работа с по-големи доку­менти и осигурява по-голяма гъвкавост. Задаваме Dock=Fill за RichTextBox контролата и й сменяме името на EditorRichTextBox. Ето как изглежда формата след всички тези действия:

16.   Дефинираме в новата форма поле mFileName, което ще съхранява името на текущия отворен файл или null, ако текущият файл няма име (например ако е нов файл):

private string mFileName = null;

17.   Поставяме в новата форма един SaveFileDialog. Ще го ползваме при запис на файла, който е зареден в RichTextBox контро­лата. Задаваме му филтър "Text files (*.txt)|*.txt".

18.   Дефинираме няколко метода, които реализират логиката по отваря­не на нов документ, зареждане на файл и записване на файл, както и помощен метод за обновяване на статус лентата:

public void CreateNewFile()

{

  SetStatusBarInfo("Created new file.");

  mFileName = null;

  this.Text = "Untitled";

}

 

public void LoadFile(string aFileName)

{

  mFileName = aFileName;

  this.Text = Path.GetFileName(aFileName);

  using (StreamReader reader = File.OpenText(aFileName))

  {

     string fileContents = reader.ReadToEnd();

     RichTextBoxEditor.Text = fileContents;

  }

}

 

public void Save()

{

  if (mFileName == null)

  {

     if (SaveFileDialog.ShowDialog() != DialogResult.OK)

     {

       return;

     }

     mFileName = SaveFileDialog.FileName;

     this.Text = Path.GetFileName(mFileName);

  }

 

  using (StreamWriter writer = new StreamWriter(mFileName))

  {

     writer.Write(RichTextBoxEditor.Text);

  }

 

  SetStatusBarInfo("Saved file: " + mFileName);

}

 

public void SetStatusBarInfo(string aText)

{

  MainForm mainForm = (MainForm) this.MdiParent;

  mainForm.SetInfoStatusBar(aText);

}

Създаването на нов документ задава заглавие "Untitled" на формата и установява в null името на файла, свързан с нея. Зареждането на файл става с текстов поток. При зареждане формата запомня пълното име на файла, а за заглавие на формата се задава името на файла без пътя. При запис, ако документът не е свързан с файл, се използва файловият диалог за избор на име на файл, в който да се запише. Ако документът е свързан с файл, той просто се записва. Записът става с текстов поток.

19.   Дефинираме няколко обработчика на събития и няколко помощни метода с цел визуализация на номера на реда в текущия файл:

private void EditorForm_Activated(object sender,

  System.EventArgs e)

{

  ShowLineNumber();

}

 

private void RichTextBoxEditor_SelectionChanged(object sender,

  System.EventArgs e)

{

  ShowLineNumber();

}

 

public void SetStatusBarLine(string aText)

{

  MainForm mainForm = (MainForm) this.MdiParent;

  mainForm.SetLineStatusBar(aText);

}

 

public void ShowLineNumber()

{

  int currentPos = EditorRichTextBox.SelectionStart;

  int line = RichTextBoxEditor.GetLineFromCharIndex(currentPos);

  SetStatusBarLine("Line: " + line);

}

При активиране на формата и при промяна на позицията на курсора приложението изчислява номера на текущия ред в текущия документ и го показва в десния панел на лентата за състоянието. Достъпът до лентата на състоянието става през родителската MDI форма (това е главната форма на прило­жението).

20.   Дефинираме и обработчик на събитието "затваряне на формата", в който извеждаме информация в статус лентата какво се е случило:

private void EditorForm_Closed(object sender,

  System.EventArgs e)

{

  if (mFileName != null)

  {

     SetStatusBarInfo("Closed file: " + mFileName);

  }

  else

  {

     SetStatusBarInfo("Closed file.");

  }

  SetStatusBarLine("");

}

С това формата за редактиране на файлове е готова. Остава само да довършим главната форма и приложението ще е готово.

21.   В главната форма пропуснахме да дефинираме методите за отва­ряне на нов файл, за зареждане на съществуващ файл и за затва­ряне на файл. Ето как можем да ги реализираме:

private void CreateNewFile()

{

  EditorForm editorForm = new EditorForm();

  editorForm.MdiParent = this;

  editorForm.CreateNewFile();

  editorForm.Show();

}

 

private void OpenExistingFile()

{

  if (OpenFileDialog.ShowDialog() != DialogResult.OK)

  {

     return;

  }

 

  string fileName = OpenFileDialog.FileName;

 

  EditorForm editorForm = new EditorForm();

  try

  {

     editorForm.LoadFile(fileName);

     editorForm.MdiParent = this;

     editorForm.Show();

     SetInfoStatusBar("Loaded file: " + fileName);

  }

  catch (IOException)

  {

     editorForm.Dispose();

     MessageBox.Show("Can not load file: " + fileName, "Error");

  }

}

 

private void SaveCurrentFile()

{

  EditorForm activeEditorForm =

     (EditorForm) this.ActiveMdiChild;

  if (activeEditorForm != null)

  {

     activeEditorForm.Save();

  }

}

При създаване и зареждане на файл се създава инстанция на формата за редакция на документи EditorForm и в нея съответно се създава нов документ или се зарежда избрания чрез OpenFileDialog файл, след което тази форма се показва като MDI подчинена в главната.

При записване на текущия документ първо се извлича текущата активна форма (ако има такава) и след това й се извиква методът Save() за записване на отворения в нея документ.

22.   Остана само да дефинираме още няколко обработчика на събития за главната форма и няколко помощни метода, които използваме:

private void MainForm_Load(object sender, System.EventArgs e)

{

  SetInfoStatusBar("Application started.");

}

 

public void SetInfoStatusBar(string aText)

{

  StatusBarPanelInfo.Text = aText;

}

 

public void SetLineStatusBar(string aText)

{

  StatusBarPanelLine.Text = aText;

}

 

static void Main()

{

  Application.Run(new MainForm());

}

23.   Приложението вече е готово и можем да го стартираме и тестваме. Ето как изглежда нашият текстов редактор в действие:

Валидация на данни

Валидацията на данни е необходима, когато в дадена контрола трябва да се допуска въвеждане само на коректни данни, например цяло число, валидна дата и др. В Windows Forms има стандартни средства за вали­да­ция:

-     Validating – събитие за валидация на данните в класа Control. На събитието се подава параметър от тип CancelEventArgs. Ако на свойството Cancel на този обект се зададе стойност true, то на потребителя не се разрешава да напусне контролата.

-     ErrorProvider – отбелязва графично контроли с невалидни данни. До контролата с невалидни данни се появява икона, а когато показа­лецът на мишката застане над иконата, се появява текст с описание на грешката.

Нека разгледаме следващия фрагмент код, илюстриращ валидацията на данни:

private TextBox TextBox1;

private ErrorProvider errorProvider;

...

 

private void TextBox1_Validating(object sender,

  System.ComponentModel.CancelEventArgs e)

{

  try

  {

     Int32.Parse(TextBox1.Text);

     errorProvider.SetError(TextBox1, "");

  }

  catch (FormatException)

  {

     errorProvider.SetError(

       TextBox1, "Integer number expected!");

     e.Cancel = true;

  }

}

Имаме една TextBox контрола, чиито данни ще валидираме, и един ErrorProvider обект, който ще използваме, за да отбелязваме, че контро­лата съдържа невалидни данни.

В обработчика на събитието Validating на контролата се опитваме да конвертираме текста, съдържащ се в нея, в цяло число. Ако конвер­ти­рането пропадне, това означава, че потребителят не е въвел коректни данни. В този случай подаваме на метода SetError(…), на ErrorProvider обекта, наша­та контрола и символен низ с описание на грешката. Това описание ще се появи при задържане на мишката над иконата за грешка. Освен това задаваме на свойството Cancel на подадения CancelEventArgs обект стойност true. Това няма да позволи на потребителя да напусне контролата. Ако конвертирането успее, то потребителят е въвел коректни данни. В този случай отново извикваме метода SetError(…), но този път му подаваме като втори параметър празен низ, което предизвиква скри­ване на иконата, ако тя е била показана.

Валидация на данни – пример  

Настоящият пример е малко по-сложен и илюстрира по-пълно средствата за валидация на данни в Windows Forms – събитието Validating и контро­лата ErrorProvider. Ще създадем просто приложение, състоящо се от две форми – главна форма и форма за въвеждане на ЕГН и година на ражда­не. Главната форма ще извиква формата за въвеждане на ЕГН и година на раждане и при успешно връщане от нея ще визуализира въведените данни. Във формата за въвеждане на ЕГН и година на раждане ще сигна­лизираме на потре­би­те­ля, когато той въведе некоректни данни. 

Ето стъпките за изграждане на нашето приложение:

1.  Стартираме VS.NET и създаваме нов Windows Forms проект.

2.  Задаваме на главната форма име MainForm и заглавие "Main Form". Променяме и името на файла от Form1.cs на MainForm.cs. Създа­ваме и формата за въвеждане на ЕГН и година на раждане (File | Add New Item … | Windows Form). Сменяме името й на ValidationDemoForm, а това на файла й на ValidationDemoForm.cs. Задаваме на свойствата MinimizeBox и MaximizeBox стойности false, а на свойството FormBorderStyle стойност FixedDialog.

3.  В новосъздадената форма поставяме две текстови полета с имена TextBoxEGN и TextBoxYear за въвеждане на EГH и година на раждане. Над всяко от тях поставяме по един Label с текст, указ­ващ предназ­на­че­нието на контролата. Поставяме и два бутона с имена ButtonOK и ButtonCancel за потвърждаване и отказване на формата. На свойството DialogResult на ButtonCancel задаваме стойност Cancel.

4.  Поставяме във формата един компонент ErrorProvider с име errorProvider, който ще използваме за отбелязване на контролите с невалидни данни. Ето как изглежда на формата в този момент:

5.  Добавяме обработчик на събитието Validating на TextBoxEGN кон­тролата:

private void TextBoxEGN_Validating(object sender,

  System.ComponentModel.CancelEventArgs e)

{

  ValidateEGN();

}

 

private bool ValidateEGN()

{

  if (IsEgnValid(TextBoxEGN.Text))

  {

     errorProvider.SetError(TextBoxEGN, "");

     return true;

  }

  else

  {

     errorProvider.SetError(TextBoxEGN, "Невалидно ЕГН!");

     return false;

  }

}

 

private bool IsEgnValid(string aText)

{

  if (aText.Length != 10)

  {

     return false;

  }

 

  for (int i=0; i<aText.Length; i++)

  {

     if (! Char.IsDigit(aText[i]))

     {

       return false;

     }

  }

 

  return true;

}

В обработчика на събитието извикваме функцията ValidateEGN(). В нея, чрез функцията IsEgnValid(…), проверяваме дали въведеното ЕГН е ва­лид­­но. Ако е валидно, посредством ErrorProvider обекта, изтри­ваме мар­ке­­ра за грешка до полето за въвеждане на ЕГН и връщаме стойност true, в противен случай задаваме маркер за греш­ка на полето и връщаме стойност false. Във функцията IsEgnValid(…) проверяваме дали в полето за ЕГН са  въведени десет символа и дали всеки от тях е цифра. Ако е така връщаме стойност true, в противен случай връщаме стойност false.

6.  Добавяме обработчик на събитието Validating на TextBoxYear контролата:

private void TextBoxYear_Validating(object sender,

  System.ComponentModel.CancelEventArgs e)

{

  ValidateYear();

}

 

private bool ValidateYear()

{

  if (IsYearValid(TextBoxYear.Text))

  {

     errorProvider.SetError(TextBoxYear, "");

     return true;

  }

  else

  {

     errorProvider.SetError(TextBoxYear, "Невалидна година!");

     return false;

  }

}

 

private bool IsYearValid(string aText)

{

  string year = TextBoxYear.Text;

  if (year.Length != 4)

  {

     return false;

  }

 

  for (int i=0; i<aText.Length; i++)

  {

     if (! Char.IsDigit(aText[i]))

     {

       return false;

    }

  }

 

  return true;

}

В обработчика на събитието извикваме функцията ValidateYear(). В нея, чрез функцията IsYearValid(…), проверяваме дали въведената година е ва­лид­­на. Ако е валидна, посредством errorProvider обекта, изтриваме мар­ке­­ра за грешка до полето за въвеждане на година и връщаме стойност true, в противен случай задаваме маркер за греш­ка на полето и връщаме стойност false. Във функцията IsYearValid(…) проверяваме дали в полето за година са  въведени четири символа и дали всеки от тях е цифра. Ако е така, връщаме стойност true, в противен случай връщаме стойност false.

7.  Добавяме обработчик на събитието Click на бутона ButtonOK:

private void ButtonOK_Click(object sender, System.EventArgs e)

{

  if (ValidateForm())

  {

     DialogResult = DialogResult.OK;

  }

  else

  {

     MessageBox.Show(

       "Моля въведете валидни стойности във всички полета!",

       "Грешка", MessageBoxButtons.OK, MessageBoxIcon.Error);

  }

}

 

private bool ValidateForm()

{

  if (! ValidateYear())

  {

     return false;

  }

 

  if (! ValidateEGN())

  {

     return false;

  }

      

  string egn = TextBoxEGN.Text;

  string year = TextBoxYear.Text;

  if (egn.Substring(0,2) == year.Substring(2,2))

  {

     errorProvider.SetError(ButtonOK, "");

     return true;

  }

  else

  {

     errorProvider.SetError(ButtonOK,

       "Годината на раждане на съответства на ЕГН-то!");

     return false;

  }

}

При натискане на бутона проверяваме чрез функцията ValidateForm() дали данните, въведени във формата са валидни. Ако са валидни, задава­ме на свойството DialogResult на формата стойност DialogResult.OK, с което връщаме управлението на извикващата форма. Ако данните са невалидни, показваме диалогова кутия с подходящо съобщение.

В метода ValidateForm() проверяваме дали въведените година и ЕГН са валидни чрез функциите ValidateYear() и ValidateEGN(). Ако проверка­та на някое от тези условия пропадне, връщаме стойност false. След това проверяваме дали първите две цифри на ЕГН-то съвпадат с последните две цифри на годината на раждане. Ако съвпадат, посред­ством ErrorProvider обекта, изтриваме мар­ке­­ра за грешка до бутона и връщаме стойност true. Ако цифрите се различават, задаваме маркер за греш­ка на бутона и връщаме стой­ност false.

8.  Добавяме свойства, чрез които да извличаме въведените във фор­мата ЕГН и година на раждане:

public string EGN

{

  get

  {

     return TextBoxEGN.Text;

  }

}

 

public string Year

{

  get

  {

     return TextBoxYear.Text;

  }

}

9.  Добавяме в главната форма бутон с име ButtonShow и текст Show Form. В обработчика на събитието Click на този бутон ще извик­ваме формата за въвеждане на ЕГН и година на раждане в модален режим и при успешно връщане от нея ще визуализираме въведе­ните данни:

private void ButtonShow_Click(object sender, System.EventArgs e)

{

  ValidationDemoForm validationDemoForm = new

     ValidationDemoForm();

  if (validationDemoForm.ShowDialog() == DialogResult.OK)

  {

     string s = String.Format("ЕГН: {0}\nГодина: {1}",

       validationDemoForm.EGN, validationDemoForm.Year);

     MessageBox.Show(s, "Резултат");

  }

  validationDemoForm.Dispose();

}

10.  Приложението вече е готово и можем да го стартираме и тестваме:

Свързване на данни

Свързването на данни (data binding) осигурява автоматично прехвърляне на данни между контроли и източници на данни. Можем например да свържем масив, съдържащ имена на градове, с ComboBox контрола и име­на­та от масива ще се показват в нея.

При добавянето на свързване указваме свойството на контролата, което ще свързваме с данните, източника на данните и път до списък или свой­ство на източника, към което ще се свържем. Този път може да е име на свойство, йерархия от имена, разделени с точки, или празен низ. Ако пътят е празен низ, ще се извика методът ToString() на обекта, използван като източник на данни.

Свързването на данни е еднопосочно – от контролата към източника на данни!

Промяна на дадено свързано свойство от дадена контрола променя дан­ни­­те в източника, към който то е свързано. Обратното не е вярно. При про­мя­на на източника на данни свързаните към него контроли не си про­ме­нят свойствата.

Ако сме променили данните в източника на данни и искаме да отразим промените в свързаните с него контроли, трябва първо да премахнем (изтрием) свързването и след това да го добавим отново.

Източници на данни

Като източник на данни можем да използваме всеки клас или компонент, който имплементира интерфейса IList. Такива са масивите и колекциите. За източници на данни можем да използваме и класове или компоненти, които имплементират интерфейса IBindingList. Този интерфейс поддър­жа нотификация за промяна на данните. IBindingList интерфейсът се имплементира от класа DataView (вж. темата за ADO.NET).

Контроли, поддържащи свързване на данни

Всички Windows Forms контроли поддържат свързване на данни (data binding). Можем да свър­жем което и да е свойство на контрола към източник на данни.

Видове свързване

В Windows Forms имаме два типа свързване на данни:

-     Просто свързване (simple binding) – свързване на контрола с еди­ни­чен обект или единичен (текущ) елемент от списък. Такова свър­зва­не използваме обикновено с контроли като TextBox и CheckBox, кои­то показват единична стойност.

-     Сложно свързване  (complex binding) – свързване на списъчна кон­трола със списък. Такова свързване използваме с контроли като ListBox, ComboBox и DataGrid. При него се поддържа текущо избран (активен) елемент от списъка. 

Просто свързване

Чрез следващите фрагменти код ще илюстрираме как се осъществява просто свързване на данни в зависимост от източника на данни.

Свързване на контрола към обект

Нека имаме клас Customer, който има свойство Name и TextBox контрола с име TextBoxName. Свързването на свойството Text на TextBox контролата към свойството Name на обект от тип Customer се извършва по следния начин:

class Customer

{

  private string mName;

  public string Name

  {

     get { return mName; }

     set { mName = value; }

  }

}

 

Customer cust = new Customer();

cust.Name = "Бай Иван";

 

TextBoxName.DataBindings.Add(new Binding("Text", cust, "Name"));

Използвахме колекцията DataBindings на класа Control. В нея можем да добавяме Binding обекти, които указват кое свойство на текущата кон­трола с кое свойство на дадена друга контрола да бъде свързано. В нашия случай при промяна на TextBoxName.Text ще се променя и свойството Name на свързания обект cust.

Свързване на контрола към списък

Нека имаме масив towns, съдържащ имена на градове, и TextBox контрола с име TextBoxTowns. Свързването на свойството Text на TextBox контро­ла­та към масива с имена на градове се извършва по следния начин:

string[] towns = {"София", "Пловдив", "Варна"};

TextBoxTowns.DataBindings.Add(new Binding("Text", towns, ""));

Оставили сме пътя до свойството на източника, към което ще се свържем, да е празен низ, защото в случая искаме да свържем свойството Text директно с елементите на масива, който използваме като източник на данни, а не с тяхно свойство. При това свързване текстовата контрола ще се свърже първоначално с първия елемент от масива (символния низ "София"), но след това програмно може да се укаже промяна на текущия елемент и свързването да се промени към някой друг от елементите на масива. На начините за промяна на текущия елемент на свързването ще се спрем след малко.

Свързване на контрола към таблица

Нека имаме DataSet обект ds с таблица Towns с колони id и name и TextBox контрола с име TextBoxTowns. Свързването на свойството Text на TextBox контро­ла­та към колоната name от таблицата може да се извърши по следния начин:

// Create a DataTable with columns id and name

DataTable towns = new DataTable("Towns");

towns.Columns.Add(new DataColumn("id", typeof(int)));

towns.Columns.Add(new DataColumn("name", typeof(string)));

 

// Add three rows to the table

DataRow row;

 

row = towns.NewRow();

row["id"] = 1;

row["name"] = "София";

towns.Rows.Add(row);

 

row = towns.NewRow();

row["id"] = 2;

row["name"] = "Пловдив";

towns.Rows.Add(row);

 

row = towns.NewRow();

row["id"] = 3;

row["name"] = "Варна";

towns.Rows.Add(row);

 

// Create a DataSet and add the table to the DataSet

DataSet ds = new DataSet();

ds.Tables.Add(towns);

 

TextBoxTowns.DataBindings.Add(

  new Binding("Text", ds, "Towns.name"));

За да укажем, че искаме да свържем свойството Text на TextBox контро­лата с колоната name на таблицата Towns от източника на данни ds, зада­ваме "Towns.name" за път до свойството на източника. Текстовото поле ще бъде свързано първоначално с първия ред на таблицата, и по-точно с полето name от този ред, но по-късно текущият ред може да бъде проме­нен програмно.

Просто свързване с VS.NET

Свързването може да става и по време на дизайн в редактора на VS.NET, ако за източник на данни използваме DataSet. За целта от прозореца Properties на редактора избираме Databindings | Advanced. Появява се прозорецът Advanced Data Binding. В него виждаме списък от свойствата на контролата. Намираме свойството, за което искаме да добавим свърз­ване, и от падащия списък в дясно от него избираме източника на данни.

Свързване на контрола към обект – пример

С настоящия пример ще илюстрираме простото свързване (simple binding) в Windows Forms. За целта ще създадем просто приложение, в което ще свържем свойство на контрола със свойство на даден обект.

Ето стъпките за изграждане на нашето приложение:

1.  Стартираме VS.NET и създаваме нов Windows Forms проект.

2.  Задаваме на главната форма име MainForm и заглавие "Binding Control To Object". Променяме и името на файла от Form1.cs на MainForm.cs.

3.  Дефинираме клас Customer, с чийто обект ще свържем по-късно контро­лата. Класът има свойство Name, даващо достъп до името на клиента:

class Customer

{

  private string mName;

  public string Name

  {

     get { return mName; }

     set { mName = value; }

  }

}

4.  Добавяме в класа MainForm една член-променлива mCustomer. С нея ще свържем текстово поле във формата.

private Customer mCustomer;

5.  В главната форма поставяме една TextBox контрола с име TextBoxCustomerName, която ще свържем с Customer обекта и три бутона с имена ButtonShowCustomer, ButtonChangeCustomer и ButtonRebind. Тези бутони ще служат съответно за показване на името на клиента, за промяна на името и за извършване на свърз­ва­не (data binding) на текстовото поле с Customer обекта.

6.  В класа MainForm добавяме функция RebindFormControls(), която свързва свойството Text на текстовата контрола със свойството Name на Customer обекта. За целта първо свързването се изтрива (в случай, че е било вече създадено) и след това се добавя отново:

private void RebindFormControls()

{

  TextBoxCustomerName.DataBindings.Clear();

  TextBoxCustomerName.DataBindings.Add(

     new Binding("Text", mCustomer, "Name"));

}

7.  Добавяме код, който при зареждане на формата (при събитие Load на формата) да инициализира Customer обекта и да го свърже с текстовата контрола:

private void MainForm_Load(object sender, System.EventArgs e)

{

  mCustomer = new Customer();

  mCustomer.Name = "Бай Иван";

 

  RebindFormControls();

}

8.  Добавяме обработчик на събитието Click на ButtonShowCustomer бутона. В него извличаме стойността на полето Name на Customer обекта и я показваме в диалогова кутия:

private void ButtonShowCustomer_Click(object sender,

  System.EventArgs e)

{

  string customerName = mCustomer.Name;

  MessageBox.Show(customerName);

}

9.  Добавяме обработчик на събитието Click на ButtonChangeCustomer бутона. В него променяме стойността на полето Name на Customer обекта:

private void ButtonChangeCustomer_Click(object sender,

  System.EventArgs e)

{

  mCustomer.Name = "Дядо Мраз";

}

10.  Добавяме обработчик на събитието Click на бутона ButtonRebind. В него извикваме функцията RebindFormControls(), която извър­шва повторно свързване на текстовата контрола с името на клиента от Customer обекта, при което това име се появява в контролата:

private void ButtonRebind_Click(object sender,

  System.EventArgs e)

{

  RebindFormControls();

}

11.  Приложението вече е готово и можем да го стартираме и тестваме.

Ако въведем стойност в полето и натиснем първия бутон, в диалоговата кутия ще се покаже въведената стойност. Това показва, че стойността се е прехвърлила в Customer обекта:

Ако натиснем втория бутон, стойността в Customer обекта ще се промени. Това можем да проверим като натиснем първия бутон и изведем стойност­та в диалогова кутия. Въпреки че стойността в Customer обекта е променена, текстовото поле не се променя. Това е така, защото свързва­не­то в Windows Forms е еднопосочно – от контролата към свързвания обект, но не и обратно.

Ако сега натиснем третия бутон, текстовото поле ще се промени. Това е така, защото извършваме повторно свързване и името на клиента от Customer обекта се прехвърля в текстовото поле.

Binding Context

Формата пази информация за свързаните контроли в своя BindingContext обект. Всеки обект, наследен от класа Control, има един BindingContext, който управлява BindingContextBase обектите за контролите, които се съдържат в него и за самия обект. Чрез него можем да извлечем BindingContextBase обект за източник на данни, свързан с някоя кон­тро­ла.

Понеже BindingContextBase е абстрактен клас, типът на върна­та­та стойност, в зависимост от източника на данни, е или CurrencyManager или PropertyManager, които са на­след­ни­ци на класа BindingContextBase. Ако източникът на данни е обект, който връща само една стойност (не е спи­сък от обекти), тогава типът ще бъде PropertyManager. Ако източникът на данни имплементира някой от интерфейсите IList, IListSource или IBindingList, ще бъде върнат CurrencyManager.

На следващата фигура са показани схематично отношенията между Binding Context, Currency Manager и Property Manager:

Навигация с CurrencyManager

Класът CurrencyManager пази текущата позиция в списъка-източник на дан­ни. Тя се съдържа в свойството Position. Свойството Count съдържа размера на списъка. Използвайки тези свойства, можем да извършваме навигация по източника на данни. За целта извличаме CurrencyManager обекта, свързан с източника на данни и променяме стойността на свой­ство­то Position.

Извличането на CurrencyManager обекта се извършва или чрез свойството DataBindings на свързаната контрола, или чрез BindingContext свойство­то на фор­ма­та:

CurrencyManager cm = (CurrencyManager)

  textBox1.DataBindings["Text"].BindingManagerBase;

 

// Може и така:

CurrencyManager cm = (CurrencyManager)

  form1.BindingContext[dataTableCustomers];

Навигацията по списъка се извършва чрез промяна на Position:

cm.Position++;

Свързване на контрола към списък и навигация – пример

С настоящия пример ще илюстрираме просто свързване (simple binding) на контрола към списък и навигация по списъка чрез CurrencyManager.

Ето стъпките за изграждане на приложението:

1.  Стартираме VS.NET и създаваме нов Windows Forms проект.

2.  Задаваме на главната форма име MainForm и заглавие "Binding Control To List". Променяме и името на файла от Form1.cs на MainForm.cs.

3.  Поставяме върху главната форма една TextBox контрола с име TextBoxTowns, която ще свържем с масив от символни низове - имена на градове, и два бутона с имена ButtonPrev и ButtonNext. Тези бутони ще служат съответно за навигация напред и назад по списъка с градовете. На свойството Text на двата бутона задаваме съответно стойности "<< Prev" и "Next >>".

4.  Добавяме код, който при зареждане на формата (при събитие Load на формата) свързва текстовото поле с масив, съдържащ имена на градове:

private void MainForm_Load(object sender, System.EventArgs e)

{

  string[] towns = {"София", "Пловдив", "Варна",

     "Русе", "Бургас"};

  TextBoxTowns.DataBindings.Add(

     new Binding("Text", towns, ""));

}

5.  Добавяме обработчик на събитието Click на бутона ButtonPrev. В него извличаме от CurrencyManager обекта на текстовата контрола теку­щата позиция в списъка с градовете и я намаляваме, като, ако сме достигнали началото, позиционираме в края:

private void ButtonPrev_Click(object sender, System.EventArgs e)

{

  CurrencyManager cm = (CurrencyManager)

     TextBoxTowns.DataBindings["Text"].BindingManagerBase;

  if (cm.Position > 0)

  {

     cm.Position--;

  }

  else

  {

     cm.Position = cm.Count-1;

  }

}

6.  Добавяме обработчик на събитието Click на бутона ButtonNext. В него извличаме от CurrеncyManager на текстовата контрола теку­щата позиция в списъка с градовете и я увеличаваме, като, ако сме достигнали края, позиционираме в началото:

private void ButtonNext_Click(object sender, System.EventArgs e)

{

  CurrencyManager cm = (CurrencyManager)

     TextBoxTowns.DataBindings["Text"].BindingManagerBase;

  if (cm.Position < cm.Count-1)

  {

     cm.Position++;

  }

  else

  {

     cm.Position = 0;

  }

}

7.  Приложението е готово и можем да го стартираме и тестваме.

При натискане на бутоните в текстовото поле ще се сменят имената на градовете. Ако променим името на някой град, промяната се отразява в масива с имената.

Сложно свързване

При сложното свързване имаме свързване на контрола към списък, като контролата се свързва с повече от един елемент от списъка. Сложното свързване се използва при списъчни контроли – ListBox, ComboBox и др.

За да свържем списъчна контрола със списък, трябва да зададем стой­ност­и на следните свойства:

-     DataSource – източника на данни, с който ще свържем контролата.

-     DisplayMember – път до полето, което да се визуализира.

-     ValueMember – път до полето, от което се получава резултатът.

Стойността по подразбиране в DisplayMember и ValueMember е празен низ.

Ето как задаваме стойност на тези свойства:

DataSet dataSetCountries = ...;

comboBox1.DataSource = dataSetCountries;

comboBox1.DisplayMember = "Countries.CountryCode";

comboBox1.ValueMember = "Countries.Name";

Сложно свързване на контрола към списък – пример

С настоящия пример ще илюстрираме сложното свързване (complex data binding) в Windows Forms. За целта ще създадем просто приложение, в което ще свържем списъчна контрола със списък.

Ето стъпките за изграждане на нашето приложение:

1.  Стартираме VS.NET и създаваме нов Windows Forms проект.

2.  Задаваме на главната форма име MainForm и заглавие "Complex Binding". Променяме името на файла от Form1.cs на MainForm.cs.

3.  Поставяме във формата един бутон с име ButtonShow и една ComboBox контрола с име ComboBoxTowns. На свойството Text на бутона задаваме стойност Show. ComboBox контролата ще свържем с масив от символни низове - имена на градове, а чрез бутона ще показваме стойността, избрана в нея.

4.  Добавяме код, който при зареждане на формата (при събитие Load) свързва ComboBox контролата с масив, съдържащ имена на градове:

private void MainForm_Load(object sender, System.EventArgs e)

{

  string[] towns = {"София", "Пловдив", "Варна",

     "Русе", "Бургас"};

  ComboBoxTowns.DataSource = towns;

  ComboBoxTowns.DisplayMember = "";

}

5.  Добавяме обработчик на събитието Click на бутона ButtonShow. В него показваме в диалогова кутия стойността, избрана в ComboBox контролата:

private void ButtonShow_Click(object sender, System.EventArgs e)

{

  MessageBox.Show(ComboBoxTowns.SelectedValue.ToString());

}

6.  Приложението ни е готово и можем да го стартираме и тестваме.

Сложно свързване с VS.NET

Сложното свързване може да става и по време на дизайн в редактора на VS.NET, ако за източник на данни използваме DataSet. За целта в прозо­ре­ца Properties на редактора щракваме върху падащия списък от дясно на свойството DataSource и избираме от него източник на данни. След това избираме от падащите списъци в дясно от свойствата DisplayMember и ValueMember полето, което ще се визуализира, и полето, от което ще се получава резултатът:

Контролата DataGrid

DataGrid контролата визуализира таблични данни. Тя осигурява нави­га­ция по редове и колони и позволява редактиране на данните. Като източ­ник на данни най-често се използват ADO.NET DataSet и DataTable. Чрез свой­ството DataSource се задава източникът на данни, а чрез свойството DataMember – пътят до данните в рамките на източника. По-важни свойства на контролата са:

-     ReadOnly – разрешава / забранява редакцията на данни.

-     CaptionVisible – показва / скрива заглавието.

-     ColumnHeadersVisible – показва / скрива заглавията на колоните.

-     RowHeadersVisible – показва / скрива колоната в ляво от редовете.

-     TableStyles – задава стилове за таблицата.

o   MappingName – задава таблицата, за която се отнася дефини­ра­ният стил.

o   GridColumnStyles – задава форматиране на отделните колони – заглавие, ширина и др.

Противно на очакванията контролата DataGrid няма събитие "смяна на текущия избран ред". Ако ви се налага да извършвате някакво действие при смяна на текущия избран ред (например да запишете промените по текущия ред в базата данни), можете да прихванете събитието CurrentCellChanged, което се активира при промяна на текущата клетка. Ако запомните в член-променлива в класа на формата коя е била предишната текуща клетка, ще можете да проверите дали текущият ред е бил променен. Текущата клетка е достъпна от свойството CurrentCell.

Препоръчителен начин за използване на DataGrid контролата е в режим ReadOnly=true. В този случай не се разрешават директни промени, а това спестява много проблеми. Ако е необходимо редактиране на редове или добавяне на нови, това може да се направи с отделен диалогов прозорец, който излиза при натискане на бутон "Edit" или "Add" при избран ред от таблицата.

Работа с DataGrid контролата – пример

С настоящия пример ще илюстрираме работата с DataGrid контролата в Windows Forms и сложното свързване (complex data binding) на таблица от DataSet с DataGrid.

Ето стъпките за изграждане на нашето приложение:

1.  Стартираме VS.NET и създаваме нов Windows Forms проект.

2.  Задаваме на главната форма име MainForm и заглавие "DataGrid Demo". Променяме и името на файла от Form1.cs на MainForm.cs.

3.  Поставяме във формата една DataGrid контрола. За име на контро­ла­та задаваме DataGridTowns.

4.  Добавяме код, който при зареждане на формата (при събитие Load) създава DataSet, съдържащ таблица Towns с две колони – id и име на град. След като той e създаден, свързваме DataGrid контро­лата с таблицата Towns от този DataSet:

private void MainForm_Load(object sender, System.EventArgs e)

{

  // Create table "Towns"

  DataTable towns = new DataTable("Towns");

  towns.Columns.Add(new DataColumn("id", typeof(int)));

  towns.Columns.Add(new DataColumn("name", typeof(string)));

      

  // Add some rows in the table

  DataRow row = towns.NewRow();

  row["id"] = 1;

  row["name"] = "София";

  towns.Rows.Add(row);

 

  row = towns.NewRow();

  row["id"] = 2;

  row["name"] = "Пловдив";

  towns.Rows.Add(row);

 

  row = towns.NewRow();

  row["id"] = 3;

  row["name"] = "Варна";

  towns.Rows.Add(row);

      

  row = towns.NewRow();

  row["id"] = 4;

  row["name"] = "Русе";

  towns.Rows.Add(row);

      

  // Add table "Towns" to the DataSet

  DataSet ds = new DataSet();

  ds.Tables.Add(towns);

 

  // Bind the DataGrid to the DataSet

  DataGridTowns.DataSource = ds;

  DataGridTowns.DataMember = "Towns";

}

5.  Приложението е готово и можем да го стартираме и тестваме.

Ако променим данните, визуализирани в DataGrid контролата, те ще се променят и в таблицата Towns от DataSet обекта.

TableStyles и дефиниране на стилове – пример

Настоящият пример илюстрира работата с DataGrid контролата в Windows Forms и възможностите за дефиниране на стилове за визуализацията на данните чрез колекцията TableStyles. Ще създадем просто приложение, подобно на това от предходния пример, но чрез колекцията TableStyles ще опре­делим как да бъдат визуализирани колоните на таблицата.

Ето и стъпките за изграждане на нашето приложение:

1.  Началните стъпки за изграждане на приложението са същите като стъпки от 1 до 4 в предишния пример. Изпълняваме ги и пре­ми­наваме към дефинирането на стиловете за визуализация на данните.

2.  Щракваме с десния бутон на мишката върху поставения в главната форма DataGrid и избираме Properties. В прозореца Properties на редактора избираме свойството TableStyles и щракваме върху бутона с многоточието, намиращ се в полето в дясно от него. Отваря се прозорец, който ни позволява да добавяме стилове за таблицата. Щракваме върху бутона Add, за да добавим нов стил. В дясната половина на прозореца можем да променяме свойствата на добавения стил. Намираме свойството Name и му задаваме стойност DataGridTableStyleTowns.

3.  На свойството MappingName задаваме стойност Towns. С това указ­ва­ме, че този стил се отнася за таблицата Towns. Задаваме на свой­ството AlternatingBackColor (указващо цвят, в който ще се оцве­тяват четните редове) стойност Info. Остана да зададем стилове за отделните колони.

4.  Щракваме върху бутона с многоточието, намиращ се в полето в дясно от свойството GridColumnStyles. Отваря се прозорец, който ни позволява да добавяме стилове за отделните колони. Щракваме върху бутона Add, за да добавим нов DataGridTextBoxColumn в ко­лекцията. Задаваме стойност DataGridTextBoxColumnName на свой­ството Name.

5.  Задаваме на свойството MappingName стойност name. Така указваме, че този стил се отнася за полето name. Задаваме на свойствата Alignment, HeaderText и NullText съответно стойности Center, "име на град" и "(няма данни)". Така заглавието на колоната ще е "име на град", текстът ще е центриран, а когато няма стойност в полето, в таблицата ще се визуализира "(няма данни)". Накрая указваме ширина на колоната, като на свойството width зададем стойност 200.

6.  Натискаме бутона [OK], за да запазим промените в колекцията със стиловете за колоните. След това натискаме бутона [OK] и в другия прозорец, за да запазим промените в стиловете за таблиците.

7.  Приложението е готово и можем да го стартираме и тестваме.

Забелязваме, че макар в таблицата Towns да има две колони, в нашия DataGrid се визуализира само едната. Това е така, защото се визу­ализират само полетата, за които са добавени стилове в колекцията GridColumnStyles. Това означава, че ако не искаме дадено поле да бъде визуализирано, просто не указваме стил за него.

Ще отбележим, че когато добавяме стил в колекцията GridColumnStyles, освен DataGridTextBoxColumn, можем да добавяме и DataGridBoolColumn. Това става, като щракнем върху стрелката, намираща се в дясната част на бутона Add, и от падащия списък изберем DataGridBoolColumn. Чрез DataGridBoolColumn определяме колона, която във всяка клетка съдържа поле с отметка, представящо булева стойност.

Master-Details навигация

Навигацията "главен/подчинен" (master-details) отразява взаимоотноше­ния от тип едно към много (например един регион има много области). В ADO.NET DataSet обектите поддържат релации от тип "главен/подчинен". За целта се из­ползват DataRelation обектите в DataSet.

В Windows Forms се поддържа навигация "главен/подчинен". За да илюстри­раме работата с нея, нека разгледаме един пример: Имаме DataSet, съдържащ две таблици – едната съдържа имена на държави, а другата – имена на градове. Те са свързани помежду си така, че на всяка държава от първата таблица съответстват определени градове от втората таблица:

Тогава можем да използваме две DataGrid контроли – първата, визуали­зи­ра­ща държавите, а втората, визуализираща градовете, съответ­ства­щи на текущо избраната държава от първата контрола. За целта контролите се свър­зват с един и същ DataSet. На главната контрола се задава за източ­ник на данни главната таблица. На подчинената кон­тро­ла се задава за източ­ник на данни релацията на таблицата:

// Bind the master grid to the master table

DataGridCountries.DataSource = datasetCountriesAndTowns;

DataGridCountries.DataMember = "Countries";

 

// Bind the detail grid to the relationship

DataGridTowns.DataSource = datasetCountriesAndTowns;

DataGridTowns.DataMember = "Countries.CountriesTowns";

Master-Details навигация – пример

Настоящият пример илюстрира възможностите за реализация на Master-Details навигация, базирана на DataSet компонентата от ADO.NET и сложното свързване на списъчни контроли в Windows Forms. В примера ще използваме базата данни Northwind – една от стандартните демон­страционни бази в MS SQL Server.

Ще създадем приложение, което има в главната си форма две контроли – ListBox, който показва региони (от таблицата Region от базата данни), и DataGrid, който показва областите за всеки регион (от таблицата Territories от базата данни).

Ето и стъпките за изграждане на нашето приложение:

1.  Стартираме VS.NET и създаваме нов Windows Forms проект.

2.  Задаваме на главната форма име MainForm и заглавие "Master-Detail Demo". Променяме и името на файла от Form1.cs на MainForm.cs.

3.  В прозореца Server Explorer от VS.NET намираме демонстрацион­ната база данни Northwind на MS SQL Server. Щракваме върху таблицата Region и след това, натискайки клавиш Ctrl, щракваме върху таблицата Territories. След като сме маркирали едновре­менно и двете таблици, ги извличаме върху формата. Ако прозоре­цът Server Explorer не е отворен, можем да го отворим, като изберем View | Server Explorer.

4.  Windows Forms редакторът автоматично създава за нас един SqlConnection и два SqlDataAdapter компонента. Променяме техните имена съответно на sqlConneciton, sqlDataAdapterRegion и sqlDataAdapterTerritories:

5.  От менюто Data избираме Generate Dataset… В появилия се прозо­рец указваме, че искаме да създадем нов DataSet и задаваме за име DataSetNorthwind. Поставяме отметки и пред двете таблици и натискаме бутона [OK], за да създадем новия DataSet. Променяме името на появилия се в редактора DataSet на dataSetNorthwind.

6.  Щракваме с десния бутон върху dataSetNorthwind в редактора и от появилото се контекстно меню избираме View Schema… Отваря се файлът DataSetNorthwind.xsd - виждаме XSD схемата на DataSet-a, генериран на базата на таблиците Region и Territories.

7.  От Toolbox извличаме един Relation обект и го пускаме върху таб­ли­цата Territories. В появилия се прозорец се уверяваме, че за Parent element e избрана таблицата Region, а за Child element - таблицата Territories, и натискаме бутона OK. Така де­фи­ни­рах­ме релация тип Master-Details между таблиците Region и Territories.

8.  Добавяме във формата един ListBox с име ListBoxRegions. На свойството DataSource задаваме стойност dataSetNorthwind, а на свойствата DisplayMember и ValueMember – съответно стойности Region.RegionDescription и Region.RegionID.

9.  Добавяме във формата един DataGrid с име DataGridTerritories. Задаваме на свойствата DataSource и DataMember съответно стой­ности dataSetNorthwind и Region.RegionTerritories.

10.  Дефинираме стил с име dataGridTableStyleTerritories за табли­цата Territories. В колекцията му GridColumnStyles добавяме стилове за полетата TerritoryID и TerritoryDescription, като указваме, че тези колони трябва да са със заглавия - съответно код и област.

11.  Добавяме код, който при зареждане на формата (при събитие Load) зарежда DataSet обекта от базата данни чрез DataAdapter компо­нентите за двете таблици (Region и Territories):

private void MainForm_Load(object sender, System.EventArgs e)

{

  sqlDataAdapterRegion.Fill(dataSetNorthwind);

  sqlDataAdapterTerritories.Fill(dataSetNorthwind);

}

12.  Приложението е готово и можем да го стартираме и тестваме:

Проблеми при Master-Details навигацията

Показаният начин за реализация на master-details навигация е лесен за използване, но има един сериозен проблем: винаги зарежда в паметта всички записи от двете таблици. Ако таблиците са обемни, този подход ще работи много бавно или въобще няма да работи. Причината е, че зареждането на голям обем записи (да кажем няколко хиляди) в DataSet изисква много памет и става бавно.

Ако данните са много, можем да подходим по следния начин: Зареждаме всички данни от главната (master) таблица и ги визуализираме с DataGrid или ListBox. След това прихващаме събитието "смяна на текущия ред" и при неговото настъпване зареждаме в подчинената (details) таблица де­тайлните записи за избрания запис от главната таблица. Зареждането може да се извърши с параметрична SQL заявка, изпълнена през SqlDataReader или SqlDataAdapter.

Релации "много към много"

DataSet и DataGrid не поддържат релации тип "много към много". Такъв тип релации могат да бъдат сведени до Master-Details чрез добавяне на изглед в базата данни. Нека примерно имаме база данни, съдържаща таблици Courses и Students и таблица StudentsCourses, осъществяваща връзка между тях.

За да сведем тази релация към Master-Details, можем да създадем изглед в базата данни:

CREATE VIEW View_StudentsCourses AS

  SELECT StudentId, StudentName, CourseId, CourseName

  FROM Students, Courses, StudentsCourses

  WHERE Students.StudentsId = StudentsCourses.StudentId

  AND Courses.CourseId = StudentsCourses.CourseId

След като сме създали изгледа, можем да сведем релацията до релация Master-Details между таблицата Courses и новосъздадения изглед:

Аналогично на предходния пример можем да работим с таблиците, които са вече във взаимоотношение "главен/подчинен":

Наследяване на форми

Наследяването на форми позволява повторно използване на части от потребителския интерфейс. Чрез него е възможно да променим наведнъж общите части на много форми. За целта дефинираме една базова форма, която съдържа общата за всички наследници функционалност.

Базовата форма е най-обикновена форма. Единствената особеност е, че контролите, които могат да се про­менят от наследниците, се обявяват като protected. Виртуални методи могат да реализират специфичната за наследниците функционал­ност, достъпна от базовата форма.

При наследяване на форма се наследява класът на базовата форма. При това се указва името на пространството, в което е дефинирана базовата форма, следвано от точка, и името на базовата форма. Във Visual Studio .NET формите наследници могат да се създават, като от менюто се избере File | Add New Item… | Inherited Form.

При наследяването на форми можем да поставим базовата форма и формите-наследници в различни асемблита и след това да проме­няме всички форми-наслед­ници чрез промяната на единичен DLL файл.

Една особеност на VS.NET е, че по време на дизайн промените, напра­вени върху базовата форма, не се отразяват върху формите наследници, преди да бъде прекомпилирано приложението.

Наследяване на форми – пример

Настоящият пример илюстрира възможностите за наследяване на форми в Windows Forms, при което се наследяват всички контроли в тях, както и методите и свойствата на класа, в който са дефинирани. В примера ще създадем четири форми:

-     MainForm – главната форма на приложението, която ще служи за показване на другите форми при натискане на съответния бутон.

-     BaseForm – базова форма, от която други форми наследяват потребителски интерфейс и базова функционалност.

-     AddressForm – форма за попълване на адрес, наследник на BaseForm.

-     ItemsDetailsForm - форма за попълване на описание на продукт, наследник на BaseForm.

Схематично наследяването между формите е показано на фигурата по-долу:

Ето и стъпките за изграждане на нашето приложение:

1.  Стартираме VS.NET и създаваме нов Windows Forms проект.

2.  Задаваме на главната форма име MainForm и заглавие "Main Form". Променяме и името на файла от Form1.cs на MainForm.cs.

3.  Добавяме нова форма с име BaseForm. Това ще бъде нашата базова форма. От нея ще наследим останалите форми. В нея поставяме един Panel с име PanelMain и три бутона ButtonOK, ButtonCancel и ButtonReset. Дефинираме панела като protected, за да може да се променя от наследниците. Бутоните ButtonOK и ButtonCancel имат обичайното предназначение, което е зададено със свойствата AcceptButton и CancelButton на формата.

4.  Добавяме обработчик на събитието Click на бутона ButtonReset. В него ще извикваме виртуалния метод ResetFormFields(), който тряб­ва да се имплементира в наследниците и трябва да изтрива всички полета:

private void ButtonReset_Click(object sender,System.EventArgs e)

{

  ResetFormFields();

}

5.  Добавяме и виртуалния метод ResetFormFields():

protected virtual void ResetFormFields()

{

  // Descendand form should implement reset functionality here

}

6.  Компилираме приложението, за да се създаде асемблито, в което ще се съдържа формата, от която ще наследяваме. За целта избираме Build | Build Solution.

7.  Добавяме първата форма-наследник. За целта избираме File | Add New Item… | Inherited Form. Въвеждаме за име на формата AddressForm и натискаме бутона open. От появилия се списък изби­раме BaseForm за компонент, от който ще наследяваме. Отваря се формата-наследник, която изглежда точно като базовата форма.

8.  Променяме заглавието й на Address Form. Добавяме във формата един TextBox с име TextBoxAddress и две ComboBox контроли с имена ComboBoxTown и ComboBoxCountry. Задаваме на свойството Multiline на TextBoxAddress стойност true. За DropDownStyle на ComboBox контролите задаваме DropDownList. В колекцията Items на ComboBoxTowns въвеждаме няколко имена на български градове, а в тази на  ComboBoxTowns въвеждаме "България".

9.  Предефинираме метода ResetFormFields() така, че да изчиства поле­та­та на формата:

protected override void ResetFormFields()

{

  this.TextBoxAddress.Clear();

  this.ComboBoxTown.SelectedIndex = -1;

  this.ComboBoxCountry.SelectedIndex = -1;

}

10.  Добавяме втората форма-наследник. Задаваме ItemDetailsForm за име на формата. Променяме заглавието й на Item Details Form. Добавяме във формата две TextBox контроли с имена TextBoxName и TextBoxPrice, един ComboBox с име ComboBoxCategory и един CheckBox с име ChackBoxAvailability. За DropDownStyle на ComboBoxCategory задаваме DropDownList, а в колекцията Items въвеждаме няколко категории – "Алкохол", "Безалкохолни напитки", "Колбаси", "Стоки за бита". Задаваме на свойството Text на ChackBoxAvailability стойност "Наличност".

11.  Предефинираме и в тази форма метода ResetFormFields() така, че да изчиства поле­та­та:

protected override void ResetFormFields()

{

  this.TextBoxName.Clear();

  this.TextBoxPrice.Clear();

  this.ComboBoxCategory.SelectedIndex = -1;

  this.CheckBoxAvailability.Checked = false;

}

12.  Поставяме подходящи етикети на контролите във формите – например при TextBoxName поставяме етикет, чието свойство Text има стойност "Име на продукт:".

13.  В главната форма добавяме два бутона с имена ButtonAddressForm и ButtonItemDetailsForm. В обработчиците на събитията Click на тези бутони ще показваме формите наследници:

private void ButtonAddressForm_Click(object sender,

  System.EventArgs e)

{

  AddressForm addressForm = new AddressForm();

  addressForm.ShowDialog();

  addressForm.Dispose();

}

 

private void ButtonItemDetailsForm_Click(object sender,

  System.EventArgs e)

{

  ItemDetailsForm itemDetailsForm = new ItemDetailsForm();

  itemDetailsForm.ShowDialog();

  itemDetailsForm.Dispose();

}

14.  Приложението е готово и можем да го стартираме и тестваме:

Пакетът System.Drawing и GDI+

Пакетът System.Drawing осигурява достъп до GDI+ функциите на Windows:

-     повърхности за чертане

-     работа с графика и графични трансформации

-     изчертаване на геометрични фигури

-     работа с изображения

-     работа с текст и шрифтове

-     печатане на принтер

Той се състои от няколко пространства:

-     System.Drawing – предоставя основни класове като повърхности, моливи, четки, класове за изобразяване на текст.

-     System.Drawing.Imaging – предоставя класове за работа с изобра­же­ния, картинки и икони, класове за записване в различни файлови формати и за преоразмеряване на изображения.

-     System.Drawing.Drawing2D – предоставя класове за графични транс­формации – бленди, матрици и др.

-     System.Drawing.Text – предоставя класове за достъп до шрифто­вете на графичната среда.

-     System.Drawing.Printing – предоставя класове за печатане на принтер и системни диалогови кутии за печатане.

Класът Graphics

Класът System.Drawing.Graphics предоставя абстрактна повърхност за чертане. Такава повърхност може да бъде както част от контрола на екрана, така и част от страница на принтер или друго устройство.

Най-често чертането се извършва в обработчика на събитието Paint. В него при необходимост се преизчертава графичния облик на контролата. Параметърът PaintEventArgs, който се подава, съдържа Graphics обекта. Graphics обект може да се създава чрез Control.CreateGraphics(). Той задължително трябва да се освобождава чрез finally блок или с конс­трукцията using, защото е ценен ресурс.

Работа със System.Drawing – пример

Чрез настоящия пример ще илюстрираме работата с GDI+ чрез пакета System.Drawing – чертане на геометрични фигури с четки и моливи и изобразяване на текст със зададен шрифт.

Ето и стъпките за изграждане на нашето примерно приложение:

1.  Стартираме VS.NET и създаваме нов Windows Forms проект.

2.  Задаваме на главната форма име MainForm и подходящо заглавие, например "System.Drawing Demo". Променяме и името на файла от Form1.cs на MainForm.cs.

3.  Добавяме обработчик на събитието Paint, където изчертаваме гра­фично изображение:

private void MainForm_Paint(object sender,

  System.Windows.Forms.PaintEventArgs e)

{

  Graphics g = e.Graphics;

  g.SmoothingMode = SmoothingMode.AntiAlias;

 

  Brush brush = new SolidBrush(Color.Blue);

  g.FillEllipse(brush, 50, 40, 350, 250);

  brush.Dispose();

 

  Pen pen = new Pen(Color.Red, 2);

  g.DrawRectangle(pen, 40, 50, 200, 40);

  pen.Dispose();

 

  brush = new SolidBrush(Color.Yellow);

  Font font = new Font("Arial", 14, FontStyle.Bold);

  g.DrawString(".NET Framework", font, brush, 60, 60);

  brush.Dispose();

  font.Dispose();

}

В метода вземаме Graphics обекта на формата, създаваме подходящи четки, моливи и шрифтове. С тях изчертаваме запълнена елипса и право­ъгълник и в него изписваме текст. Всички GDI+ ресурси (четки, моливи и шрифтове) задължително се освобождават след използване.

4.  Приложението е готово и можем да го стартираме и тестваме:

Анимация със System.Drawing – пример

Настоящият пример илюстрира как със средствата на GDI+ чрез пакета System.Drawing може да се реализира плавна анимация на някакъв геометричен обект.

Ето и стъпките за изграждане на нашето примерно приложение:

1.  Стартираме VS.NET и създаваме нов Windows Forms проект.

2.  Задаваме на главната форма име MainForm и заглавие "System. Drawing Demo". Променяме и името на файла от Form1.cs на MainForm.cs.

3.  Добавяме променливи и константи за позицията на анимирания обект (елипса), стъпката на преместване и размерите на елипса­та:

private int mPosX = 0;

private int mPosY = 0;

    

private int StepX = 1;

private int StepY = 1;

 

public const int ELLIPSE_SIZE_X = 70;

public const int ELLIPSE_SIZE_Y = 40;

4.  Поставяме в главната форма една Timer компонента с име TimerAnimaiton и един PictureBox с име PictureBoxAnimatoin.

5.  Добавяме обработчик на събитието Paint на PictureBox контрола­та. В него изчертаваме движещия се обект на позицията, в която се намира в момента:

private void PictureBoxAnimation_Paint(object sender,

  System.Windows.Forms.PaintEventArgs e)

{

  Graphics g = e.Graphics;

  g.SmoothingMode = SmoothingMode.AntiAlias;

 

  Brush brush = new SolidBrush(Color.Blue);

  g.FillEllipse(brush, mPosX, mPosY,

     ELLIPSE_SIZE_X, ELLIPSE_SIZE_Y);

  brush.Dispose();

 

  brush = new SolidBrush(Color.Yellow);

  Font font = new Font("Arial", 14, FontStyle.Bold);

  g.DrawString(".NET", font, brush, mPosX+10, mPosY+10);

  brush.Dispose();

  font.Dispose();

}

6.  Задаваме на свойствата Enabled и Interval на Timer компонентата съответно стойности true и 10. Така тя ще генерира събитие на всеки 10 милисекунди.

7.  Добавяме обработчик на събитието Elapsed на Timer компонентата. В него променяме координатите на движещия се обект и пречерта­ва­ме PictureBox контролата:

private void TimerAnimation_Elapsed(object sender,

  System.Timers.ElapsedEventArgs e)

{

  mPosX += StepX;

  if ((mPosX >= PictureBoxAnimation.Width - ELLIPSE_SIZE_X - 3)

       || (mPosX <= 0))

  {

     StepX = -StepX;

  }

 

  mPosY += StepY;

  if ((mPosY >= PictureBoxAnimation.Height - ELLIPSE_SIZE_Y - 3)

       || (mPosY <= 0))

  {

     StepY = -StepY;

  }

 

  PictureBoxAnimation.Refresh();

}

8.  Приложението е готово и можем да го стартираме и тестваме:

В примера сме използвали PictureBox контрола, защото тя не чертае нищо в своя Paint метод, който се извиква преди всяко пречертаване. Ако бяхме използвали Panel или друга контрола, щеше да се получи трепкане.

За професионална анимация се използва DirectX технологията, която използва ресурсите на графичната карта много по-ефективно и натоварва централния процесор много по-малко. Като цяло за по-сложни прило­жения (например игри) използваният в този пример подход е грешен!

Печатане на принтер

Често се налага създадените от нас приложения да отпечатват някаква информация на принтер. Пространството System.Drawind.Printing ни пре­дос­тавя класове, чрез които можем да реализираме такава функцио­нал­ност.

При печатането на принтер се използват три ключови класа:

-     PrintDialog – стандартен диалог за печатане на принтер. Позволява на потребителя да избере принтер и да укаже кои части от доку­мен­та да се отпечатат.

-     PrintController – управлява процеса на печатане и активира съби­тия, свързани с него. PrintController предоставя Graphics по­върх­ност­­та, върху която печатаме.

-     PrintDocument – описва характеристиките на отпечатвания доку­мент. Съдържа PrinterSettings, върнати от PrintDialog.

Обикновено, когато искаме да отпечатаме нещо на принтер, създаваме инстанция на класа PrintDocument, задаваме стойности на свойствата, описващи какво ще печатаме, и извикваме метода Print(), за да отпе­ча­та­ме документа.

Потребителски контроли

Потребителските контроли (custom controls) позволяват разширяване на стандартния набор от контроли чрез комбиниране на съществуващи контроли, разширяване на съществуващи или създаване на съвсем нови такива.

Потребителските контроли или разширяват съществуващи контроли, или класа Control или класа UserControl. Те могат да управляват поведе­нието си по време на изпълнение, както и да взаимодействат с дизайнера на VS.NET по време на дизайн.

Създаване на нова контрола, която не наследява съществуваща

Създаването на нова контрола, която не наследява никоя съществуваща вече контрола, става по следния начин:

1.  От VS.NET избираме File | Add New Item … | UI | Custom Control.

2.  Припокриваме виртуалния метод Paint(…), за да чертаем графич­ния образ на контролата.

3.  Дефинираме необходимите свойства и методи.

4.  Обявяваме свойствата, достъпни от дизайнера на средата за разработка (VS.NET) чрез следните атрибути:

-     Category – указва категорията, в която ще се показва свойството.

-     Description – задава описание на свойството.

Създаване на нова контрола като комбинация от други контроли

Създаването на контрола като комбинация от други контроли става по следния начин:

1.  От VS.NET избираме File | Add New Item … | UI | User Control.

2.  Използваме дизайнера на VS.NET, за да добавим контроли и да оформим желания вид на контролата.

3.  Обявяваме свойствата, достъпни за дизайнера на средата за разра­ботка чрез атрибутите Category и Description.

Създаване на нова контрола, която наследява съществуваща контрола

Създаването на нова контрола, която наследява съществуваща контрола, става по следния начин:

1.  От VS.NET избираме File | Add New Item … | UI | Inherited User Control.

2.  Избираме контролата, от която ще наследяваме.

3.  Дефинираме допълнителни методи и свойства и ги обявяваме за дизайнера на VS.NET чрез атрибутите Category и Description.

4.  Припокриваме OnXXX() методите при необходимост, за да променим поведението на оригиналната контрола.

Създаване на контрола – пример

В настоящия пример ще илюстрираме как със средствата на Windows Forms и GDI+ можем да създаваме потребителски Windows Forms контро­ли. Ще създадем контролата ClockControl, която представлява кръгъл ча­совник със стрелки, на който може да се задава колко часа да показва.

Ето стъпките за създаване на контролата и на приложение, което я използва:

1.  Стартираме VS.NET и създаваме нов Windows Forms проект.

2.  Задаваме на главната форма име MainForm и заглавие "Clock Control Demo". Променяме и името на файла от Form1.cs на MainForm.cs.

3.  Създаваме нашата потребителска контрола. За целта избираме File | Add New Item … | UI | Custom Control. Задаваме ClockControl за име на контролата.

4.  Дефинираме две полета mHour и mMinute и свойства за достъп до тях. Те ще съдържат часа и минутите на нашия часовник:

private int mHour;

private int mMinute;

 

[Category("Behavior"), Description("Specifies the hour.")]

public int Hour

{

  get

  {

     return mHour;

  }

 

  set

  {

     mHour = value;

     this.Invalidate();

  }

}

 

[Category("Behavior"), Description("Specifies the minutes.")]

public int Minute

{

  get

  {

     return mMinute;

  }

 

  set

  {

     mMinute = value;

     this.Invalidate();

  }

}

Приложили сме към свойствата атрибути Category и Description, за да укажем на Visual Studio .NET да ги публикува в Properties прозореца по време на дизайн. При промяна на свойствата се извиква методът Invalidate(), за да се пречертае контролата и да се преместят стрелките на часовника.

5.  Добавяме една константа за размер по подразбиране и добавяме в конструктора код за инициализиране на контролата. Ще инициали­зи­раме контролата с текущия час:

private const int DEFAULT_SIZE = 100;

 

public ClockControl()

{

  // This call is required by the Windows.Forms Form Designer.

  InitializeComponent();

 

  this.Size = new Size(DEFAULT_SIZE, DEFAULT_SIZE);

  mHour = DateTime.Now.Hour;

  mMinute = DateTime.Now.Minute;

}

6.  Припокриваме виртуалния метод OnPaint(…) и в него чертаем часов­ника върху Graphics повърхността на контролата. За прес­мятане на координатите на стрелките използваме изчисления с помощта на тригонометрични функции синус и косинус:

protected override void OnPaint(PaintEventArgs pe)

{

  Graphics g = pe.Graphics;

 

  // Draw the circle

  Pen pen = new Pen(Color.Blue, 1);

  g.DrawEllipse(pen, 0, 0, this.Width-1, this.Height-1);

  pen.Dispose();

 

  // Draw the minute finger

  double minuteFingerAngle =

     (mMinute % 60) * (2*Math.PI/60);

  int minuteFingerLen = this.Width * 45 / 100;

  int x1 = this.Width / 2;

  int y1 = this.Height / 2;

  int x2 = (int) (x1 +

     minuteFingerLen*Math.Sin(minuteFingerAngle));

  int y2 = (int) (y1 –

     minuteFingerLen*Math.Cos(minuteFingerAngle));

  pen = new Pen(Color.Red, 2);

  g.DrawLine(pen, x1, y1, x2, y2);

  pen.Dispose();

 

  // Draw the hour finger

  double hourFingerAngle =

     (mHour % 12) * (2*Math.PI/12) +

     (mMinute % 60) * (2*Math.PI/(60*12));

  int hourFingerLen = this.Width * 25 / 100;

  x1 = this.Width / 2;

  y1 = this.Height / 2;

  x2 = (int) (x1 + hourFingerLen*Math.Sin(hourFingerAngle));

  y2 = (int) (y1 - hourFingerLen*Math.Cos(hourFingerAngle));

  pen = new Pen(Color.Yellow, 3);

  g.DrawLine(pen, x1, y1, x2, y2);

  pen.Dispose();

 

  // Calling the base class OnPaint

  base.OnPaint(pe);

}

7.  Припокриваме метода OnSize(…), в който приравняваме височината и ширината на контролата и я пречертаваме. Така контролата винаги ще бъде с квадратна форма:

protected override void OnResize(System.EventArgs e)

{

  this.Height = this.Width;

  this.Invalidate();

}

8.  Нашата  потребителска контрола е готова. Можем да прекомпилира­ме приложението и да я добавим в Toolbox. За да я добавим в Toolbox, щракваме в него с десен бутон на мишката и от там изби­ра­ме Add/Remove Items… В появилия се прозорец натискаме бутона Browse…  и избираме изпълнимия файл на нашето прило­же­ние. Пос­та­­вяме отметка пред ClockControl в списъка и натискаме бутона OK. Контролата се добавя в Toolbox.

9.  В главната форма на приложението поставяме една ClockControl контрола с име clock и един панел с контроли за промяна на текущия час и минути – две NumericUpDown контроли с имена NumericUpDownHour и NumericUpDwonMinute и един бутон с име ButtonSetTime за отразя­ва­не на промените. Свойствата на ClockControl могат да бъдат про­ме­няни от прозореца Properties (вж. фигурата по-горе).

10.  Добавяме код, който при зареждане на формата (при събитие Load на формата) задава стойностите на NumericUpDown контролите за час и минута, съответстващи на тези от ClockControl обекта:

private void MainForm_Load(object sender, System.EventArgs e)

{

  NumericUpDownHour.Value = clock.Hour;

  NumericUpDownMinute.Value = clock.Minute;

}

11.  Добавяме обработчик на събитието Click на ButtonSetTime. В него променяме стойностите на свойствата на ClockControl обекта:

private void ButtonSetTime_Click(object sender,

  System.EventArgs e)

{

  clock.Hour = (int) NumericUpDownHour.Value;

  clock.Minute = (int) NumericUpDownMinute.Value;

}

12.  Добавяме обработчик на събитието SizeChanged на формата. В него добавяме код, който не позволява на часовника да бъде върху панела:

private void MainForm_SizeChanged(object sender,

  System.EventArgs e)

{

  ClientSize = new Size(

     ClientSize.Width, ClientSize.Width + PanelDown.Height);

}

13.  Приложението е готово и можем да го стартираме и тестваме.

Хостинг на контроли в Internet Explorer

Internet Explorer може да изпълнява Windows Froms контроли, вградени в тялото на HTML страници. Технологията е подобна на Java аплетите и Macromedia Flash – вгражда се изпълним код, който се изпълнява в клиентския уеб браузър. От JavaScript могат да се достъпват свойствата на Windows Forms контролите. Необходими са Internet Explorer 5.5, или по-нова версия, и инсталиран .NET Framework.

Настройките за сигурност не позволяват достъп до файловата система и други опасни действия. Сигурността може да се задава и ръчно. Ако има нужда от запазване на някакви данни на машината на потребителя, може да се използва Isolated Storage.

Хостинг на контроли в Internet Explorer – пример

Настоящият пример илюстрира как можем да реализираме хостинг на Windows Forms контроли в Internet Explorer чрез вграждането им в HTML страница и как можем да достъпваме свойствата им от JavaScript.

Да разгледаме примерна HTML страница, в която е вградена Windows Forms контролата "часовник" от предходния пример:

index.html

<html>

 

<script>

 

function ChangeText() {

  clockControl.Hour = hour.value;

  clockControl.Minute = minute.value;

}

 

</script>

 

<body>

 

  <p>Clock Control in IE</p>

 

  <object id="clockControl"

     classid="http:Demo-18-CustomControl-Clock.exe#Demo_18_CustomControl_Clock.ClockControl"

     width="200" height="200">

     <param name="Hour" value="14">

     <param name="Minute" value="35">

  </object>

 

  <br>

  <br>

 

  Hour:<input type="text" id="hour"><br>

  Minute:<input type="text" id="minute"><br>

  <input type="button" value="Update the clock" onclick="ChangeText()">

 

</body>

 

</html>

Как работи примерът?

Нека разгледаме по-подробно отделните части на HTML страницата. Чрез HTML тага <object> вмъкваме в страницата нашата контрола. Това е часовникът, който създадохме в предишния пример. Атрибутът id, който има стойност clockContol, указва идентификатор, чрез който ще можем да достъпваме обекта в HTML страницата, а атрибу­ти­те width и height указват с каква ширина и височина да се изобрази той. Атрибутът classid определя класа на вмъквания обект. В случая това е нашата ClockControl контрола. Забележете, че указваме асемблито, пространството и името на класа в стойността на този атрибут. В случая сме поставили асемблито Demo-18-CustomControl-Clock.exe в директорията, в която се намира и HTML страницата. Чрез таговете <param> задаваме стойности за свой­ства­та на изобразяваната контрола.

Под контролата сме поставили две текстови полета и един бутон. Тексто­ви­те полета служат за въвеждане на час и минути, които да показва ча­сов­никът. Бутонът служи за промяна на стрелките на часовника. При на­тис­кането му се извиква JavaScript функцията ChangeText(), дефи­ни­ра­на в началото на страницата, която променя свойствата на контролата. Достъпът до текстовите полета и до контролата се извършва посредством техните идентификатори, зададени чрез атрибута id.

Примерът в действие

За да видим резултата от нашата работа, трябва да използваме Internet Explorer 5.5 или по-нов. Не е известен друг уеб браузър, който поддържа Windows Forms контроли.

Ако отворим директно index.html в Internet Explorer, контролата ClockControl няма да се зареди заради политиката за сигурност, която не позволява локално разположени HTML документи да изпълняват Windows Forms контроли. Необходимо е страницата да бъде публикувана на няка­къв уеб сървър, например IIS.

Нека файловете ни се намират в папката Demo-19-Custom-Controls-in-IE. Публикуването на папката в Internet Information Services (IIS) се извършва по следния начин:

1.  От свойствата на папката Demo-19-Custom-Controls-in-IE, дос­тъп­ни от диалоговата кутия на Windows Explorer, избираме таба "Web Sharing". В него избираме "Share this folder".

2.  Публикуваме папката Internet Information Services, като позволим четене на файловете и листинг на директориите.

Сега можем да отворим с Internet Explorer URL адреса на примера от публикуваната в IIS директория:

http://localhost/Demo-19-Custom-Controls-in-IE/index.html

Ще получим следния резултат:

Ако въведем час и минута и натиснем бутона, стрелките ще променят местоположението си.

Нишки и Windows Forms

Продължителните операции в Windows Forms приложенията трябва да се изпълняват в отделна нишка. В противен случай се получава "заспиване" на потребителския интерфейс. Как можем да използваме нишки, ще разгледаме подробно в темата "Многонишково програмиране и синхрони­зация", но засега можем да считаме, че нишките позволяват паралелно изпълне­ние на програмен код в нашите приложения.

Да вземем за пример операцията "изтегля­не на файл от Интернет". Тя може да отнеме от няколко секунди до някол­ко часа и е недопустимо приложението да блокира, докато изтеглянето на файла не приключи. В такъв случай трябва да изпълним задачата в друга нишка (thread) и от време на време да показваме на потребителя индикация за напредъка, например чрез контролата ProgressBar. Има обаче един проблем, свър­зан с достъпа до потребителския интерфейс при работа с нишки.

Обновяването на потребителския интерфейс на дадена контрола трябва да става само от ниш­ка­та, в която работи контролата. От друга нишка безопасно могат да се извикват са­мо методите Invoke(), BeginInvoke(), EndInvoke() и CreateGraphics().

Никога не обновявайте Windows Forms контроли от нишка, която не ги притежава!

За изпълнение на методи от нишката, която притежава дадена контро­ла, изпол­зва­ме метода Invoke(…) на класа Control. Ето пример:

delegate void StringParamDelegate(string aValue);

 

class Form1 : System.Windows.Forms.Form

{

  private void UpdateUI(string aValue)

  {

     // Update UI here …

     // This code is called from the Form1's thread

  }

 

  void AsynchronousOperation()

  {

     // This runs in separate thread. Invoke UI update

     this.Invoke(new StringParamDelegate(UpdateUI),

       new object[]{"някакъв параметър"});

  }

}

По този начин нишката, която извършва времеотнемащата работа, работи паралелно на нишката, която управлява потребителския интерфейс, но той се обновява само от неговата нишка-собственик. Ако обновяваме потребителския интерфейс от нишката, която извършва времеотнемащата операция, а не от главната нишка на приложението, се получават много странни ефекти – от "зависване" на приложението до неочаквани изключения и системни греш­ки. Не го правете!

Използване на нишки в Windows Forms приложения – пример

С настоящия пример ще илюстрираме използването на нишки (threads) в Windows Forms приложения за изпълнение на времеотнемащи задачи. Ще покажем правилния начин, по който една нишка, която се изпълнява паралелно с главната нишка на Windows Forms приложението, може да обновява неговия потребителски интер­фейс.

Приложението, което ще създадем, ще търси прости числа (което е време­отнемаща операция) и ще ги показва на потребителя. Търсенето ще се извършва в отделна, паралелно изпълняваща се нишка, за да не "заспива" потребителският интерфейс.

Ето стъпките за изграждане на нашето приложение:

1.  Стартираме VS.NET и създаваме нов Windows Forms проект.

2.  Задаваме на главната форма име MainForm и заглавие "Asynchronos UI Update Demo". Променяме и името на файла от Form1.cs на MainForm.cs.

3.  Добавяме във формата два бутона с имена ButtonStart и ButtonStop и един TextBox с име TextBoxLastPrimeNumber. На свойствата Text на бутоните задаваме съответно стойности Start и Stop. Задаваме стойност false на свойството Enabled на бутона ButtonStop.

4.  Добавяме променлива за нишката, която търси прости числа:

private Thread mPrimeNumbersFinderThread = null;

5.  Декларираме делегат, който ще използваме при извикването на метода Invoke(…), когато обновяваме потребителския интерфейс:

delegate void LongParameterDelegate(long aValue);

6.  Дефинираме клас PrimeNumberFinder, чрез който ще търсим прости числа в интервала [0; 1 000 000 000]:

class PrimeNumbersFinder

{

  private MainForm mMainForm;

 

  public PrimeNumbersFinder(MainForm aMainForm)

  {

     mMainForm = aMainForm;

  }

 

  public void FindPrimeNumbers()

  {

     for (long number=0; number<1000000000; number++)

     {

       if (IsPrime(number))

       {

          mMainForm.Invoke(

          new LongParameterDelegate(mMainForm.ShowPrimeNumber),

          new object[]{number}

          );

       }

     }

  }

 

  private bool IsPrime(long aNumber)

  {

     // Primarity testing. Very ineffective.

     // Don't do it in a real case!!!

     for (long i=2; i<aNumber; i++)

     {

       // Just waste some CPU time

       int sum = 0;

       for (int w=0; w<100000; w++)

       {

          sum += w;

       }

 

       if (aNumber % i == 0)

       {

          return false;

       }

     }

 

     return true;

  }

}

Понеже търсенето на прости числа ще се извършва в отделна нишка, в класа сме дефинирали променлива mMainForm, чрез която ще се обръщаме към главната форма, за да обновяваме потребителския интерфейс. Тази променлива се инициализира в конструктора на класа.

Методът IsPrime(…) проверява дали подаденото като параметър число е просто. Тази проверка нарочно се прави по изключително времеотнемащ, неефек­ти­вен и натоварващ процесора начин, за да се симулира забавяне.

Методът FindPrimeNumbers() проверява последователно дали е просто вся­ко от числата  в интервала от 0 до 1000000000. Ако числото е просто, през главната нишка на приложението се извиква методът ShowPrimeNumber(…), като му се подава като параметър намереното прос­то число. Този метод показва числото в потребителския интерфейс. Извикването се извършва чрез метода Invoke(…) на формата, който има гри­жата да изпълни подадения му делегат през нишката, в която работи фор­мата.

Нишката, която търси прости числа, няма право да променя директно потребителския интерфейс на приложението, защото той работи в друга нишка. Ако две нишки работят с потребителския интерфейс едновремен­но, могат да възникнат непредвидими проблеми – блокиране на приложе­ние­то, странни изключения или странни визуални ефекти.

7.  Дефинираме в главната форма метода ShowPrimeNumber(…), който показва подаденото му като параметър число в текстовото поле TextBoxLastPrimeNumber:

internal void ShowPrimeNumber(long aNumber)

{

  TextBoxLastPrimeNumber.Text = aNumber.ToString();

}

8.  Добавяме обработчик на събитието Click на бутона ButtonStart. В него деактивираме Start бутона, активираме бутона Stop и стар­ти­ра­ме отделна нишка, в която започваме да търсим прости числа:

private void ButtonStart_Click(object sender,System.EventArgs e)

{

  ButtonStart.Enabled = false;

  ButtonStop.Enabled = true;

  PrimeNumbersFinder finder = new PrimeNumbersFinder(this);

  mPrimeNumbersFinderThread =

     new Thread(new ThreadStart(finder.FindPrimeNumbers));

  mPrimeNumbersFinderThread.Start();

}

9.  Добавяме обработчик на събитието Click на бутона ButtonStop. В него активираме Start бутона, деактивираме бутона Stop и пре­кра­­тяваме изпълнението на стартираната нишка:

private void ButtonStop_Click(object sender, System.EventArgs e)

{

  ButtonStart.Enabled = true;

  ButtonStop.Enabled = false;

  mPrimeNumbersFinderThread.Abort();

}

10.  Добавяме обработчик на събитието Closing на главната форма. В него прекратяваме изпълнението на нишката, търсеща прости чис­ла (в случай че е била стартирана):

private void MainForm_Closing(object sender,

  System.ComponentModel.CancelEventArgs e)

{

  if (mPrimeNumbersFinderThread != null)

  {

     mPrimeNumbersFinderThread.Abort();

  }

}

11.  Приложението е готово и можем да го стартираме и тестваме.

Въпреки че се извършва тежко изчисление и процесорът е натоварен на 100%, потребителският интерфейс не "замръзва". Ако все пак в даден момент се получи замръзване за кратко време, най-вероятно причината за това e включването на системата за почистване на паметта (Garbage Collector).

Влачене (Drag and Drop)

Реализацията на "влачене и пускане" (drag and drop) в Windows Forms прило­же­ние се извършва чрез обработването на поредица от събития.

В събитието MouseDown на контролата, от която започва влаченето, трябва да извикаме метода DoDragDrop(…), за да копираме данните, които ще вла­чим.

За да дадем възможност на контрола да получава данни при влачене, трябва да зададем стойност true на свойството й AllowDrop и трябва да прихванем събитията DragEnter и DragDrop. При обработка на DragEnter трябва да проверяваме формата на идващите данни и да позволяваме или забраняваме получаването им. Тази проверка можем да извършим чрез метода DragEventArgs.Data.GetDataPresent(…). В събитието DragDrop трябва да обработ­ваме получените данни. Можем да ги извличаме посредством метода DragEventArgs.Data.GetData(…).

Влачене и пускане в Windows Forms – пример

Настоящия пример илюстрира как със средствата на Windows Forms могат да бъдат реализирани приложения, които използват Drag-and-Drop техно­логията (влачене и пускане на обекти от една контрола към друга).

Приложението, което ще създадем, ще съдържа две контроли – едната ще се използва като източник при влаченето, а другата като получател.

Ето и стъпките за изграждане на нашето приложение:

1.  Стартираме VS.NET и създаваме нов Windows Forms проект.

2.  Задаваме на главната форма име MainForm и заглавие "Drag and Drop Demo". Променяме и името на файла с нейния сорс код от Form1.cs на MainForm.cs.

3.  Добавяме във формата две ListBox контроли с имена ListBoxSource и ListBoxTarget. Те ще бъдат съответно източник и получател при влаченето.

4.  Задаваме за свойството Items на ListBoxSource списък от имена на градове – София, Пловдив, Варна,

5.  Добавяме обработчик на събитието MouseDown на ListBoxSource. В него намираме избрания елемент от списъка и извикваме метода DoDragDrop(…), с което активираме влаченето. На метода подаваме като първи параметър данните, а като втори – стойност от изброе­ния тип DragDropEffects, указваща какъв да е резултатът от влаче­нето – в нашия случай е копиране:

private void ListBoxSource_MouseDown(object sender,

  System.Windows.Forms.MouseEventArgs e)

{

  Point mouseLocation = new Point(e.X, e.Y);

  int selectedIndex =

       ListBoxSource.IndexFromPoint(mouseLocation);

  if (selectedIndex != -1)

  {

     string data = (string) ListBoxSource.Items[selectedIndex];

     ListBoxSource.DoDragDrop(data, DragDropEffects.Copy);

  }

}

6.  Задаваме на свойството AllowDrop на ListBoxTarget стойност true.

7.  Добавяме обработчик на събитието DragEnter на ListBoxTarget. В него проверяваме дали влаченият обект е Unicode символен низ и съответно позво­ля­ва­ме или забраняваме пускането му:

private void ListBoxTarget_DragEnter(object sender,

  System.Windows.Forms.DragEventArgs e)

{

  if (e.Data.GetDataPresent(DataFormats.UnicodeText))

  {

     e.Effect = DragDropEffects.Copy;

  }

}

8.  Добавяме обработчик на събитието DragDrop на ListBoxTarget. В него извличаме низа и го обработваме:

private void ListBoxTarget_DragDrop(object sender,

  System.Windows.Forms.DragEventArgs e)

{

  string data =

     (string) e.Data.GetData(DataFormats.UnicodeText);

  ListBoxTarget.Items.Add(data);

}

9.  Приложението е готово и можем да го стартираме и тестваме, като завлечем  няколко града от списъка-източник в списъка-получател.

Конфигурационен файл на приложението

.NET Framework приложенията могат да използват конфигурационен файл, за да четат настройките си. Той представлява обикновен XML файл:

App.config

<?xml version="1.0" encoding="utf-8" ?>

<configuration>

  <appSettings>

    <add key="username" value="Бай Иван" />

    <add key="language" value="US-EN" />

  </appSettings>

</configuration>

В тага <appSettings> могат да се добавят конфигурационни параметри на приложението, които представляват двойки от ключ и стойност. Настрой­ки­те от конфигурационния файл могат да бъдат извличани по време на изпълнение по следния начин:

string username = System.Configuration.

  ConfigurationSettings.AppSettings["username"];

// username = "Бай Иван"

От VS.NET можем да добавим конфигурационен файл като изберем File | Add New Item… | Application configuration file | App.config. При компилация App.config се копира под име <име_на_проекта.exe.config>.

Извличане на настройки от конфигурационен файл – пример

Настоящият пример илюстрира как можем да извличаме настройки от конфигурационния файл на приложението. Ще създадем приложение, което извлича стойност от своя конфигу­ра­цио­нен файл и я показва.

Ето и стъпките на изграждане на нашето приложение:

1.  Стартираме VS.NET и създаваме нов Windows Forms проект.

2.  Задаваме на главната форма име MainForm и заглавие "Config File Demo". Променяме и името на файла от Form1.cs на MainForm.cs.

3.  Добавяме във формата един TextBox с име TextBoxUserName и един бутон с име ButtonReadUserName. Задаваме на свойството Text на бутона стойност "Read user name from config file".

4.  Добавяме конфигурационен файл на приложението, като избираме File | Add New Item… | Application configuration file | App.config. В него добавяме нов конфигурационен параметър с ключ username и стойност "Бай Иван":

App.config

<?xml version="1.0" encoding="utf-8" ?>

<configuration>

  <appSettings>

     <add key="username" value="Бай Иван" />

  </appSettings>

</configuration>

5.  Добавяме обработчик на събитието Click на ButtonReadUserName. В него извличаме стойността на параметъра username и я показ­ва­ме в текстовото поле:

private void ButtonReadUserName_Click(object sender,

  System.EventArgs e)

{

  TextBoxUserName.Text = System.Configuration.

     ConfigurationSettings.AppSettings["username"];

}

6.  Приложението е готово и можем да го стартираме и тестваме:

Упражнения

1.    Какво представлява библиотеката Windows Forms? Каква функцио­нал­ност предоставя? Кога се използва?

2.    Какво е компонент? Какво представлява компонентният модел .NET Framework? Какво е характерно за него?

3.    Опишете програмния модел на Windows Forms. Каква функционалност реализира той?

4.    Кои са най-важните класове от Windows Forms? Кои са най-важните им методи и свойства?

5.    Какво е характерно за всички Windows Forms контроли? Кои са общите им методи и свойства?

6.    Какво е характерно за формите в Windows Forms? Какви свойства и събития имат те?

7.    Как се поставят контроли в дадена форма? Как се прихващат събития, породени от дадена контрола?

8.    Реализирайте Windows Forms приложение, което представлява опростен вариант на стандартния калкулатор в Windows. Калкулаторът трябва да поддържа основните аритметични операции с цели и реални числа.

9.    Със средствата на Windows Forms реализирайте играта "Хвани бягащия бутон". Играта представлява една форма, в която има един бутон със заглавие "Натисни ме". При приближаване на курсора на мишката в близост до бутона той трябва да "бяга от него" (да се премества на друго място във формата, възможно по-далече от курсора на миш­ката).

10. Със средствата на Windows Forms реализирайте проста информа­ци­он­на система за управление на клиентите на дадена фирма. Системата трябва да визуализира списък от клиенти (ListBox) и да позволява доба­вяне, редактиране и изтриване на клиенти. Всеки клиент е или юридическо или физическо лице. Юридическите лица се описват с наименование, вид (ЕТ, АД, ООД, сдружение, ...), Булстат, данъчен номер, адрес, телефон, email, уеб сайт и МОЛ (който е физическо лице). Физическите лица се описват с име, презиме, фамилия, пол, ЕГН, данни за лична карта, адрес, телефон и email. Приложението трябва да се състои от 3 форми – главна форма, съдържаща клиентите, форма за въвеждане/редакция на юридическо лице и форма за въвеждане/редакция на физическо лице. Използвайте подходящи Windows Forms контроли във формите. Данните трябва да се четат и записват в XML файл.

11. Със средствата на Windows Forms реализирайте специализиран редак­тор за библиотеки с текстови документи. Една библиотека пред­став­лява съвкупност от текстови документи, организирани дървовидно в папки. В една папка може да има документи и други папки (подобно на файловата система на Windows). Всеки документ представлява някакъв текст с форматиране. Редакторът трябва да може да създава библиотеки, да чете/записва библиотеки от/в XML файл. Когато е отво­рена дадена библиотека, редакторът трябва да позволява редак­ти­ране на документите в нея (промяна на текста и форматирането на отделни фрагменти от него), както и създаване/изтри­ване/пре­име­ну­ва­не на папки и документи. За дървото с папките трябва да се използва контролата TreeView, а за активния документ - RichEdit. Редакторът трябва да разполага с падащо меню, 2 контекстни менюта (за дървото с папките и за полето за редактиране на документ), 3 ленти с инструменти (за отваряне/записване на библиотека, за работа с дървото с папките и за форматиране на активния в момента документ), статус лента и подходящи кратки клавиши за по-важните команди. Реализирайте и търсене и заменяне на текст в документите.

12. Напишете Windows Forms приложение, в което се въвежда информа­ция за физическо лице (име, презиме, фамилия, ЕГН, адрес, телефон, email, личен сайт) и въведеното се записва в XML файл. Реализирайте валидация на всяко едно от полетата и на цялата форма, като изпол­зва­те подходящи регулярни изрази.

13. Със средствата на Windows Forms и простото свързване на данни (simple data binding) реализирайте приложение за управление на проста система с информация за градове и държави. Всяка държава се описва с име, език, население, национален флаг и списък от градове. Всеки град се описва с име, население и държава. Трябва да се реализира навигация по градовете и държавите и редакция на инфор­ма­цията за тях, като не се използват списъчни контроли, а само текстови полета и просто свързване. Да се реализира четене и запис­ва­не на данните в XML файл.

14. Със средствата на Windows Forms и сложното свързване на данни (complex data binding) реализирайте система, подобна на системата за управление на информация за градове и държави. Добавете към системата списък от континенти за всяка държава. За визуализацията и навигацията използвайте таблици (DataGrid) и списъчни контроли. Реализирайте предходното приложение, като съхранявате данните не в XML файл, а в релационна база от данни (напр. MS SQL Server). Използвайте разкачения модел за достъп до данните (disconnected model), като реализирате възможност за разрешаване на конфликтите, които възникват при работа с много потребители едновременно.

15. Създайте Windows Forms приложение, с което могат да се въвеждат данни за физически и юридически лица. Физическите лица се описват с име, ЕГН, адрес, телефон, email и уеб сайт. Юридическите лица се описват с наименование, вид (ЕТ, АД, ООД, сдружение, ...), Булстат, данъчен номер, адрес, телефон, email, уеб сайт и МОЛ (име и ЕГН на физическо лице). Използвайте наследяване на форми, като отделите в базова форма общите елементи на потребителския интерфейс и общите полета от формите за въвеждане на физически и юридически лица.

16. Реализирайте Windows Forms приложение, което по ежедневните данни от дадено техническо измерване за даден период (текстов файл с цели положителни числа) визуализира графично резултатите като редица от правоъгълни стълбове. При обемни данни осигурете възмож­ност за скролиране на графиката.

17. Със средствата на Windows Forms реализирайте играта "морски шах" (в квадратна дъска с размери 3 на 3 се поставят пулове "X" и "0"). Играчът трябва да може да играе срещу компютъра в 2 режима: "компютърът играе оптимално" и "компютърът играе хаотично (слу­чай­но)". Осигурете подходяща визуализация и интерактивност на играта.

18. Реализирайте Windows Forms MDI приложение, което може да отваря файлове с графични изображения (gif, jpg, png) и може да ги преораз­ме­рява и да ги записва в друг файл.

19. Реализирайте Windows Forms приложение, което показва даден текстов файл, като визуализира всеки негов ред със специален ефект: всяка буква първоначално се появява на случайно място във формата и започва да се придвижва анимирано към мястото си. За 2 секунди всяка буква трябва да си е на мястото. След изчакване от 1 секунда се преминава към следващия ред от входния файл.

20. Със средствата на Windows Forms реализирайте прост текстов редак­тор, който може да отваря файлове с влачене от Windows Explorer.

21. Наследете контролата TextBox и създайте потребителска контрола NumberTextBox, която позволява въвеждане само на числа.

22. Направете Windows Forms потребителска контрола HourMinuteBox, която се състои от 2 NumericUpDown полета и позволява въвеждане на час и минута в интервала [0:00 - 23:59].

23. Реализирайте Windows Forms потребителска контрола "зарче", която представлява квадрат, в който могат да се изобразяват графично стойности от 1 до 6 (както са при стандартните зарчета при някои игри). Контролата трябва да реализира собствено изчертаване и свойство "Value" за задаване на текущата стойност.

24. С помощта на контролата "зарче" реализирайте играта "състезание": Двама играчи играят последователно. При всеки ход играчът, който е на ход, хвърля 2 зарчета (генерират се случайни стойности) и мести толкова стъпки, колкото е сумата от хвърлените зарове. Печели първият, който премине сумата 50. Реализирайте подходяща визу­а­ли­за­ция на позицията на двамата играчи на хвърлените зарове.

25. Реализирайте играта "състезание" като Windows Forms контрола и я хостнете в Internet Explorer, използвайки подходяща уеб страничка. Хвър­лянето на заровете извиквайте с JavaScript при натискане на бутон от уеб страницата.

26. Със средствата на Windows Forms реализирайте приложение, което търси текст във всички файлове в дадена директория. Понеже търсе­не­то е бавна операция, реализирайте я в отделна нишка. При нами­ра­не на текста добавяйте файла и отместването, на което е намерен, в ListBox контрола чрез главната нишка на приложението, като изпол­зва­те Invoke() метода на формата. Реализирайте възможност за пре­кра­тяване на търсенето. Реализирайте подходяща визуализация при щракване върху някое от намерените съвпадения в резултата.

27. Реализирайте Windows Forms приложение, което съдържа една тексто­ва контрола, стойността на която се зарежда от конфигурационния XML файл на приложението. При изход от приложението стойността на тази контрола трябва да се запазва обратно в конфигурационния файл. За четене от конфигурационния файл използвайте System. Configuration.ConfigurationSettings.AppSettings, а за пи­са­не в него използвайте DOM парсера на .NET Framework.

Използвана литература

1.  Светлин Наков, Графичен потребителски интерфейс с Windows Forms – http://www.nakov.com/dotnet/lectures/Lecture-14-Windows-Forms-v1.0.ppt

2.  MSDN Library - http://msdn.microsoft.com

3.  Microsoft Windows Forms QuickStarts Tutorial –
http://www.csharpfriends.com/quickstart/winforms/doc/default.aspx

4.  Marj Rempel, Kenneth S. Lind, Marjorie Rempel, MCAD/MCSD Visual C# .NET Certification All-in-One Exam Guide, McGraw-Hill, 2002, ISBN 0072224436

5.  MSDN Library, Event Handling in Windows Forms – http://msdn.
microsoft.com/library/en-us/vbcon/html/vbconeventhandling.asp

6.  Threading in Windows Forms –
http://www.yoda.arachsys.com/csharp/threads/winforms.shtml

7.  J. Fosler, Windows Forms Painting: Best Practices –
http://www.martnet.com/~jfosler/articles/WindowsFormsPainting.htm

 


Глава 16. Изграждане на уеб приложения с ASP.NET

Автори

Михаил Стойнов

Рослан Борисов

Стефан Добрев

Деян Варчев

Иван Митев

Христо Дешев

Необходими знания

-     Базови познания за езика C#

-     Базови познания за архитектурата на .NET Framework

-     Базови познания по Интернет технологии

-     HTTP (Hyper Text Transfer Protocol)

-     HTML (Hyper Text Markup Language)

-     Познания за архитектурата на уеб базираните приложения

Съдържание

-     Въведение

-     Уеб форми

-     Контроли

-     Изпълним код на уеб форми и контроли (code-behind)

-     Събития

-     Проследяване и дебъгване

-     Валидация на данни

-     Работа с бази от данни

-     Управление на състоянието

-     Оптимизация, конфигурация и разгръщане

-     Сигурност

В тази тема ...

В настоящата тема ще разгледаме разработката на уеб приложения с ASP.NET. В началото ще запознаем читателя с уеб формите и техните основни директиви, атрибути и тагове. Ще разгледаме видовете уеб контроли, които се използват при изграждане на уеб приложения, и по-важните от тях. Ще разгледаме концепцията за отделяне на кода от потребителския интер­фейс (code-behind), ще обясним програмния модел на ASP.NET и работата със събития. След това ще демонстрираме как да работим с данни, извлечени от релационна база от данни. Ще обърнем специално внимание на принципите на свързване на контроли с данни (data binding) и ще обясним как да свързваме списъчни и итериращи контроли. Ще разгледаме как можем да управля­ваме вътрешното състоя­ние на уеб приложението: работа със сесии и cookies, достъп до контекста на приложението и технологията ViewState. Ще покажем как да валидира­ме данни, въведени от потреби­теля, чрез различните валидатори. Ще обясним концепцията за потребителските контроли като метод за преиз­ползване на части от приложението. Ще се научим как да проследя­ваме и дебъгваме уеб приложения. Ще покажем как се оптимизират, конфигу­рират и разгръщат ASP.NET уеб приложения (кеширане, настрой­ки и deployment). Ще обърнем специално внимание и на сигурността при уеб приложенията.


Въведение

ASP.NET е библиотека за разработка на уеб приложения и уеб услуги, стандартна част от .NET Framework. Тя дава програмен модел и съвкуп­ност от технологии, чрез които можем да изграждаме сложни уеб прило­жения.

Изпълнение на ASP.NET уеб приложение

Уеб приложенията използват модела заявка-отговор (request-response), както е показано на фигурата:

1.  Потребителят въвежда в браузъра адрес на страница (URL). Браузърът изпраща HTTP заявка (request) към уеб сървъра.

2.  Сървърът получава заявката и я обработва. В случая с ASP.NET, IIS намира процес, който може да обработи дадената заявка.

3.  Резултатът от вече обработената заявка се изпраща обратно към потребителя/клиента под формата на HTTP отговор (response).

4.  Браузърът показва получения отговор като уеб страница.

Преглед на технологията ASP.NET

ASP.NET е програмна платформа за разработка на уеб приложения, предо­ставена от .NET Framework. Тя предлага съвкупност от класове, които работят съвместно, за да обслужват HTTP заявки. Също като класическите ASP (Active Server Pages), ASP.NET се изпълнява на уеб сървър и предо­ставя възможност за разработка на интерактивни, динамични, персонали­зирани уеб сайтове, както и на уеб базирани приложения. АSP.NET е също и платформа за разработка и използване на уеб услуги.

ASP.NET и .NET Framewrok

На фигурата са показани основните компоненти на .NET Framework, част от които е библиотеката ASP.NET.

Разлики между ASP и ASP.NET

Разликите между ASP и АSP.NET са значителни. АSP.NET предлага ново ниво на абстракция за разработка на уеб приложения. Ключова характе­ристика на ASP.NET е възможността за разделяне на кода описващ дизайна от кода, реализиращ логиката на приложенията. ASP.NET прило­женията могат да бъдат разработвани с помощта на всички езици за програмиране, които се компилират до MSIL код (C#, VB.NET, J#, Managed C++ и много други).

Фундаменти на ASP.NET

Основният компонент на ASP.NET е уеб формата – абстракция на HTML страницата, която интернет потребителите виждат в браузъра си. Зами­сълът на създателите на ASP.NET е работата с уеб формите да бъде интуи­тивна и максимално улеснена, както е при Windows Forms формите. ASP.NET предлага едно високо ниво на абстракция, предоставяйки ни богат избор от уеб контроли, подобни на тези в Windows Forms, и нама­лява нуждата програмиста да работи с чист HTML код.

Всяко ASP.NET приложение се изгражда от една или повече уеб форми, които могат да взаимодействат помежду си, създавайки интерактивна система.

Как работи ASP.NET?

Традиционните уеб страници могат да изпълняват код на клиента, с който извършват сравнително прости операции.

ASP.NET уеб формите могат да изпълняват и код от страна на сървъра (server-side code). С него те генерират HTML код, който да се върне като отговор на заявката. За целта могат да се извършват обработки, изискващи достъп до бази от данни и до ресурсите на самия сървър, генериращи допълнителни уеб форми и други.

Всяка уеб форма в крайна сметка се трансформира в HTML код, пригоден за типа на клиентския браузър. Това позволява улеснена разработка на уеб форми. Те работят практически върху всяко устройство, което разпо­лага с интернет свързаност и уеб браузър.

Разделяне на визуализация от бизнес логика

Един от основните проблеми на класическите ASP беше смесването на HTML с бизнес логика. Това правеше страницата труд­на за разбиране, поддръжка и дебъгване. Файловете ставаха големи и сложни и се забавяше процеса на разработка на приложението. Една от основните архитектурни цели на АSP.NET e справянето с този проблем. Тъй като реализацията на потребителския интерфейс и на бизнес логика­ са до голяма степен, две независими задачи, ASP.NET предоставя мо­дел за разработка, при който те са физически разделени в отделни файлове.

Програмирането за клиентския интерфейс (UI) се разделя на две части:

-     За визуализация се използва HTML-подобен код, записан във файл с разширение .aspx.

-     Бизнес логиката се дефинира в отделен файл (с разширение .cs за C# или .vb за Visual Basic .NET), съдържащ конкретната имплемен­тация на определен програмен език.

Файлът, съдържащ бизнес логиката, се нарича "Изпълним код на уеб формата" (Code-behind).

Зад всяка уеб форма стои богатият обектен модел на .NET Framework и тя се компилира до клас в асемблито на проекта ни.

Класът, генериран от .aspx файл, се непряк наследник на Page класа. Съществува междинен клас в йерархията, който е за изпълнимия код (code-behind class). В него можем лесно да добавяме методи, обработка на събития и др.

Чрез "изпълнимия код" представянето е разделено от логиката. Това улеснява значително поддръжката на .aspx страниците.

Компоненти на ASP.NET

Ето кои са основните компоненти, от които се изграждат уеб приложенията, базирани на ASP.NET:

* Web Forms – описват интерфейса за ASP.NET приложение.

 Code-behind класове – асоциират се с уеб форми и контроли и съ­дър­жат server-side код.

 Web.config – файл, съдържащ конфигурацията на ASP.NET прило­же­нието.

 Machine.config – файл с глобални настройки за уеб сървъра.

 Global.asax – файл, съдържащ код за прихващане на събития на ниво приложение (application level events).

Съществуват и други компоненти като Http Modules, Http Handlers и други, но на тях няма да се спираме.

Пример за уеб приложение

Ще създадем примерно уеб приложение чрез Visual Studio.NET, за да разгледаме структурата на директориите и файловете му. Отваряме Visual Studio.NET и създаваме нов уеб проект с име Demo-1-ExampleOfWebApplication:

Отляво е кутията с инструменти (toolbox), където са контролите. Нека добавим текстово поле и бутон, като привлачим двете контроли върху формата.

Можем да разгледаме кода на страницата (code-behind класа) като върху формата натиснем [F7].

Можем да компилираме и стартираме приложението с [Ctrl+F5].

ASP.NET Web Application проекти във VS.NET

При създаване на проект за .NET уеб приложение (ASP.NET Web Application) във Visual Studio .NET, се създават две директории.

В едната (по подразбиране това е \My Documents\Visual Studio Projects) се намира solution файла (.sln). Той описва проектите, участ­ващи в приложението. Обикновено в поддиректории се съхраняват оста­налите проекти от solution файла.

Втората директория е с идентично име и се създава в уеб-достъпна папка, като най-често това е папката c:\inetpub\wwwroot. Тя съдържа файлове­те, които са нужни на уеб приложението: .aspx страниците, техните code-behind файлове и файловете Web.config и Global.asax. Когато се компи­лира проекта, се създава съответно асембли в директорията bin.

Забележка: Директорията c:\inetpub\wwwroot е коренната (root) вирту­ална директория по подразбиране на уеб сървъра Internet Information Server (IIS), с който по подразбиране работи Visual Studio.NET за разгръ­щане на приложенията си.

Виртуална директория е такава, която се вижда през протокола HTTP, например:

Ако отваряме сървъра локално, можем да го извикаме с адреса http://localhost/.

Като направим директорията c:\inetpub\wwwroot\Lecture-15-ASP.NET-and-Web-Applications\Demo-1-ExampleOfWebApplication, тя ще се вижда през протокола HTTP като виртуалната директория:

http://localhost/Lecture-15-ASP.NET-and-Web-Applications/Demo-1-ExampleOfWebApplication/.

Модел на изпълнение на ASP.NET

Моделът на изпълнение (execution model) на ASP.NET е следният:

1.  Клиентският браузър изпраща HTTP GET заявка на сървъра.

2.  Сървърът намира за коя страница е заявката и започва да я изпъл­нява.

3.  ASP.NET парсерът интерпретира нейния сорс код.

4.  Ако кодът не е бил компилиран в асембли, ASP.NET извиква компи­латора.

5.  Средата за изпълнение (CLR) зарежда в паметта и изпълнява Microsoft Intermediate Language (MSIL) кода.

6.  Страницата се изпълнява и генерира HTML код. Сървърът връща този резултат на клиента като HTTP отговор.

Уеб форми

ASP.NET уеб приложенията представляват най-общо съвкупност от уеб форми. Нека разгледаме как можем да създаваме и използваме уеб форми.

Какво е уеб форма (Web Form)?

Уеб формата е програмируема уеб страница. Тя служи като потребителски интерфейс в ASP.NET уеб приложенията. Уеб формите съдържат HTML код и контроли. Те се изпълняват на уеб сървъра. Най-често това е Microsoft Internet Information Server (IIS). Уеб формите връщат като резултат пот­ребителски интерфейс, под формата на HTML код, който се изпраща на клиентския браузър.

Създаване на уеб форма

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

Атрибутите на @Page директивата дефинират глобална функционалност. Атрибутите на body тага дефинират как ще се покаже една страница. Ат­рибутите на form тага дефинират как ще се обработят групите контроли.

Top of Form

Bottom of Form

дфдсфдсфTop of Form

Bottom of Form

сдфдфсфдссдфTop of Form

Bottom of Form

<%@ Page Language="c#"

  Codebehind="WebForm1.aspx.cs"

  Inherits="WebApplication1.WebForm1"%>

<html>

  <head><title>WebForm1</title></head>

  <body MS_POSITIONING="GridLayout">

     <form id="Form1" method="post">

       <asp:Button ...></aspButton>

     </form>

  </body>

</html>

Забележка: @Page директивата е специална конструкция, използвана в ASP.NET уеб формите. Въпреки че и в HTML има <body> и <form> тагове, същите (когато са записани така <body runat="server" ...> и <form runat="server" ...>) играят по-специална роля в ASP.NET. Тези особености са обяснени в детайли по-нататък.

Поддържат се два вида разполагане на HTML елементите на страницата.

-       FlowLayout: HTML обектите се нагласят по ширината на прозореца на браузъра.

-       GridLayout: HTML обектите са с абсолютни координати на HTML страницата. Това е стойността по подразбиране.

Директиви

Директивите предоставят възможност за контролиране на компилацията и изпълнението на уеб формата. Името на всяка директива започва с "@" и е заградено с <% и %> тагове. Директивите могат да бъдат поставени навсякъде в .aspx файла на формата, но обикновено се поставят в началото му. Настройките и опциите към всяка директива се задават като атрибути.

Важни директиви:

-     @Page – главна директива за формата (по-късно разгледана);

-     @Import – въвежда дадено пространство от имена във формата;

-     @Implements – указва, че формата (или контролата) имплементира даден интерфейс;

-     @Control – аналог на @Page директивата (използва се само за потребителски контроли);

-     @OutputCache – контролира способността за кеширане на формите;

-     @Register – регистрира контрола за употреба в уеб форма;

-     @Reference – декларативно указва, че сорс файлът на друга потре­бителска контрола или форма трябва да бъде динамично компили­ран и свързан с формата, в която е декларирана директивата.

Ето един пример за използване на @Page директивата:

<%@ Page Language="c#" Codebehind="WebForm1.aspx.cs" Inherits="WebApplication1.WebForm1"%>

Директивата <@Page …>

Дефинира специфични за формата (.aspx файл) атрибути, използвани от парсера и компилатора на ASP.NET.

Важни атрибути:

-     AutoEventWireup – решава автоматичното абониране за събитията на страницата и контролите.

-     Culture – определя културата (регионалните настройки), която да се използва при обработка на данните.

-     UICulture – определя културата за видимите от потребителя текстови съобщения.

-