Состоит из дохера классов, но базовых меньше: Bitmap – реализация gdi+ bitmap, что есть массив графических данных попиксельно со всеми их атрибутами.

Оглавление
13 TOC \o "1-3" \h \z \u 1413 LINK \l "_Toc345926969" 141. Основные понятия языка 13 PAGEREF _Toc345926969 \h 1431515
13 LINK \l "_Toc345926970" 141.1. Алфавит и лексемы 13 PAGEREF _Toc345926970 \h 1431515
13 LINK \l "_Toc345926971" 141.2. Типы данных 13 PAGEREF _Toc345926971 \h 1431515
13 LINK \l "_Toc345926972" 142. Операторы языка C# 13 PAGEREF _Toc345926972 \h 1441515
13 LINK \l "_Toc345926973" 142.1. Операторы ветвления 13 PAGEREF _Toc345926973 \h 1441515
13 LINK \l "_Toc345926974" 142.2. Операторы цикла 13 PAGEREF _Toc345926974 \h 1441515
13 LINK \l "_Toc345926975" 142.3. Операторы передачи управления 13 PAGEREF _Toc345926975 \h 1441515
13 LINK \l "_Toc345926976" 143. Классы 13 PAGEREF _Toc345926976 \h 1441515
13 LINK \l "_Toc345926977" 143.1. Поля и константы 13 PAGEREF _Toc345926977 \h 1441515
13 LINK \l "_Toc345926978" 143.2. Методы 13 PAGEREF _Toc345926978 \h 1441515
13 LINK \l "_Toc345926979" 143.3. Конструкторы 13 PAGEREF _Toc345926979 \h 1441515
13 LINK \l "_Toc345926980" 143.4. Свойства 13 PAGEREF _Toc345926980 \h 1441515
13 LINK \l "_Toc345926981" 144. Массивы 13 PAGEREF _Toc345926981 \h 1451515
13 LINK \l "_Toc345926982" 144.1. Одномерные массивы 13 PAGEREF _Toc345926982 \h 1451515
13 LINK \l "_Toc345926983" 144.2. Многомерные массивы 13 PAGEREF _Toc345926983 \h 1451515
13 LINK \l "_Toc345926984" 144.3. Неявно-типизированные массивы 13 PAGEREF _Toc345926984 \h 1451515
13 LINK \l "_Toc345926985" 144.4. Оператора цикла foreach 13 PAGEREF _Toc345926985 \h 1451515
13 LINK \l "_Toc345926986" 144.5. Класс System.Array 13 PAGEREF _Toc345926986 \h 1451515
13 LINK \l "_Toc345926987" 145. Символы и строки постоянной длины в C# 13 PAGEREF _Toc345926987 \h 1461515
13 LINK \l "_Toc345926988" 145.1. Класс char 13 PAGEREF _Toc345926988 \h 1461515
13 LINK \l "_Toc345926989" 145.2. Класс char[] – массив символов 13 PAGEREF _Toc345926989 \h 1461515
13 LINK \l "_Toc345926990" 145.3. Класс String 13 PAGEREF _Toc345926990 \h 1461515
13 LINK \l "_Toc345926991" 145.3.1. Объявление строк. Конструкторы класса String 13 PAGEREF _Toc345926991 \h 1461515
13 LINK \l "_Toc345926992" 145.3.2. Операции над строками 13 PAGEREF _Toc345926992 \h 1461515
13 LINK \l "_Toc345926993" 145.3.3. Статические свойства и методы класса String 13 PAGEREF _Toc345926993 \h 1461515
13 LINK \l "_Toc345926994" 145.3.4. Методы Join и Slpit 13 PAGEREF _Toc345926994 \h 1471515
13 LINK \l "_Toc345926995" 145.3.5. Динамические методы класса String 13 PAGEREF _Toc345926995 \h 1471515
13 LINK \l "_Toc345926996" 146. Введение в Windows.Forms 13 PAGEREF _Toc345926996 \h 1471515
13 LINK \l "_Toc345926997" 146.1. Класс Windows.System.Forms.Application 13 PAGEREF _Toc345926997 \h 1471515
13 LINK \l "_Toc345926998" 146.2. Класс Form 13 PAGEREF _Toc345926998 \h 1471515
13 LINK \l "_Toc345926999" 147. Меню 13 PAGEREF _Toc345926999 \h 1481515
13 LINK \l "_Toc345927000" 148. Создание строки состояния и панели инструментов 13 PAGEREF _Toc345927000 \h 1491515
13 LINK \l "_Toc345927001" 149. Графика 13 PAGEREF _Toc345927001 \h 14101515
13 LINK \l "_Toc345927002" 149.1. Обзор пространства имен GDI 13 PAGEREF _Toc345927002 \h 14101515
13 LINK \l "_Toc345927003" 149.2. Пространство имею System.Drawing 13 PAGEREF _Toc345927003 \h 14111515
13 LINK \l "_Toc345927004" 1410. Сеансы вывода графики 13 PAGEREF _Toc345927004 \h 14111515
13 LINK \l "_Toc345927005" 1410.1. Система координат по умолчанию в GDI+ 13 PAGEREF _Toc345927005 \h 14111515
13 LINK \l "_Toc345927006" 1410.2. Применение альтернативных точек отсчета 13 PAGEREF _Toc345927006 \h 14121515
13 LINK \l "_Toc345927007" 1411. Обзор пространства имен System.Drawing.Drawing2D 13 PAGEREF _Toc345927007 \h 14121515
13 LINK \l "_Toc345927008" 1411.1. Работа с перьями 13 PAGEREF _Toc345927008 \h 14121515
13 LINK \l "_Toc345927009" 1411.2. Работа с наконечниками перьев 13 PAGEREF _Toc345927009 \h 14141515
13 LINK \l "_Toc345927010" 1411.3. Работа с кистью 13 PAGEREF _Toc345927010 \h 14141515
13 LINK \l "_Toc345927011" 1411.4. Вывод изображений 13 PAGEREF _Toc345927011 \h 14151515
13 LINK \l "_Toc345927012" 1412. Обработка исключительных ситуаций 13 PAGEREF _Toc345927012 \h 14161515
13 LINK \l "_Toc345927013" 1412.1. Применение пары ключевых слов try и catch 13 PAGEREF _Toc345927013 \h 14161515
13 LINK \l "_Toc345927014" 1412.2. Применение нескольких операторов catch 13 PAGEREF _Toc345927014 \h 14171515
13 LINK \l "_Toc345927015" 1412.3. Перехват всех исключений 13 PAGEREF _Toc345927015 \h 14171515
13 LINK \l "_Toc345927016" 1412.4. Вложение блоков try 13 PAGEREF _Toc345927016 \h 14171515
13 LINK \l "_Toc345927017" 1412.5. Генерирование исключений самостоятельно 13 PAGEREF _Toc345927017 \h 14171515
13 LINK \l "_Toc345927018" 1412.6. Повторное генерирование исключений 13 PAGEREF _Toc345927018 \h 14181515
13 LINK \l "_Toc345927019" 1413. Классы: подробно 13 PAGEREF _Toc345927019 \h 14191515
13 LINK \l "_Toc345927020" 1413.1. Индексаторы 13 PAGEREF _Toc345927020 \h 14191515
13 LINK \l "_Toc345927021" 1413.2. Деструкторы 13 PAGEREF _Toc345927021 \h 14201515
13 LINK \l "_Toc345927022" 1413.3. Операции класса 13 PAGEREF _Toc345927022 \h 14201515
13 LINK \l "_Toc345927023" 1414. Наследование, делегирование 13 PAGEREF _Toc345927023 \h 14211515
13 LINK \l "_Toc345927024" 1415. Диалоговые окна, элементы управления 13 PAGEREF _Toc345927024 \h 14221515
13 LINK \l "_Toc345927025" 1416. Элементы управления (продолжение) 13 PAGEREF _Toc345927025 \h 14231515
15

Основные понятия языка
Алфавит и лексемы
Лексема (информатика) последовательность допустимых символов языка программирования, имеющая смысл для транслятора. Ну или минимальная неделимая единица языка. В шарпе, да и в других ЯП это они:
зарезервированные слова
идентификаторы
числовые константы (целые и действительные числа)
буквенные константы
строчные константы
коды операторов
комментарии. Комментарии непосредственно не несут информации о структуре программы. В дальнейшем они не используются, то есть не передаются синтаксическому анализатору.
скобки и другие элементы программы.
Что еще добавить я не знаю
Типы данных
Есть ссылочные, есть типы значений. Типы значений хранит данные на стёке, ссылочные типы хранятся в куче(heap). Стёк живет ограниченное количество времени, куда – пока ее не убьёт сборщик мусора.
Так же есть указательные типы. Это все неуправляемые (читай все, кроме строк и объекта) типы, объявленные указателем.
Встроенные типы:
Bool – булевый тип 0 и 1
Byte – целочисленный 0 255
Sbyte – целочисленные со знаком -127 127
Char – двухбайтовый юникодовый символ
Decimal – дробный, 16и байтовый, для финансовых расчетов, 28 значимых символов после запятой
Double – дробный 8ми байтовый, со знаком
Float – дробный 4х байтовый
Int – целочисленный со знаком 4х байтовый
Uint – целочисленный без знака 4хбайтовый
Long – целочисленный со знаком 8ми байтовый
Ulong – целочисленный без знака 8ми байтовый
Short – целочисленный со знаком 2х байтовый
Ushort – целочисленный без знака 2х байтовый
Object – родитель вообще всех типов в языке. Так или иначе все – объект. Можно запаковывать(читай явное приведение к object), так и распаковывать(читай обратное к запаковке). Каким типом является я хз, но, наверное, ссылочным. Да, на счет упаковки – это приведение типа значений к ссылочному типы, распаковка – наоборот.
String – ссылочный тип, единственный из базовых. Представляет собой упорядоченную коллекцию char. При этом значение строки – рид-онли
Операторы языка C#
Операторы ветвления
Их 2.
If(){}else{}
switch(){case:}.
Операторы цикла
Их 3.
do{} while()
while(){}
for()
Операторы передачи управления
Их 4.
Goto – работает везде
break работает для циклов и для свичей. В цикле – вообще пререрывает цикл, в свиче – выход их кейса.
Continue работает для циклов – пропуск текущей итерации.
Return работает везде. Возвращает управление в код на уровень выше.
Классы
Класс – набор методов и свойства реализующих нужный функционал.
Поля и константы
Поле, как и константа в классе – тупо классовая переменная. Константная переменная – просто переменная объявленная с модификатором const, особенность в том, что значение можно присвоить только один раз, при объявлении, например.
Прототип объявления
[const|static] [модификаторы доступа] тип имя [= значение];
Методы
Классовые методы – тупо методы, объявленные в реализации класса. Так же могут быть статическими, т.е. вызываться без создания объекта(экземпляра) класса. Каким-то образом сюда относятся и свойства.
Прототип объявления
[static][модификатор доступа] возвращаемый_тип имя ([входные аргументы]) {}
Конструкторы
Конструктор – метод класса, с таким же именем, что и класс, без объявления возвращаемого типа. Служит для выделения памяти, инициализации экземпляра класса, классовых переменных, да и вообще для всего чего захочешь.
Конструкторов может быть несколько для реализации перегрузки, если она нужна.
Прототип объявления
[модификатор_доступа]Имя_класса ([входные аргументы]){}
Свойства
Свойства – поля класса, не статические и не константные, у которых реализованы геттер и сеттер. Геттер/сеттер – методы, вызываемые при получении/установки значения переменной.
[модификатор доступа] тип имя {get{[к-лб действия]}; set{[ к-лб действия]}}
Массивы
Массив это структура данных, содержащая несколько переменных одного типа.
Одномерные массивы
Массив в форме простого вектора.
Объявление:
type[] имя_массива, где type – один из встроенных типов
Объявление и инициализация:
type[] имя_массива = new type[размерность];
type[] имя_массива = {1,2,3,4,5};
может быть еще есть, например, через перегруженный конструктор, но я их не знаю.
Многомерные массивы
Можно представить в виде двумерной таблицы.
Объявление схожее с одномерным вариантом, отличие в том, что при объявлении количесвто_запятых+1 в квадратных скобках – размерность массива, а в конструкторе необходимо указать размерность каждого измерения массива, тоже через запятую:
type[,,] имя_массива = new [1,2,3]; - трехмерный массив.
Объявление и инициализация:
type[,,] имя_массива = {{1,2,3},{1,2},{1}};
Неявно-типизированные массивы
Чтобы не трахаться с явным приведением типов, и переложить всю эту работу на компилятор, можно объявлять массивы типа var, а компилятор уже сам подставит нужный тип.
Объявление и инициализация такая же, как и у нормальных массивов, только type надо заменить на var.
Оператора цикла foreach
Просто удобная запись цикла для типов, реализующих интерфейс перечислений, тех, что IEnumerable.
Использование
foreach(type элемент in объект), где объект – та переменная, что реализует перечисление. Таким образом данный цикл выполнит количество итераций равное количеству элементов в объекте, при этом на каждой итерации текущий элемент будет помещен в переменную элемент.
Класс System.Array
Хз, зачем рассматривать этот класс.
Класс, реализующий всю работу с массивами, методы очистки, инициализации, копирования, перемещения, свойства размеров и параметров массива.
Основные свойства(по моему мнению):
Length – общая длина массива, как если бы его развернули в вектор.
Rank – количество измерений массива.
Методы:
Clear – зануляет нужный диапазон в массиве
Clone – просто делает клон массива, причем изменения в клоне или оригинале отображаются на оба массива
Copy – копирует нужный диапазон в новый массив
CopyTo – полностью копирует массив
IndexOf – ищет индекс в одномерном массиве
Sort – сортирует тоже одномерный массив
Символы и строки постоянной длины в C#
Класс char
Класс для работы с единичными символами в UTF-16. Можно делать сравнение на математическое равенство, при этом вместо символа используется его ascii код.
Методы:
IsDigit – истина, если число является десятичным числом
IsLetter – истина, если символ юникода
IsNumber – хз, в чем разница от IsDigit, но суть та же.
IsLower – символ в нижнем регистре
ToLower – привести символ в нижний регистр
IsUpper – символ в верхнем регистре
ToUpper – привести к верхнему регистру
Класс char[] – массив символов
Хрен знает, что она имела ввиду этим сочетанием букв. Это же просто массив charов, и ничего более. Посему методы, присущие массиву. Отдельно можно выделить ToString, думаю, он превращает массив в строку, а не пишет, что это массив типа чар.
Класс String
Объявление строк. Конструкторы класса String
Их целых 8(.
String(Char[]) – просто строка из массива чаров
String(Char, Int32) – строка из повторение чаров
String(Char[], Int32, Int32) – строка из диапазона чаров из массива
Операции над строками
Присваивание просто инициализация или присваивание через (=)
Сравнение на равенство(==) и неравенство(!=)
Конкатенация, как и сложение в математике (+)
Взятие индекса – просто обращение к элементу строки по индексу через квадратные скобки.
Статические свойства и методы класса String
Статических свойств у строки нет, хотя она может думает, что метод, имеющий в начале get – геттер для свойства, так вот это не так. У класса строк свойства всего два, и ни одно из них не статическое.
Статических методов до жопы, выберу на мой взгляд основные.
Compare – сравнивает две строки
Concat – конкатенация сторок, только в виде метода
Copy – копирует содержимое одной строки в другую
Format – формирует строку с подстановками из объектов, та штука, что в строке {0} {1} и так далее
Join – просто конкатенирует строки с определенным разделителем
Методы Join и Slpit
Join – статический метод для конкатенации строк и разделением их в результирующей строке разделителем, определенным одних из входных параметров метода.
Split – динамический метод, который возвращает массив строк, разделенных по переданному разделителю.
Динамические методы класса String
CopyTo – копирует строку в новый объект
IndexOf – возвращает индекс передаваемого элемента
Insert – вставляет символ/строку в переданную позицию
Remove – удаляет символ по заданному индексу
Replace – заменяет все вхождения на нужные
Split – делит строку по разделителю
Substring – возвращает подстроку по заданным границам
ToCharArray – возвращает массив чаров из этой строки
ToLower – всю строку в нижний регистр
ToUpper – то же, но в верхний
Trim – обрезает пробелы с начала и конца строки
Введение в Windows.Forms
Класс Windows.System.Forms.Application
Класс состоящий только из статических методов для управления приложением и получением его стостояния.
Exit – выходит из приложения, закрывая его контекст.
Run – запускает или голое приложение, или есть перегрузка с формой
Restart – сначала закрывает контекст приложения, затем сразу его снова открвает
Класс Form
Класс, реализующий просто окошко или диалоговое окошко, из которых строится ЮИ.
Конструктор один и без входных параметров.
Свойств до жопы:
BackColor – цвет подложки, ну или фоновый.
BackgroundImage – картинка на фон формы
Bounds – границы типа Rectangle
DialogResult – диалогрезульт с которым закрывается форма
Enabled – можно ли ей управлять или нет(при этом она видимая)
Font – шрифт для текста на форме, но не для элементов, расположенных на ней. Я так думаю, что это свойство для Bindingа, или чего-то еще.
Height – высота в пикселях
Opacity – прозрачность, как работает я не знаю, ибо не пробовал
Size – размер типа Size, наверное, чтобы не менять высоту и ширину, а сразу.
Text – текст формы, тот, что в заголовке
Visible – видимость, но при этом активность, т.е. невидимость не означает Enabled==false.
Width – ширина в пикселях.
Методы:
Activate – устанавливает форму активной и вытаскивает на передний план
BringToFront – просто вытаскивает на передний план
Close - закрывает
Focus – передает фокус формы, при этом она не обязательно будет на переднем плане, но будет ловить клавиатуру
Refresh – заставляет форму и все что на форме перерисоваться
Scale – несколько перегрузок, меняет размер формы
Show – просто показывает форму, типа Activate
ShowDialog – показывает форму в диалоговом режиме
Update – мягче, чем Refresh, так как использует метод Invalidate для определения надобности полной перерисовки формы. Вообще, я разницы не вижу(
Меню
2 класса: MenuStrip, ContextMenuStrip.

Создание меню приложения (Подсмотрено в Form1.Designer.cs):
Меню может содержать 3 типа элементов:
MenuItem – аналог кнопки.
ComboBox
TextBox

Пример:
private System.Windows.Forms.MenuStrip menuStrip1;
private void InitializeComponent( ) {
t
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·is.toolStripMenuItem1.Size = new System.Drawing.Size(45, 20);
this.toolStripMenuItem1.Text = "Файл";
this.toolStripMenuItem1.Click += new System.EventHandler(this.toolStripMenuItem1_Click);


this.Controls.Add(this.menuStrip1);
this.MainMenuStrip = this.menuStrip1;
}


Думаю, аналогичным способом добавляются и ComboBox и TextBox.

Создание контекстного меню (Подсмотрено там же):
Контекстное меню просто так не показывается, его надо связать с помощью свойства ContextMenuStrip у элемента, на котором меню должно вызываться.
Может содержать следующие элементы:
MenuItem
ComboBox
Separator
TextBox

Пример:
private System.Windows.Forms.ContextMenuStrip contextMenuStrip1;
this.components = new System.ComponentModel.Container();
this.contextMenuStrip1 = new Syste
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
Создание строки состояния и панели инструментов
StatusBar
Устаревший класс, на замену ему есть StatusStrip, но мы же, блять, по прогрессивной программе учимся, поэтому не используем классы, для которых есть компоненты WindowsForms.
Класс ебанутый до невозможности. Единственная штука которую может содержать СтатусБар это StatusBarPanel.
Создаем СтатусБар с двумя панелями:
StatusBar statusBar1 = new StatusBar();
StatusBarPanel panel1 = new StatusBarPanel();
StatusBarPanel panel2 = new StatusBarPanel();

Panel
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·Такая же дремучая хунта, как и СтатуБар, но, тем не менее, поддерживается.
toolBar1 = new ToolBar();
ToolBarButton toolBarButton1 = new ToolBarButton();
ToolBarButton toolBarButton2 = new ToolBarButton();
ToolBarButton toolBarButton3 = new ToolBarButton();

toolBarButton1.Text = "OPen";
toolBarButton2.Text = "Save";
toolBarButton3.Text = "Print";

toolBar1.Buttons.Add(toolBarButton1);
toolBar1.Buttons.Add(toolBarButton2);
toolBar1.Buttons.Add(toolBarButton3);

this.Controls.Add(toolBar1);

Графика
Обзор пространства имен GDI
Pft,fnjt простанство имен, хотя дизайн не оч( Ну и графон вообще никуда, физики ВООБЩЕ НЕТУ, БЛДЖАД!!!
Честно говоря, хз что писать, так как документации по нему нет, только для плюсов, а в шарпе его, вроде нет, ПОТОМУ ЧТО ОН, БЛЯТЬ, ДЛЯ C!!! Ебаная ты овца( И ПАТАМУШТА В C# ЭТО System.Drawing, БЛЕАТЬ!!!!

Тем не менее, мы ж ничего не знаем, так что задвигаем про Фреймворк для сей.

GDI это интерфейс Windows для представления графических объектов и передачи их на устройства отображения, такие как мониторы и принтеры.
GDI отвечает за отрисовку линий и кривых, отображение шрифтов и обработку палитры. Он не отвечает за отрисовку окон, меню и т. п., эта задача закреплена за пользовательской подсистемой, располагающейся в user32.dll и основывающейся на GDI.
Оперирует базовым инструментарием, состоящим из:
Bitmap – объект для создания и управления графическими файлами на диске, так же служит практически основным объектом с которым ведется работа типа изменения масштаба, поворотов, смещения и прочей хрени.
Brush – объект для рисования примитивных фигур: круг, эллипс, квадрат, прямоугольник, возможно рисовать полигоны.
Pen – объект для рисования прямых и кривых, ну еще шрифтов, короче линий.
Color – думаю, пояснений не надо.
Coordinate space and transformations – координатная плоскость представлена двумя измерениями. Трансформации – преобразование графических объектов, чаще всего это изменение формы, размеров или координат.
Device Context – структура, представляющая собой множество (набор, set) графических объектов необходимых для вывода на устройство.
Filled Shapes – графические объекты нарисованные Pen и залитые Brush. Могут быть:
Эллипс
Корд, цепь, струна. Chord
Пирожок. Pie.
Полигон
Прямоугольник
Fonts and Text – графические объекты для отрисовки текста. Font рисуется Pen.
Lines and Curves – опять же графические объекты только для отрисовки линий, рисуются так же Pen.
Painting and Drawing – операции для вывода графического объекта на устройство. В чем разница я хз.
Printing and Print spooler – операции для вывода графики на принтер и вообще управление принтер через его спуллер.
Rectangle – графический объект прямоугольник. Рисуется Pen.
Region – графический объект в виде Rectangle, Ellipse or Polygon для проверки попадания мышки в него (hit testing).
Пространство имею System.Drawing
Пространство имен, предоставляющее доступ к функциям GDI+. Состоит из дохера классов, но базовых меньше:
Bitmap – реализация gdi+ bitmap, что есть массив графических данных попиксельно со всеми их атрибутами. Используется для работы с изображениями, etc.
Brush – инструмент для заполнения фигур цветом.
SolidBrush – тоже для заполнения объектов, но только одним цветом. Я так понимаю, что просто Brush можно расширять за счет рисования им картинкой, например.
TextureBrush – вот эта штука, которая используется просто Brush с текстурой из картинки для заполнения фигур, т.е. обертка вокруг Brush для залития формы картинкой, так я думаю.
Font – работает с форматом текста, его шрифтом, семейством шрифта и его начертанием.
Graphics – непосредственна та поверхность (surface) на которой все рисуется.
Image – абстрактный класс, объединяющий фукнционал битмапа и метафайла в один. Короче, класс для работы с картинками, которые могут быть (а по идее и должны) битмапом.
Pen – основной инструмент для рисования линий.
Region – (Google translate) Описание интерьера графики форма состоит из прямоугольников и путей. Этот класс не может быть унаследован.
Остальная хуита – дополнительные классы, расширяющие функционал данных.
Данное пространство имен примитивно (для рисования), поэтому его расширения находятся в System.Drawing.Drawing2D, System.Drawing.Imaging and System.Drawing.Text.
Сеансы вывода графики
Система координат по умолчанию в GDI+
X0 Y0 находится в верхнем левом углу.
В GDI+ используется три координатных пространства: объемное, страничное и пространство устройства.
Объемные координаты это координаты, которые служат для моделирования определенного графического пространства. Именно они передаются методам в .NET Framework.
Страничные координаты это система координат, используемая областью рисования, например формой или элементом управления.
Координаты устройства это система координат, используемая физическим устройством, на котором производится рисование, будь то экран или лист бумаги.
При вызове myGraphics.DrawLine(myPen, 0, 0, 160, 80) точки, передаваемые методу DrawLine, (0, 0) и (160, 80) относятся к объемной системе координат. Перед тем как интерфейс GDI+ выполнит рисование линии на экране, координаты подвергнутся последовательности преобразований.
Одно из преобразований, называемое объемным преобразованием, переводит объемные координаты в страничные, после чего страничное преобразование переводит страничные координаты в координаты устройства.
За объемное преобразование, которое служит для перевода объемных координат в страничные, отвечает свойство Transform класса Graphics.
Преобразование, переводящее страничные координаты в координаты устройства, называется страничным преобразованием. За страничное преобразование отвечают свойства PageUnit и PageScale класса Graphics. Класс Graphics также содержит два доступных только для чтения свойства DpiX и DpiY, позволяющих узнать количество точек на дюйм в используемом устройстве отображения.

Свойство PageUnit класса Graphics можно использовать для задания единицы измерения, отличной от пикселя.
myGraphics.PageUnit = GraphicsUnit.Inch;

Применение альтернативных точек отсчета
В GDI+ для изменения точки отсчета системы координат используется метод TranslateTransform() ,определенный в классе Graphics. Например, установить точку отсчета в положение 100.100 относительно системы координат по умолчанию можно следующим образом:
Grapics G = this.CreateGraphics();
G.PageUnit=GraphicsUnit.Point;
G.TranslateTransform(100.100);


Обзор пространства имен System.Drawing.Drawing2D
Работа с перьями
Обычное применение объектов Pen (перьев) заключается в рисовании линий. Как правило, объект Pen используется не сам по себе: он передается в качестве параметра многочисленным методам вывода, определенным в классе Graphics. Как правило, названия всех этих методов, использующих Pen, начинаются с Draw.
Методы:
DrawArc()

Этот метод предназначен для вывода дуги. Он принимает в качестве параметров объект Pen и данные, позволяющие построить эллипс и выделить на нем дугу.

DrawBezier()
DrawBeziers()
Метод для вывода кубической кривой Безье (нескольких кривых) по четырем точкам

DrawCurve()
Метод для вывода кривой на основе массива точек.

DrawEllipse()

Метод для вывода эллипса, вписанного в прямоугольник (передаются координаты прямоугольника).

DrawLine()
DrawLJnes()
Эти методы соединяют прямыми линиями точки (массив точек)


DrawPath()

Этот метод выводит коллекцию прямых и кривых линий при помощи типа GraphicsPath, определенном в пространстве имен System.Drawing.Drawing2D.

DrawPie()

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

DrawPolygon()
Выводит многоугольник на основе принимаемого массива точек.

DrawRectangle()
DrawRectangles()
Выводят прямоугольник (или несколько прямоугольников), основываясь на двух точках: для верхнего левого и нижнего правого угла. Можно передавать как объект Rectangle, так и координаты точек в виде значений int и float.


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

Color
Определяет цвет создаваемых объектом Pen линий

CompoundArray
Позволяет получить или создать массив пользовательских вариантов штрихов

CustomStartCap
CustomEndCap
Позволяют получить или установить стиль «наконечника» пера, который будет показан в начале линии (StartCap) и в конце линии (EndCap)

DashCap

Позволяет получить или установить стиль «наконечника» для перьев, рисующих пунктирные линии

DashOffset

Устанавливает смещение начала пунктира относительно исходной точки пунктирной линии

DashPattem

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

DashStyle

Позволяет получить или установить стиль для пунктирных линий, создаваемых при помощи данного объекта Pen

LineJoin

Позволяет получить или установить стиль объединения при пересечении двух линий, выводимых данным объектом Pen

РепТуре
Позволяет получить стиль линий, выводимых при помощи данного объекта Pen

StartCap
EndCap

Позволяет получить или установить один из заранее готовых стилей «наконечника» пера. Используются значения из перечисления LineCap, определенного в пространстве имен System.Drawlng.Drawing2D.

Width
Позволяет получить или установить ширину данного пера


Кроме класса Реп в GDI+ также можно использовать коллекцию заранее определенных перьев (коллекция Pens). При помощи статических свойств коллекции Pens мы можем мгновенно получить уже готовое перо, без необходимости создавать его вручную. Однако, все типы Pen, которые создаются при помощи коллекции Pens, имеют одну и ту же одинаковую ширину, равную 1.
Таблица со стилями DashStyle:
Custom
Пользовательский стиль пунктира

Dash
Штриховая линия

DashDot
Штрихпунктирная линия: штрих-точка-штрих

DashDotDot
Штрихпунктирная линия: штрихточкаточкаштрих

Dot
Пунктир из одних точек

Solid
Сплошная линия


Помимо использования готовых стилей пунктирных линий из перечисления DashStyles, мы можем также определить свой собственный стиль. Для этого используется свойство DashPattern класса Pen:
Pen customDashPen = newPen(Color.BlueViolet,5);
float[] myDashes = {5.0f, 2.0f, 1.0f, 3.0f} ;
customDashPen.DashPattern = myDashes;


Работа с наконечниками перьев
Если мы предпочитаем более изысканные окончания линий, в нашем распоряженииперечисление LineCap .Значения этого перечисления представлены в таблице:
ArrowAnchor
Линии оканчиваются стрелками

DiamondAnchor
Линии оканчиваются «бриллиантами» (ромбами)

Flat
Стандартное прямоугольное завершение линий

Round
Линии на концах скруглены

RoundAnchor
На концах линий «шары» ;)

Square
На концах линий квадраты в толщину линии

SquareAnchor
На концах линий квадраты большего размера, чем толщина линии

Пример использования:
Pen redPen = new Pen(Brushes.Red, 6.0F);
redPen.StartCap = System.Drawing.Drawing2D.LineCap.RoundAnchor;
redPen.EndCap = System.Drawing.Drawing2D.LineCap.ArrowAnchor;



Работа с кистью
Сам класс Brush абстрактные, поэтому мы не можем создавать объекты этого класса. Вместе него есть наследники, всякие SolidBrush, HatchBrush, etc.
Кистей есть 4 вида:
Простые (хз как называются) SolidBrush
Штриховые. HatchBrush
Текстурные. TextureBrush
Градиентные. LinearGradientBrush
Простые:
Класс SolidBrush. Заливают сплошным цветом.
Методы (УНИВЕРСАЛЬНЫ ДЛЯ ЛЮБОГО ТИПА КИСТИ):
FillClosedCurve()
Закрашивает область внутри замкнутой кривой

FillEllipse()
Закрашивает область внутри эллипса

FillPath()
Закрашивает область внутри траектории

FillPie()
Закрашивает область внутри сегмента эллипса

FillPolygon()
Закрашивает область внутри многоугольника

FillRectangle()
FillRectangles()
Закрашивают область внутри прямоугольника (нескольких прямоугольников)

FillRegion()
Закрашивает внутреннюю область объекта Region (Regionэто внутренняя область геометрической фигуры)


Пример:
SolidBrush blueBrush = new SolidBrush(Color.Blue);
g.fillEllipse(blueBrush, 10, 10, 100, 100);


Штриховые:
Класс HatchBrush.
Используются для заливки фигур различными штрихованными линиями. Стили штриховки находятся в перечислении HatchStyle.
Основные стили:
BackwardDiagonal
Диагональная штриховка с наклоном вправо

Crass
«Крестообразная» штриховка, состоящая из пересекающихся вертикальных и горизонтальных линий

DiagonalCross
Еще одна разновидность «крестообразной» штриховки, состоящая из пересекающихся диагональных линий

ForwardDiagonal
Диагональная штриховка с наклоном влево

Hollow
«Пустая» кисть, которая ничего не рисует

Horizontal
Горизонтальная штриховка

Pattern
Штриховка, которая создается на основе указанного пользователем растрового изображения

Solid
Обычная «плотная» кисть без всякой штриховки (аналогично обычному типу SolidBrush)

Vertical
Вертикальная штриховка


Пример:
HatchBrush hBrush = new HatchBrush(HatchStyle.Horizontal, Color.Red);
g.FillEllipse(hBrush, 0, 0, 100, 60);


Текстурные:
Класс TextureBrush. Заливают картинкой.
Ничего особенного, только пример:
Image bGroundBrushlmage = new Bitmap(“Coluds.bmp");
TextureBrush tBrush = new TextureBrush(bBroundBrushlmage);
g:FillRectangle(tBrush, ClientRectangle);


Градиентные:
Класс LinearGradientBrush. Заливают градиентом.
Типы градиента определены в перечислении LinearGradientMode.
Основные(а может их больше и нет, я хз) типы градиента:
BackwandDiagonal
Из верхнего правого угла в нижний левый

ForwardDiagonal
Из верхнего левого угла в нижний правый

Horizonta l
Слева направо

Vertical
Сверху вниз


ВСЕ, БЛЕАТЬ, ЗАЕБЛА( Я БОЛЬШЕ КИСТЕЙ НЕ ЗНАЮ И НИГДЕ НЕ НАШЕЛ!
Вывод изображений
Дохера методов работы с картинкой, типа трансформации, конвертации, сохранения, etc.
Основные методы:
FromFile()
Этот статический метод предназначен для создания объекта Image из файла

FromHbitmap()
Еще один статический метод. Создает объект Bitmap на основе идентификатора окна (Window handle)

FromStream()
Этот статический метод позволяет создать объект Image, используя в качестве источника поток данных

GetBounds()
Возвращает прямоугольник, представляющий текущую область, занятую изображением

Save()
Позволяет сохранить изображение в файл


Основные свойства:
Height
Width
Size
PhysicalDimensions
HorizontaDimensions
VerticalResolution
Все эти свойства предназначены для работы с размерами (измерениями) изображения

Palette
Это свойство возвращает объект ColorPalette, представляющий цветовую палитру, использованную для данного графического изображения

Обработка исключительных ситуаций
Применение пары ключевых слов try и catch
Функции обработки исключений на языке C# помогают обрабатывать любые непредвиденные или исключительные ситуации, происходящие при выполнении программы.
При обработке исключений используются ключевые слова try, catch и finally для попыток применения действий, которые могут не достичь успеха, для обработки ошибок, если предполагается, что это может быть разумным, и для последующего освобождения ресурсов. Исключения могут генерироваться средой CLR, платформой .NET Framework или внешними библиотеками, либо кодом приложения.
Во многих случаях исключение может инициироваться не методом, вызванным непосредственно кодом, а другим методом, расположенным ниже в стеке вызовов. Когда это происходит, среда CLR выполняет откат стека в поисках метода с блоком catch для определенного типа исключения. При обнаружении первого такого блока catch этот блок выполняется. Если среда CLR не находит соответствующего блока catch где-либо в стеке вызовов, она завершает процесс и отображает пользователю сообщение.

Исключения имеют следующие свойства:
Исключения имеют типы, в конечном счете являющиеся производными от System.Exception.
Следует использовать блок try для заключения в него инструкций, которые могут выдать исключения.
При возникновении исключения в блоке try поток управления немедленно переходит к первому соответствующему обработчику исключений, присутствующему в стеке вызовов. В языке C# ключевое слово catch используется для определения обработчика исключений.
Если в блоке catch определяется переменная исключения, ее можно использовать для получения дополнительной информации о типе произошедшего исключения.
Код в блоке finally выполняется, даже при возникновении исключения. Блок finally используется для освобождения ресурсов, например для закрытия потоков или файлов, открытых в блоке try.

Пример:
try {
int i = new Random().Next() / new Random().Next();
}
catch(DivideByZeroException e) {
Сonsole.WriteLine("Div by zero");
}

Применение нескольких операторов catch
Вполне возможна вероятность возникновения различного типа исключений. Их много, и нет смысла приводить все.
Пример:
try {
int i = new Random().Next() / new Random().Next();
}
catch(DivideByZeroException e) {
Сonsole.WriteLine("Div by zero");
}
catch (System.UnauthorizedAccessException e)
{}
catch (System.MagicDoesntWork e) {}

Перехват всех исключений
Для перехвата всех исключений достаточно использовать оператор catch с пустым входным параметром.
Пример:
try {
int i = new Random().Next() / new Random().Next();
}
catch(Exception ex) {
Сonsole.WriteLine("Shit happens: {0}”, ex.ToString());
}

Вложение блоков try
Один блок try может быть вложен в другой. Исключение, генерируемое во внутреннем блоке try и не перехваченное в соответствующем блоке catch, передается во внешний блок try:
Пример:
try
{
try
{ }
catch(OverflowException)
{ }
}
catch (FormatException ex)
{ }

Генерирование исключений самостоятельно
Для генерирования исключения можно поступить 2мя способами:
Передать исключение дальше, повторно вызвав его с помощью throw.
Либо пронаследовать класс System.Exception.

Генерим с помощью throw.
Пример:
try {
int i = new Random().Next() / new Random().Next();
}
catch(Exception ex) {
throw new Exception(new String.Format(“Caused at object {0}”, “MY BRAIN”));
}


Наследуем класс Сутем.Эксепшн.
Пример:
public class MyExc : System.Exception {
public MyExc( );
public override string Message {
get {
return "1 2 FUCK YOU!!!!";
}
}
}
}
class Program {

public void DoSmthn( ) {
if ( true )
throw new MyExc( );
}
static void Main( string[ ] args ) {
try {
DoSmthn( );
}
catch ( MyExc ex ) {
Console.WriteLine( ex.Message );
}
}
}


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

Не следует, однако, забывать, что когда исключение генерируется повторно, то оно не перехватывается снова тем же самым блоком catch, а передается во внешний блок catch.
Пример:
class Program
{
static void Del(int x, int y)
{
try
{
int result = x / y;
}
catch(DivideByZeroException)
{
Console.WriteLine("Деление на ноль!");
throw;
}
}

static void Main()
{
try
{
Del(5, 0);
}
catch (DivideByZeroException)
{
Console.WriteLine("Программная ошибка!");
}
Console.ReadLine();
}
}


Классы: подробно
Индексаторы
Индексаторы позволяют индексировать экземпляры класса или структуры так же, как массивы. Индексаторы напоминают свойства, но их методы доступа принимают параметры.

В следующем примере определяется универсальный класс и в качестве средств присвоения и извлечения значений создаются простые методы доступа get и set. Класс Program создает экземпляр этого класса для хранения строк.
class SampleCollection
{
private T[] arr = new T[100];

public T this[int i]
{
get
{
return arr[i];
}
set
{
arr[i] = value;
}
}
}

class Program
{
static void Main(string[] args)
{
SampleCollection stringCollection = new SampleCollection();

stringCollection[0] = "Hello, World";
System.Console.WriteLine(stringCollection[0]);
}
}

Деструкторы
Деструктор – метод аналогичный конструктору. Но он может быть явно не реализован, кроме того ДЕСТУРКТОР НЕЛЬЗЯ ВЫЗВАТЬ РУКАМИ. Деструкторы вызывается сам при смерти объекта (экземпляра класса).
Объявляется деструктор со знаком тильды (~) впереди и именем класса. У деструктора нет входных параметров, нет перегрузок, и он ничего не возвращает.
Чаще всего используется для освобождения выделенных ресурсов класса во время рантайма.

Пример (Происходит закрытие потока данных):
public class MyNewClass {
List tL;
System.IO.FileStream fs;
public MyNewClass( ) {
tL = new List( new int[] {1, 2, 3} );
fs = System.IO.File.OpenWrite(@"C:\pagefile.sys");
}
~MyNewClass( ) {
fs.Close( );
}
}

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

Операции класса описываются с помощью методов специального вида (функций-операций). Перегрузка операций похожа на перегрузку обычных методов. Синтаксис операции:
[ атрибуты ] спецификаторы объявитель_операции тело

Пример:
public class MyNewClass {
int x;
public MyNewClass( int value ) {
this.x = value;
}
public static MyNewClass operator +( MyNewClass ble, MyNewClass atb ) {
return new MyNewClass( ble.x + atb.x );
}
}

Наследование, делегирование
Наследование:
Наследование, вместе с инкапсуляцией и полиморфизмом, является одной из трех основных характеристик (или базовых понятий) объектно-ориентированного программирования.
Наследование позволяет создавать новые классы, которые повторно используют, расширяют и изменяют поведение, определенное в других классах. Класс, члены которого наследуются, называется базовым классом, а класс, который наследует эти члены, называется производным классом. Производный класс может иметь только один непосредственный базовый класс. Однако наследование является транзитивным. Если ClassC является производным от ClassB, и ClassB является производным от ClassA, ClassC наследует члены, объявленные в ClassB и ClassA.
Пример (Наследуются 2 поля “x” и “y”):
public class OriginClass {
protected int x;
protected int y;
public OriginClass( ) {
}
}
public class OriginClassInheritor : OriginClass {
public int res {
get {
return x + y;
}
}
public OriginClassInheritor( int xval, int yval ) {
x = xval;
y = yval;
}
}



Делегирование:
Делегат это тип, который определяет сигнатуру метода. При создании экземпляра делегата можно связать этот экземпляр с любым методом с совместимой сигнатурой. Метод можно запустить (или вызвать) с помощью экземпляра делегата.

Делегаты используются для передачи методов в качестве аргументов к другим методам. Обработчики событий это нe что иное, как методы, вызываемые с помощью делегатов. Вы создаёте свой метод, и класс, как например, элемент управления Windows, может вызывать ваш метод при возникновении определенного события. В следующем примере показано объявление делегата:
public delegate int PerformCalculation(int x, int y);

Делегату можно назначить любой метод из любого доступного класса или структуры, соответствующий сигнатуре делегата, которая состоит из типа возвращаемого значения и параметров. Этот метод должен быть статическим методом или методом экземпляра. Это позволяет программно изменять вызовы метода, а также включать новый код в существующие классы. Если сигнатура делегата известна, то можно назначить собственный метод.

Пример:
public delegate void Delegate( int i );
public void DelegateImplementation( int i ) {
i++;
}

public void DelegateTestCall( ) {
Delegate dlg = DelegateImplementation;
dlg( 1 );
}

Диалоговые окна, элементы управления
Диалоговое окно:
Модальные окна в основном используются как диалоговые. "Диалоговое окно" это специальный тип окна в приложениях для взаимодействия с пользователями, выполняющий такие задачи, как открытие файлов или печать документов.
Диалоговые окна зачастую позволяют пользователям принять или отменить задачу, отображаемую им до закрытия диалогового окна. ShowDialog возвращает значение с типом NullableBoolean, указывающее, было ли выполнено действие или же отменено. Возвращаемое значение представляет собой значение свойства DialogResult перед закрытием окна.Дополнительные сведения см. в разделе DialogResult.

Я вот не знаю, может сюда надо еще включить те диалоги, что:
OpenFileDialog – диалог открытия файла.
PrintDialog – стандартное окно печати Windows.
SaveFileDialog – диалог сохранения файла
Элементы управления:
Делятся на кучу категорий.
Основные:
Макетные (Layout). Используются для управления размером, размерностью, положением и расположением дочерних элементов.
Border - Рисует границу фон или и то, и другое вокруг другого элемента.
Canvas - Определяет область, в которой можно разместить дочерние элементы явным образом с помощью координат, относительно Canvas область.
DockPanel - Определяет область, в которой можно упорядочить дочерние элементы горизонтально или вертикально относительно друг друга.
Grid - Определяет гибкую область сетки, состоящей из столбцов и строк.
Panel -
ScrollBar
Window
StackPanel - Упорядочивает дочерние элементы в одну линию, которая может быть ориентировать горизонтально или вертикально.
Кнопки
Button
RepeatButton
Отображение данных. Используются для отображения информации из источника данных.
DataGrid
ListView
TreeView
[ Cкачайте файл, чтобы посмотреть ссылку ]
Calendar
DatePicker
Меню
Menu
ContextMenu
ToolBar
Выбор. Используются для предоставления пользователю возможности выбирать один или несколько параметров.
CheckBox
ComboBox
ListBox
RadioButton
Slider
Навигация
TabControl
Информация для пользователя
Label
Popup
ProgressBar
StatusBar
TextBlock
ToolTip
Ввод данных
TextBox
RichTextBox
PasswordBox
Мультимедиа
Image
MediaElement - Представляет элемент управления, содержащий аудио и/или видео.
InkCanvas
Элементы управления (продолжение)
Что тут писать я не знаю. Помню на последней лекции она нам давала про возможные кнопки у MessageBox.

MessageBox – класс Отображает окно сообщения, содержащее текст, кнопки и символы, с помощью которых информируется и инструктируется пользователь.
Вызывается методом Show.
Перегрузок до жопы, но во многих он хавает список отображаемых кнопок. Находятся они в перечислении MessageBoxButtons.
OK
Окно сообщения содержит кнопку "ОК".

OKCancel
Окно сообщения содержит кнопки "ОК" и "Отмена".

AbortRetryIgnore
Окно сообщения содержит кнопки "Прервать", "Повторить" и "Пропустить".

YesNoCancel
Окно сообщения содержит кнопки "Да", "Нет" и "Отмена".

YesNo
Окно сообщения содержит кнопки "Да" и "Нет".

RetryCancel
Окно сообщения содержит кнопки "Повторить" и "Отмена".


Пример вызова:
MessageBox.Show("1 2 FUCK YOU!!!", MessageBoxButtons.OK);


",.8:PRdfxz€Љ ў°ІИКавшъ
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·ѕђ Заголовок 1ѕђ Заголовок 2ѓђ Заголовок 3¤ђ Заголовок 415

Приложенные файлы

  • doc 7866204
    Размер файла: 289 kB Загрузок: 0

Добавить комментарий