Окно диалога Контрольное значение
Отображает текущее значение выделенного выражения. Эта функция полезна при отладке для просмотра текущего значения переменной, свойства или другого выражения.
Параметры окна диалога
Контекст Отображает имена проекта, модуля и процедуры, в которых определено контрольное выражение.
Выражение Отображает выделенное выражение.
Значение Отображает значение выделенного выражения. Текущее значение не выводится, если контекст выражения находится вне процедур, перечисленных в окне диалога Стек вызова.
Добавить Добавляет выражение в область Контрольные окна отладки.
Окно диалога Настройка
Позволяет настраивать панели инструментов и меню.
Вкладки
Панели инструментов Позволяет создавать, переименовывать, удалять или сбрасывать панели инструментов.
Команды Содержит команды, которые можно перетащить с помощью мыши в меню или панель инструментов.
Параметры Позволяет изменять размеры кнопок панелей инструментов, отображать подсказки и клавиши быстрого набора, добавлять в меню элементы анимации.
Кнопка вызова Помощника Отображает Помощника по Office.
Окно диалога Настройка печати
Отображается при нажатии кнопки Настройка в окне диалога Печать.
Используется для выбора принтера, ориентации и размера страницы.
Параметры окна диалога
Принтер Позволяет задать принтер. Если принтер не выбран, печать будет осуществлена на принтере Windows по умолчанию.
Имя - Отображает список доступных принтеров.
Состояние - Отображает состояние принтера и его готовность к работе.
Тип - Отображает тип принтера.
Место - Отображает место размещения принтера. Ели принтер сетевой, выводит путь к серверу.
Заметки - Отображает физическое место размещения принтера, а также дополнительные сведения.
Свойства - Отображает окно диалога Свойства для выбранного принтера, где задаются дополнительные параметры, такие как используемая бумага и способ печати графики.
Бумага Позволяет выбрать размер и тип подачи бумаги (из доступных вариантов). Размеры и типы подачи бумаги зависят от выбранного принтера и изменяются при изменении принтера.
Размер бумаги - Отображает список доступных размеров бумаги.
Подача бумаги - Отображает доступные типы подачи бумаги для выбранного принтера.
Ориентация Позволяет выбрать книжную или альбомную ориентацию листа при печати.
Окно диалога Параметры компонента
Позволяет добавить справочные сведения или комментарии для процедуры, описанной в проекте.
Параметры окна диалога
Имя компонента Отображает имя элемента, выделенного в списке Классы или Компоненты.
Описание Позволяет задать строку, отображаемую в панели описания в окне диалога Просмотр объектов.
Файл контекстной справки Отображает связанный с выбранным элементом файл справки. Это значение задается в ячейке Файл контекстной справки на вкладке Общие окна диалога Свойства проекта.
Идентификатор справки Присваивает уникальное числовое значение идентификатору контекста. Это значение используется для поиска соответствующего раздела в файле справки из ячейки Файл контекстной справки при нажатии клавиши F1 или кнопки
Окно диалога Переименование панели
Позволяет задать новое имя специальной панели инструментов.
Параметры окна диалога
Панель инструментов Задает новое имя панели инструментов.
Окно диалога Просмотр объектов
Отображает классы, свойства, методы, события и константы объектных библиотек и процедур проекта. Используется для поиска объектов, созданных в текущем или других приложениях.
Дополнительные сведения о просмотре объектов можно получить в разделе Просмотр объектов справочной системы.
Элементы управления
Поле Проект/Библиотека
Отображает список библиотек, прямо адресуемых из активного проекта. Добавление библиотек выполняется в окне диалога Ссылки. При выборе значения <Все библиотеки> одновременно отображаются все библиотеки.
Поле поиска текста
Содержит строку искомого текста. Допускается ввод или выбор строки. Поле содержит также 4 последних искавшихся в текущем проекте строки. В строке допускается использование стандартных подстановочных знаков Visual Basic.
Для поиска целых слов в контекстном меню следует выбрать команду Только слово целиком.
Кнопка Назад
Позволяет перейти к предыдущему выбранному месту в списке классов и компонентов. При каждом нажатии кнопки происходит возврат на одно положение, пока не будет достигнуто самое первое обращение к этим спискам.
Кнопка Вперед
При каждом нажатии повторяет первоначальный выбор в списке классов и компонентов, пока не будет достигнуто самое последнее обращение к этим спискам.
Кнопка Скопировать в буфер обмена
Копирует выделенный текст из списка компонентов или из области описания в буфер обмена. В дальнейшем возможна вставка этого текста в программу.
Кнопка Описание
Помещает курсор в окне модуля в место описания выделенного объекта из списка классов или компонентов.
Кнопка Справка
Отображает контекстную справку по выделенному в списке классов или компонентов объекту. Для получения справки также служит клавиша F1.
Кнопка Найти
Выполняет поиск библиотек, в которых встречается класс, свойство, метод, событие или константа, совпадающие с шаблоном, заданным в поле поиска текста, а также открывает панель Результаты поиска, содержащую сведения о найденных элементах.
Кнопка Показать/скрыть результаты поиска
Отображает или скрывает панель Результаты поиска. В этой панели выводятся результаты поиска в проекте или библиотеке, выбранных из списка Проект/Библиотека. Результаты выводятся в алфавитном порядке.
Список Результаты поиска
Отображает библиотеку, класс и компонент, удовлетворяющие условиям поиска. Содержимое панели Результаты поиска изменяется при изменении значения в списке Проект/Библиотека.
Список Классы
Отображает список всех доступных классов из библиотеки или проекта, выбранных в поле Проект/Библиотека. Если для класса существует программный текст, этот класс выделяется жирным шрифтом. Список всегда начинается с класса <глобальные>, компоненты которого доступны глобально.
Если выделен класс, но не указан компонент, будет выведен компонент по умолчанию (если таковой существует). Компонент по умолчанию помечается звездочкой (*) или определенным для данного компонента значком по умолчанию.
Список Компоненты
Отображает список компонентов выбранного класса, сгруппированных по типу и упорядоченных внутри каждой группы по алфавиту. Методы, свойства, события и константы, для которых имеется программный код, выделяются жирным шрифтом. Порядок сортировки изменяется командой Компоненты группы контекстного меню просмотра объектов.
Панель описания
Отображает описание компонента. Содержит ссылку для перехода к классу или библиотеке, к которой принадлежит компонент. Некоторые компоненты имеют также ссылку на свой родительский класс. Например, если в панели описания указано, что Команда1 имеет тип Кнопка, выбор этой надписи отобразит класс Кнопка.
Допускается перетаскивание с помощью мыши текста из панели описания в окно модуля.
Линия разбивки
Разделяет панели и позволяет изменять их размер. Существует между:
Списками Классы и Компоненты.
Списком Результаты поиска и списками Классы и Компоненты.
Списками Классы и Компоненты и панелью описания.
Окно диалога Шрифт
Служит для изменения шрифта, его размера и/или начертания для текста и полей данных.
Параметры окна диалога
Шрифт Отображает список всех установленных в Windows шрифтов. При открытии окна диалога выбирается шрифт, использованный для форматирования выделенного элемента.
Начертание Отображает список четырех дополнительных атрибутов, применимых к выбранному шрифту:
Обычный - стандартное, неизмененное начертание
Полужирный - жирный шрифт
Курсив - наклонный шрифт
Полужирный курсив - жирный наклонный шрифт
Размер Отображает список стандартных размеров для выбранного шрифта. При открытии окна диалога выбирается размер шрифта, использованный для форматирования выделенного элемента, и этот размер отображается в первой строке списка размеров.
Допускается выбор размера из списка или его ввод в поле редактирования (если есть уверенность, что для текущего принтера установлены дополнительные размеры шрифта, или если используется масштабируемый шрифт).
Атрибуты Отображает два дополнительных атрибута, используемые для выделения выбранного шрифта.
Зачеркнутый - перечеркивает символы шрифта
Подчеркнутый - подчеркивает символы шрифта
Возможно задание любого сочетания атрибутов.
Образец Отображает образец выбранного шрифта. Показываются: шрифт, начертание, размер, атрибуты и цвет (если указан). Полезно использовать это поле для просмотра результатов подбора параметров форматирования.
Набор символов Отображает перечень входящих в состав шрифта наборов символов.
OK Применяет параметры шрифта к выделенному элементу отчета.
Отмена Отменяет все изменения шрифта и оставляет отчет в прежнем виде.
Окно диалога Создание панели инструментов
Позволяет задать имя новой панели инструментов.
Параметры окна диалога
Панель инструментов Допускается ввод имени новой панели или использование имени по умолчанию. Имя по умолчанию различно для каждой панели инструментов и имеет вид: Настраиваемая1, Настраиваемая2 и т. д.
Окно диалога Стек вызова
Отображает список активных вызовов процедур в режиме прерывания. При выполнении процедуры она помещается в список активных вызовов. Если из этой процедуры вызываются другие, все они также добавляются в список. Процедуры удаляются из списка когда управления возвращается вызвавшей их процедуре. В список также добавляются процедуры, вызываемые в окне проверки.
Параметры окна диалога
БазаДанных.Модуль.Процедура Отображает список процедур.
Показать Помещает место вставки в точку вызова процедуры и на полях устанавливает маркер вызова
Окно свойств
Чуть раньше мы уже познакомились с такими свойствами объектов, как BackColor, Width, Text. Количество свойств у каждого из объектов довольно большое. Многие из них мы можем менять в режиме работы [run] при помощи программы, как мы это уже делали (например, HScrollBar1.Width = 100). Оказывается, многие свойства формы и элементов управления можно менять и в режиме проектирования [design]. Делается это вручную, безо всякого программирования (для того и задумано, что вручную легче!).
Вы сейчас в режиме [design]? Хорошо. Пусть вы хотите просмотреть свойства кнопки Button1. Один щелчок по этой кнопке. При этом на кнопке появляются маркеры. Говорят, что объект выделен, стал активным. В этом случае его свойства вы можете видеть в окне свойств (окно Properties в правой части Рис. 3.3).
Рис. 3.3
Если окна не видно, проделайте View ® Properties Window, после чего снова щелкните по кнопке Button1.
У вас это окно может занимать несколько другое положение. Если оно кажется вам маловатым, попробуйте расширить его, ухватившись за левый или нижний края. Более подробно работа с окнами среды VS разобрана в 4.2.
В окне свойств – два столбца: название свойства и его значение. Для вашего удобства свойства могут быть упорядочены по алфавиту (закладка Alphabetic
Выберите упорядочение по алфавиту. Обратите внимание, что некоторые свойства помечены значком «+». Это сложные свойства, которые сами состоят из нескольких свойств. На Рис. 3.3 это, например, свойство Font (шрифт). Если вы щелкнете по значку «+», он превратится в «-», а свойства, из которого Font состоит, будут видны по-отдельности, каждое – в своей строке. На Рис. 3.3 вы видите, из чего состоят свойства Location (местоположение) и Size (размер). Так, в свойство Size входят два свойства: Width (ширина) и Height (высота).
Попробуем изменить значение свойства Width. Найдите в окне свойств его численное значение. Введите вместо имеющегося там числа другое число, например, 30. Вы увидите, что ширина кнопки на форме изменилась. Точно такого же результата вы добились бы в режиме работы [run], выполнив оператор Button1.Width = 30. А теперь поступим наоборот – перетащим немного влево или вправо один из маркеров кнопки. Мы увидим, что соответственно изменилось и число в окне свойств.
Выделим щелчком какой-нибудь другой объект на форме. Теперь в окне свойств – его свойства. Выделим форму, щелкнув по любому свободному месту ее поверхности – теперь мы видим и можем менять ее свойства. И так далее. Поэкспериментируйте.
С названиями и смыслом разных свойств я буду знакомить вас постепенно.
Значение многих (но не любых) свойств из окна свойств легко изменить в программе операторами типа Button1.Width = 30.
Оператор присваивания меняет значения переменных величин
Пока я не рассматривал программы, в которых переменные меняют свою величину. Теперь настало время такую программу рассмотреть:
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
Dim k As Integer
k = 10
Debug.WriteLine(k)
k = 25
Debug.WriteLine(k)
k = 4
Debug.WriteLine(k)
End Sub
В процессе работы программы содержимое ячейки k меняется. Так, при выполнении оператора k=25 там вместо значения 10 появляется 25. А куда же девается десятка? Она стирается, то есть компьютер забывает ее безвозвратно. Здесь действует общий принцип работы всех компьютеров:
Если в какую-нибудь ячейку или вообще в какое-нибудь место памяти или диска записывается новая информация, то старая информация, записанная там раньше, автоматически стирается, даже если она кому-то и нужна.
Раз теперь вместо 10 в ячейке k находится 25, то оператор Debug.WriteLine(k) печатает уже 25. (Слово «печатает» устарело, оно осталось от тех времен, когда мониторов еще не было, а вместо них были принтеры. Когда я по старинке говорю, что информация печатается, я подразумеваю, что она появляется на мониторе в том или ином окне.) Следующий оператор k=4 запишет на место 25 четверку, а Debug.WriteLine(k) ее напечатает. Проверьте.
Запишем схематически процесс изменения информации в ячейке k:
| ПОРЯДОК ИСПОЛНЕНИЯ ОПЕРАТОРОВ | ЧТО НАХОДИТСЯ В ЯЧЕЙКЕ ПАМЯТИ k | ЧТО ВИДИМ
В ОКНЕ Output | |||
| k=10 | 10 | ||||
| Debug.WriteLine(k) | 10 | 10 | |||
| k=25 | 25 | ||||
| Debug.WriteLine(k) | 25 | 25 | |||
| k=4 | 4 | ||||
| Debug.WriteLine(k) | 4 | 4 |
А что напечатает следующая программа?
Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
Dim f As Integer
f = 30
Debug.WriteLine(f)
f = f + 4
Debug.WriteLine(f)
End Sub
Оператор f=30 запишет в ячейку f число 30. Затем оператор Debug.WriteLine(f) напечатает 34. А что сделает странный оператор f=f+4 ? Не думайте, что это уравнение или что-нибудь в этом роде. Это оператор присваивания, а значит и выполнится он согласно определению оператора присваивания. Сначала VB вычислит правую часть f+4 , подставив туда вместо f его значение, взятое из ячейки, и получит 34. Затем число 34 будет записано в ячейку, отведенную под переменную, обозначенную в левой части, то есть опять же в ячейку f. При этом старое значение 30 будет стерто. Оператор Debug.WriteLine(f) напечатает 34.
Таким образом, оператор f=f+4
просто увеличивает число в ячейке f на четверку или, другими словами, увеличивает f на 4.
Зачем это нужно? Узнаете позже. Очень даже нужно. Операторы такого типа встречаются настолько часто, что для них даже придумали сокращенную запись. Потренируемся:
|
Оператор |
Сокращенная запись |
Действие |
|
a = a + 1 |
a += 1 |
Переменная увеличивается на 1 |
|
s = s - 25 |
s -= 25 |
Переменная уменьшается на 25 |
|
b = b * 2 |
b *= 2 |
Переменная увеличивается в 2 раза |
|
t = t / 3 |
t / = 3 |
Переменная уменьшается в 3 раза |
Определите без компьютера, что будет напечатано при выполнении следующих фрагментов программ:
a=100 : a=10*a+1 : Debug.WriteLine(a)
a=100 : a= -a : Debug.WriteLine(a)
a=10 : b=25 : a=b-a : b=a-b : Debug.WriteLine(a) : Debug.WriteLine(b)
Отличия Visual Studio NET от и от Visual StudioNET
Отличия практически отсутствуют и сводятся в основном к интерфейсу, поэтому данная книга является учебником по программированию на языке Visual Basic .NET как в среде Visual Studio .NET 2003, так и в среде Visual Studio .NET 2005, так и в среде Visual Studio .NET. Хотя конкретно изложение ведется для версии 2003.
Панели инструментов
Панели инструментов предназначены для быстрого и удобного доступа к инструментам VS той или иной специализации. На Рис. 4.28 вы видите две панели инструментов. Верхняя из них – стандартная, она всегда на экране, потому что нужна очень часто. Ее направленность – основные операции с проектами. Мы уже пользовались некоторыми ее кнопками. Задержите мышку на любом значке панели – и он назовет себя.
Рис. 4.28
Часто те же инструменты, что на панелях, имеются и в главном меню, но панели обеспечивают более быстрый доступ к инструментам. Познакомьтесь со всеми кнопками стандартной панели. Возможно, вам покажется, что пользоваться некоторыми из них удобнее, чем пунктами меню (один щелчок быстрее двух).
VS имеет привычку без спросу выводить на экран панели, которые по ее мнению вам могут в данный момент пригодиться, а затем убирать их с экрана, когда с ее точки зрения они вам больше не нужны. Вручную панели инструментов вызываются на экран так: View ® Toolbars ® щелчок по одному из пары десятков названий панелей. Те панели, что уже есть на экране, помечены галочкой. Убрать панели с экрана можно тем же способом, что и вызывали.
Выведите на экран панель Layout. Ее специализация – работа с элементами управления на форме. В 4.4.6 мы косвенно с ней уже познакомились. Скорее всего она покажется в верхней части окна VS рядом с другими панелями. На Рис. 4.28 вы видите ее под стандартной панелью инструментов. Если вы хотите сместить ее оттуда, ухватитесь мышкой за один из нескольких сереньких вертикальных отрезков, разделяющих инструменты на этой панели, и тащите.
После этого вы можете изменять форму панели. Делаете вы это примерно так же, как изменяете форму окон, ухватившись мышкой за их края. На Рис. 4.29 вы видите ту же панель Layout, которую мы уже переместили и которой изменили форму. Теперь ее можно закрывать и крестиком.
Рис. 4.29
Пока на форме не выделены элементы управления, кнопки на панели Layout будут бледными и неактивными, потому что им нечего делать. Выделите несколько элементов управления, кнопки оживут, с ними можно работать. А как – вы уже поняли из 4.4.6
Щелкнув по треугольной стрелочке рядом с крестиком в правом верхнем углу панели, вы сможете добавлять и убирать кнопки с панели. Там же вы можете создать собственную панель инструментов. Но уж в этом вы разберетесь сами, если понадобится.
Польза от остальных панелей инструментов вам станет ясна по мере дальнейшего изучения VB.
Передвигаем и настраиваем окна
Откройте какой-нибудь проект. Пусть он называется «Иерархия». Посмотрите на Рис. 4.8. Не беда, если картинка на вашем экране будет не очень похожа на рисунок.
Рис. 4.8
Группы окон. Сколько окон мы видим на рисунке? Попробуем посчитать.
Прежде всего это большое белое окно, на котором расположена форма. Это – окно конструктора форм. Над окном мы видим две закладки. Щелкнем по закладке Form1.vb и обнаружим, что на месте окна конструктора возникло окно кода. Щелкнем по закладке Form1.vb [Design] и обнаружим, что на месте окна кода снова возникло окно конструктора. Таким образом, два окна объединены в группу окон с закладками для быстрого переключения между окнами.
Справа мы видим еще две подобных группы, только размер у них небольшой и закладки расположены не над, а под окнами. Верхняя группа состоит из двух окон (закладки Solution Explorer и Class View). Нижняя – тоже из двух окон (закладки Properties и Dynamic Help). Пощелкайте по закладкам.
Снизу мы видим продолговатое окно Output. Без закладок. Но это тоже группа, только из одного окна, потому и без закладок.
Поставьте мышь на значок
Обратите внимание на значок
На самом деле окон в VS гораздо больше, чем мы видим на рисунке, только они не открыты.
Закрываем и открываем окна. Чтобы избавиться от ощущения тесноты на экране, давайте начнем с того, что закроем все окна, исключая (чтобы не запутаться) Toolbox и Server Explorer. У каждого окна есть в правом верхнем углу значок крестика «´». Будем щелкать по крестикам до тех пор, пока главное окно среды не опустеет (Рис. 4.9).
Рис. 4.9
Теперь можно нашу пустую квартиру заселять. Не думайте, что наш проект закрыт, он открыт, только не виден, закрыты окна, а не проект.
Команды на показ многих окон VS расположены в пункте View главного меню VS. Начинать нужно с открытия окна Solution Explorer. Наши действия: View ® Solution Explorer. На Рис. 4.10 вы видите среду VS после этого действия, а также открытое меню View, в котором открыто подменю Other Windows («Другие окна»).
Рис. 4.10
Щелкните по значку Form1 в окне Solution Explorer. Теперь выберите в меню View пункты Code (чтобы появилось окно кода), Designer (чтобы появилось окно конструктора форм) и Properties Window (чтобы появилось окно свойств), а в подменю Other Windows – окно Output. Ваша среда приобрела примерно такой вид, как на Рис. 4.11. Он отличается от Рис. 4.8 меньшим количеством закладок (так как уменьшилось число окон).
Рис. 4.11
Перемещаем окна. Теперь поучимся перемещать окна. Чтобы приблизить эксперимент к реальности, выберите в меню View окно Class View, а в меню Help – окно Dynamic Help. Среда приобрела прежний вид (у меня – как на Рис. 4.8, а у вас, возможно, другой). Надеюсь, что в правой части у вас найдется хотя бы одна группа окон с закладками. Если этого нет, то читайте дальше, вскоре вы поймете, как такую группу получить.
Группу окон можно таскать по экрану, ухватившись мышкой за заголовок. Исключение – центральная группа с окнами Code и Designer. На Рис. 4.12 я ухватился мышкой за заголовок одной из групп (закладки Solution Explorer и Class View) и перетащил ее в центр экрана, не отпуская мышиной кнопки. Виден контур положения окна, когда я отпущу кнопку мыши.
Рис. 4.12
На Рис. 4.13 я отпустил кнопку мыши.
Рис. 4.13
Вы видите, что группа окон (закладки Solution Explorer и Class View) оказалась в середине экрана, а группа окон (закладки Properties и Dynamic Help) шустро захватила место уехавшей группы. Это – отличительная черта VS. При запуске проекта, использовании системы помощи и во многих других случаях некоторые окна сами собой возникают, исчезают, меняют место Эта шустрость перемещения, возникновения и исчезновения окон поначалу приводит новичка в замешательство, и только потом привыкаешь и даже начинаешь ощущать удобство такого поведения. Поведение это направлено на то, чтобы в нужный момент на экране были только нужные окна, а остальные должны быть спрятаны.
Начните рискованное дело, а именно: повторяйте за мной все манипуляции с окнами, которые я проделываю. Для успешных манипуляций нужен опыт, а если у вас его нет, то через некоторое время ваша среда будет похожа на груду мусора. Однако не отчаивайтесь, упорство будет вознаграждено и через несколько абзацев вы станете спокойным и уверенным хозяином своей среды.
Прежде всего повторите за мной только что описанное перемещение группы. Готово? А теперь снова ухватитесь за заголовок той же группы и самым разнообразным образом потаскайте ее по экрану, не отпуская мышиной кнопки. При этом приближайте ее вплотную к краям главного окна VS, проводите ее по-разному над другими группами и окнами, совмещая курсор мыши с заголовками, закладками и границами других групп и окон. Вы увидите, что в зависимости от текущего положения заголовка относительно перечисленных объектов контур окна резко изменяет форму и положение, проявляя тенденцию «прилипать» к краям главного окна VS и к другим группам и окнам, «толкаться», смещая группы и окна по вертикали или горизонтали. Если вы совместите курсор мыши с заголовком или закладками другой группы, то контур примет такую форму, как на Рис. 4.14. Вы видите, что здесь контур занял всю группу Output, причем у контура имеется выступ внизу (будущая закладка). Это значит, что когда вы отпустите мышь, ваша группа присоединится к этой. В результате на этом месте образуется единая группа из 3 окон с 3 закладками.
Рис. 4.14
Отпустите мышь.
Аналогичным образом мы можем передвигать по экрану большинство групп и окон. Не стесняйтесь, перемещайте со всего размаху, пусть наступит хаос!
Настраиваем окна. А теперь посмотрим, как восстановить порядок. Закройте все окна, включая Toolbox и Server Explorer. Откройте окно Solution Explorer и пришвартуйте его к правому краю окна VS, как оно пришвартовано на Рис. 4.10. Щелкните правой клавишей мыши по заголовку окна Solution Explorer. Вы увидите контекстное меню для выбора состояния окна (см. Рис. 4.15).
Рис. 4.15
Поговорим о пунктах этого меню.
На рисунке вы видите, что в меню выбрано состояние Dockable («швартующийся»). Это значит, что окно (или группа) при перемещении по экрану будет стремиться пришвартоваться, прилипнуть куда ни попало, как я уже описывал чуть раньше. Попробуйте. Прилипшее окно называется привязанным.
Если вы выбрали состояние Floating, то окно прекратит свое сумасшедшее поведение и будет перемещаться по среде привычно и спокойно, не взаимодействуя с другими окнами, как ведут себя обычные окна Windows. Попробуйте. Такое окно называется плавающим.
Когда окно пришвартовано к любому из краев окна VS, в меню появляется пункт Auto Hide («автопрятки»). Если выбрать это состояние, то окно всякий раз, когда вы его не используете, будет уплывать за край окна VS, оставив у края свой значок с надписью, как это делает Toolbox. Когда окно снова вам нужно, вы просто ставите мышку на значок – окно выплывает. Это очень экономит место на экране. Попробуйте. Обратите внимание, что окно теперь нельзя утащить от края, пока не снимешь выделение пункта Auto Hide.
Так же ведет себя и группа окон. Для каждого окна из группы у края остается свой значок.
Пункт Auto Hide настолько популярен, что для него в заголовке окна есть специальный значок, по которому вы можете оперативно щелкать мышкой, устанавливая и снимая состояние Auto Hide. Когда значок имеет вид
Вот несколько полезных приемов работы с окнами:
Чтобы «вытащить» окно из группы, тащите его за закладку.
Чтобы присоединить окно к группе, перетащите его заголовок на заголовок группы или одну из закладок.
Чтобы присоединить окно к центральной группе (куда входят окна кода и конструктора форм) уберите у окна выделение как пункта Dockable, так и пункта Floating.
Чтобы «вытащить» это присоединенное окно из центральной группы, выделите у окна пункт Dockable или пункт Floating.
Окно кода и окно конструктора не движутся. И контекстное меню у них другое. Чтобы увидеть одновременно оба этих окна, выберите в контекстном меню New Horizontal Tab Group или New Vertical Tab Group. Чтобы вернуть все в прежнее положение, выберите в контекстном меню Move to Next Tab Group или Move to Previous Tab Group.
Пункт Hide просто прячет окно. Снова открывать его – через меню View.
Когда окна или группы граничат друг с другом (как окна Solution Explorer и Properties на Рис. 4.11), вы можете мышкой обычным образом смещать их границу. Для этого, не спеша перемещая мышь поперек границы, поймайте момент, когда курсор мыши поменяет свой вид на двойную стрелку, и после этого тащите мышь.
Минимум окон для работы. Каков минимум окон, которым можно для начала обходиться? Вот список:
Toolbox
Solution Explorer
Properties Window
Designer
Code
Output
Теперь, когда вы все это знаете, закройте все окна и по-одному открывайте нужные. Затем буксируйте их на желаемое место, пришвартовывайте к приглянувшемуся краю, выбирайте удобное состояние и присоединяйте к подходящей группе. Желаю успеха.
Переменные величины и память
Графиня отвела во дворце каждому гостю по комнате. Размер комнаты зависит от титула. Для нас дворец – это оперативная память, гости – переменные, а комнаты – так-называемые ячейки. Полностью механизм работы переменных величин не понять, если не узнать, как они хранятся в оперативной памяти компьютера.
Оперативная память нужна компьютеру для того, чтобы хранить во время выполнения программы саму эту программу и данные (в том числе переменные величины), с которыми программа работает. О работе памяти вы можете почитать. в Приложении 1.
При запуске проекта и позже компьютер под каждую переменную отводит в памяти место. Оно называется ячейкой. Во дворце размер комнат измеряют в квадратных метрах, в памяти размер ячейки выражают в байтах. Князю нужна более вместительная комната, чем барону. Переменной типа Double нужна более вместительная ячейка, чем переменной типа Integer. Так оно и есть на самом деле: под переменную типа Integer в памяти отводится ячейка размером 4 байта, а под переменную типа Double – 8 байтов. Только не думайте, что переменная типа Integer не может быть числом длиннее 4 цифр, а переменная типа Double не может быть числом длиннее 8 цифр. Компьютер использует для записи чисел в ячейки более компактную систему, чем для записи символов: в 1 байт умещаются две с лишним цифры числа.
Не думайте также, что «стенки» между ячейками в оперативной памяти физически стоят намертво, как стены между комнатами дворца. При выполнении каждого следующего проекта и даже в процессе выполнении одного и того же «дворец» перестраивается. Но нас не интересует физический уровень. Мы можем пока думать, что на всем протяжении «праздника» любая переменная спокойно живет в своей неизменной ячейке.
Перенос длинного оператора на следующую строку
Иногда оператор получается такой длинный, что не умещается на ширине окна кода, и чтобы его увидеть целиком, приходится прокручивать окно кода влево-вправо. Это неприятно, потому что прокручивать не хочется, а хочется видеть весь оператор на экране целиком. Часть оператора можно перенести на другую строку комбинацией пробела и подчеркивания. Например, вместо
Результат.Text = Val(Число1.Text) + Val(Число2.Text)
можно записать
Результат.Text = Val(Число1.Text) _
+ Val(Число2.Text)
или
Результат.Text = _
Val(Число1.Text) _
+ Val(Число2.Text)
Как видите, в конце строк в качестве знака переноса стоит пара символов: пробел и за ним знак подчеркивания.
Лично я для обозримости программы применяю еще одно средство – для окна кода выбираю шрифт Arial Narrow. Очень помогает, так как шрифт узенький и на ширину окна умещается много букв. Как это сделать, написано в 4.4.7.
VS предлагает еще одно средство: Edit ® Advanced ® Word Wrap. В этом случае код переносится на другую строку автоматически. Но мне это средство не нравится, так как нарушает привычную для глаз программиста систему отступов от левого края окна.
Перенос вашего проекта на другие компьютеры
Когда ваш проект, например, Калькулятор, заработает на вашем компьютере, вам захочется, чтобы он заработал и на компьютерах ваших друзей. В давние времена для решения этой проблемы достаточно было создать исполняемый файл вашего проекта (назовем его Калькулятор.exe) и скопировать его на компьютер вашего друга (где найти исполняемый файл, написано в 3.12.4). Теперь ситуация изменилась. У современных средств программирования гораздо более солидный и тяжелый подход к переносу программ с компьютера на компьютер. Не копировать, а инсталлировать – вот девиз! В причины отказа от легкой жизни я не буду особенно вдаваться, но основная такая – программа, написанная на VB, слишком зависит от Windows и других системных программ, а на разных компьютерах операционная система Windows и системные программы разные, поэтому копирования запускающего файла недостаточно, нужно как-то перенастраивать Windows и возможно инсталлировать какие-то системные программы. Все это входит в понятие инсталляции вашей программы на чужой компьютер.
Это не значит, что вы не можете попытаться безо всякой инсталляции просто скопировать исполняемый файл простенького проекта на другой компьютер с таким же системным программным обеспечением. Вполне возможно, что он и запустится.
Что такое инсталляция. Если вы когда-нибудь инсталлировали какую-нибудь игру на компьютер, то что такое инсталляция знаете. Вот вы купили компакт-диск с понравившейся игрой или программой (пусть это будет Microsoft Office). Во многих случаях купленная программа просто так не запустится, нужна установка или, по-другому, инсталляция (от английского install - устанавливать). Говорят, что на компакт-диске находится не сама программа Microsoft Office, а инсталляционный пакет программы Microsoft Office, то есть набор файлов, в который входят в сжатом виде и файлы Microsoft Office. Вы находите в инсталляционном пакете программу установки (ее запускающий файл чаще всего называется Setup.exe, хотя вполне могут быть и другие названия) и запускаете ее. Все ваши дальнейшие действия диктуются этой программой, которая еще называется мастером установки. Фактически вам приходится только отвечать на ее вопросы. Например, вы отвечаете на вопрос, в какую папку жесткого диска вы желаете установить Microsoft Office. Программа установки разворачивает сжатые файлы Microsoft Office и копирует их на жесткий диск вашего компьютера. Кроме этого она настраивает Windows на работу с Microsoft Office. После окончания установки вы сможете запускать Microsoft Office из стартового меню «Пуск» на панели задач Windows.
Во время установки игр вам, возможно, приходили в голову мысли о суперпрограммистах, которые мало того, что создают игру, они еще и создают программу установки и делают так, чтобы программа установки правильно установила игру на ваш компьютер. Сейчас я предлагаю вам стать таким «суперпрограммистом». Наша цель – через полчаса получить на жестком диске папку – инсталляционный пакет вашей программы, готовый к употреблению. После этого вы можете переписывать его на компакт-диск и дарить друзьям.
В качестве примера создадим инсталляционный пакет для нашего Калькулятора, созданного в 3.3. Если вы хотите создавать инсталляционный пакет для другого приложения – не беда, мое объяснение никак не зависит от устанавливаемого приложения.
Первые шаги – за ручку
Лучший способ познакомиться с VB – поскорее создать и запустить какой-нибудь проект. Пусть он будет маленький и никому, кроме нас, не нужный, но зато с ним мы пройдем все этапы работы с VB. Этим мы сейчас и займемся.
Садитесь за компьютер и приступим. Без компьютера этот раздел принесет вам мало пользы. Учиться Бейсику по книжке без компьютера – все равно, что учиться кататься на велосипеде по самоучителю без велосипеда. Все, что я говорю, вы отныне должны немедленно выполнять на компьютере. Это нужно и для тренировки и еще потому, что многое, кажущееся таким очевидным в тексте, становится странным и непонятным, когда нажмешь на клавиши. К тому же не забывайте, что автор – не Господь Бог и тоже может ошибиться. Компьютер же не ошибается и всегда поймает автора за руку.
Иногда я буду прямо говорить: «Нажмите такую-то клавишу» или «Сделайте на компьютере то-то и то-то». Но чаще я буду просто излагать материал, не повторяя по сто раз, что нужно проверять на компьютере каждое мое слово. Например, я говорю, что данная процедура по такой-то причине печатает число 36, и сразу же перехожу к другой теме. Стоп! Не надо спешить за мной. Сначала проверьте, действительно ли будет напечатано 36.
Напоминаю, что если у вас нет достаточного опыта работы на компьютере, к вашим услугам Приложение 2, где вы научитесь всему, что нужно, чтобы приступить к делу.
Первый этап – подготовка проекта
В коде вашего проекта могут встретиться операторы типа
Кл_деления.Image = Image.FromFile("D:\Фотографии\Earth.JPG")
или
Плеер.FileName = "D:\WINNT\Media\canyon.mid"
Эти операторы объединяет наличие в них адресов файлов. Это значит, что в режиме работы ваш проект может обращаться к графическим, звуковым и другим файлам, находящимся где-то далеко на диске. Вам никогда не приходило в голову, что будет, если кто-то, не подозревая, что эти файлы нужны вашей программе, сотрет их? Ничего хорошего не будет. А если вы к тому же предназначаете ваш проект для инсталляции на чужой компьютер, опасность и морока возрастают вдвойне.
Отсюда совет: Все такие файлы заранее скопируйте в папку BIN внутри папки вашего проекта, туда, где находится исполняемый файл вашего проекта. По принципу «Все мое ношу с собой». Так как после запуска проекта эта папка является текущей (см. 19.2.12), то также упростятся и адреса в приведенных выше операторах:
Кл_деления.Image = Image.FromFile("Earth.JPG")
Плеер.FileName = "canyon.mid"
Картинки, которые вы загрузили в объекты на этапе проектирования, не нуждаются во всех этих усилиях, так как они уже неявно сохранены в одном из файлов в папке проекта.
Рекомендую также с самого начала разработки проекта сохранять его не под предлагаемым именем WindowsApplication1, а под уникальным именем, например, Калькулятор.
Первый способ – опускаем названия пространств имен
В большинстве случаев VB позволяет выбросить из операторов название пространства имен. Попробуйте:
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
Interaction.Beep()
Debug.WriteLine(3 + 2)
End Sub
Все сошло нормально. Результат прежний – 5.
Пространство имен Microsoft.Visual Basic позволяет выкинуть даже имя объекта. Попробуйте:
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
Beep()
Debug.WriteLine(3 + 2)
End Sub
Получилось.
Но иногда название пространства имен выбросить не удается: VB возражает. Это значит, что объект с тем же именем есть и в других пространствах имен, и VB возражает потому, что не знает, какой именно из этих объектов вы имеете в виду. Если в компании два Кольки, то во избежание путаницы одного все зовут Колька с Полянки, а другого – Колька с Басманной.
Пишем программу
Давайте придумаем себе задачу для нашего проекта. Пусть на экране при нажатии кнопки или, скажем, при передвижении ползунка на полосе прокрутки что-нибудь происходит. Легко сказать – пусть! Для этого нужно знать, что вообще умеет делать VB при нажатии на кнопки или при передвижении ползунков. А если даже мы это знаем, то все равно не знаем, как это приказать, то есть как правильно написать программу. Ну что ж. Программирование мы будем изучать постепенно и постепенно всему научимся, а сейчас я выберу что-нибудь самое простое и подскажу, как это делается. К компьютеру не подходите, пока я не дам знак.
Придумали оператор. Забудем пока о «покраске формы» и прикажем компьютеру для начала при нажатии кнопки Button1 сделать ширину горизонтальной полосы прокрутки равной 100 пикселямH. Команда (оператор) для этого пишется так:
HScrollBar1.Width = 100
Разберемся, что здесь написано.
HScrollBar1 – это имя нашей горизонтальной полосы прокрутки (Его дал VB. О том, как узнавать имена объектов и изменять их, я скажу позже).
Width – переводится «ширина».
Смысл оператора очевиден: это приказ сделать ширину объекта HScrollBar1 равной 100.
Теперь о том, что обозначают точка и знак равенства. Пока правило такое:
Слева от точки мы записываем имя объекта, справа от точки – название его свойства, а справа от знака равенства – значение этого свойства. Точку нужно писать обязательно.
Вот аналогии:
Коля.рост = 140
Бразилия.климат = жаркий
Нина.фамилия = Рыбакова
В будущем мы увидим, что свойство само может быть объектом, а значит, у него тоже могут быть свои свойства. Вот аналогии:
Нина.фамилия.число букв = 8
Буратино.нос.длина = 30
Танк.двигатель.шестеренка.материал = сталь
Говорят: Свойству Width объекта HScrollBar1 присваивается значение 100.
Окно кода. Теперь поговорим о том, как нам сделать, чтобы компьютер выполнил этот оператор, причем именно при нажатии на кнопку Button1, а не в какой-либо другой момент. Снова садитесь за компьютер. Вы еще не стерли наш проект? Проверьте, находимся ли мы в режиме проектирования [design]. Сделайте двойной щелчок по кнопке Button1. Перед вами возникнет новое окно – окно программного кода или просто окно кода (Рис. 1.7).
Рис. 1.7
Будем называть кодом любой текст программы. В окно кода будем записывать весь код нашего проекта (а большие проекты могут использовать и несколько окон кода).
Если по какой-то причине окно кода вы потеряли из виду, то в главном меню окна VS выберите View ® Code.
Заготовка процедуры. Мы видим, что в окне кода уже что-то написано. Это написал сам VB. Ситуация, как в ресторане: мы еще ничего не заказали, а соль и перец уже на столе. Кроме этого, многое из написанного Бейсиком мы даже и не видим, да и знать нам этого невидимого пока не надо. Если вы человек опытный и вам любопытно увидеть этот невидимый код, щелкните по малюсенькому плюсику возле строки Windows Form Designer generated code, но не каждому затем удастся отыскать получившийся минусик и щелкнуть по нему, чтобы все вернулось к прежнему виду. Если вы все-таки попались и не знаете, как выбраться из ситуации, то или бросьте этот проект, или почитайте 6.1.3.
Остановимся пока на смысле двух видимых на рисунке строк.
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
Слово Sub обозначает «процедура». Слово Click означает «щелкнуть мышкой». На смысле остальных слов в строке пока не останавливаемся. Эту строку можно вольно перевести как «Что делать, если щелкнуть мышкой по кнопке Button1». А более точно так: «Заголовок процедуры, в которой компьютеру пишется инструкция, что делать, если человек мышкой нажмет на кнопку Button1».
Ниже оставлено свободное место и там уже мигает курсор, приглашая нас вводить туда какие нам угодно операторы. Они-то и будут выполнены при щелчке по кнопке.
Еще ниже находится строка End Sub, что означает «конец процедуры». Все пространство между этими двумя строками, которое мы будем заполнять операторами, будем называть телом процедуры.
Таким образом, мы видим перед собой не что иное, как заготовку процедуры, которая должна выполниться при щелчке по кнопке Button1. Услужливый VB догадался создать эту заготовку, когда мы дважды щелкнули по кнопке Button1.
Вам нужно ввести с клавиатуры на свободное место между этими двумя строками наш оператор
HScrollBar1.Width = 100
Если у вас нет опыта ввода текста в компьютер, то прервитесь и изучите Приложение 2. Вы не имеете права допустить ни малейшей ошибки в строке. Даже лишний пробел может быть ошибкой.
Вводим оператор. Начнем потихоньку вводить. Введите слово HScrollBar1 и точку, причем VB простит вас, если вы где-нибудь вместо заглавной буквы введете строчную или наоборот. Как только вы введете точку, VB (чтобы вам не утомлять свои персты вводом слова Width) развернет перед вами список всех уместных после точки слов. Вам останется только сделать двойной щелчок на нужном слове (Рис. 1.8) или выделить его и нажать на клавиатуре клавишу Tab.
Рис. 1.8
Если вам не хочется прокручивать этот список в поисках нужного слова, вы можете просто начать вводить это слово с клавиатуры сразу после точки, компьютер тогда сам прокрутит список и нужное слово найдет и выделит. Не ленитесь после этого все же нажать клавишу Tab, пусть даже слово и совсем почти вами дописано, потому что это обережет вас от возможных грамматических ошибок.
Но вот ввод оператора закончен. Уберите теперь текстовый курсор из строки, которую вводили. VB при этом проверит грамматическую правильность строки и немного подправит ее внешний вид, исходя из своих представлений об изяществе. Если он обнаружит ошибки, то ошибочные части строки подчеркнет. Если вы увидели, в чем ошибка, исправьте ее. Если не увидели, то читайте 1.3.8.
Теперь окно кода должно иметь такой вид:
Public Class Form1
Inherits System.Windows.Forms.Form
Windows Form Designer generated code
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
HScrollBar1.Width = 100
End Sub
End Class
Перед вами готовая процедура. Проверьте, не ввели ли вы нечаянно что-нибудь выше, ниже или правее этих строк. Если ввели, то сотрите.
Запускаем проект. Пришла пора снова запускать проект. Предположим, что ошибок в коде нет. Щелкните кнопку Start. На экране опять появляется знакомый вид работающей формы. Щелкните по кнопке Button1 – горизонтальная полоса прокрутки изменила свою ширину (Рис. 1.9).
Рис. 1.9
Поздравляю! Ваш первый проект заработал. Щелкните еще раз. Ничего не изменилось. Естественно. Завершим выполнение проекта.
Если у вас при запуске получилось не то, что нужно, или же VB выдал какое-то сообщение, прочтите чуть ниже подраздел 1.3.8.
Быстрое переключение между окнами кода и конструктора. Над окном кода вы видите закладки
Почему нельзя не объявлять переменные величины
Хозяйка бала присматривает, чтобы слуга объявлял всех гостей, пусть даже и без упоминания титула. VB присматривает, чтобы программист объявлял все переменные, пусть даже и без указания типа (этот присмотр называется Option Explicit). Поэтому, если вы попытаетесь обойтись без оператора Dim, VB выдаст сообщение об ошибке. Если же не выдает, значит Option Explicit выключен, в этом случае читайте 4.4.7.
В 5.2.2я показал, какая польза от указания типа в операторе Dim. А какая польза от оператора Dim без указания типа? Какая польза от ножен без сабли? Посмотрим. Однажды, давным-давно, я устал от необходимости тратить время на «ненужные» объявления. И настроил VB так, чтобы он перестал строго присматривать за объявлением переменных. После чего писал Dim «через раз». Некоторое время все шло хорошо, но потом на одном глупом фрагменте застопорилось. Вот этот фрагмент:
. x = 2
Debug.WriteLine(х)
Как по вашему, что он у меня напечатал? Если вы думаете, что 2, то ошибаетесь. Ничего не напечатал. Я подумал: Это наверно потому, что я не написал Dim. Я добавил Dim:
. Dim x = 2
Debug.WriteLine(х)
Не помогло. Опять ничего не печатает Как же так? – подумал я – Я ведь все сделал как положено. Мало ли, что у меня Option Explicit отключен? – Ведь Dim-то имеется! VB не нашел в программе никаких ошибок. Я долго не мог понять, в чем дело, пока не решил действовать по давно оправдавшему себя принципу: Если не можешь поймать ошибку, доведи все остальное до наивозможнейшего идеала, даже если это и кажется бессмысленным. «Бессмысленным» идеалом было включить Option Explicit, я и включил. И сразу VB подчеркнул во второй строке фрагмента имя х и сказал, что оно не объявлено. Как же «не объявлено»? – подумал я, но потом догадался, что в первой строке фрагмента присутствует латинская буква "икс", а во второй строке я нечаянно написал русскую букву "ха".
Итак, вы видите, что по нашей человеческой рассеянности многие переменные могут проскочить на бал необъявленными, хотя бы потому, что мы легко путаем латинские и русские буквы одинакового начертания. Выводы:
Никогда не отключайте Option Explicit.
Всегда объявляйте переменные величины.
При этом по возможности указывайте их тип.
Два варианта. Вы уже заметили, что переменную величину можно сначала объявить, а впоследствии присвоить ей значение:
Dim a As Integer
. . . .
a = 20
а можно сделать это и одним оператором:
Dim a As Integer = 20
Почему Visual Basic, а не C++?
Почему Visual Basic? Этот вопрос стоит перед новичками, которые не знают, с какого языка начать. Вот краткий обзор возможных вариантов.
Сейчас наиболее известны языки Бейсик, Паскаль, Си, Джава (Ява) До появления одноименных .NET-языков все они существовали и сейчас существуют в своих самых разных версиях. .NET-языки отличаются от своих тезок-предшественников, несмотря на то, что являются их прямыми потомками. Отличаются не столько внешним видом программ, сколько внутренним содержанием (использование механизмов .NET Framework). Особенно резко отличается Visual Basic .NET.
Что же касается различий, которые существовали между самими языками, то они в основном сохранились и в их .NET-версиях.
Рассмотрим, насколько тот или иной язык подходит для изучения начинающим программистом.
Начнем с Явы. Ява пока применяется в основном только в Интернете. Поскольку нас интересует все-таки и обычное программирование, Яву отодвигаем в сторону. Остаются Бейсик, Паскаль, Си.
Си – высокопрофессиональный язык, программы, написанные на нем, имеют превосходное быстродействие, в среде программистов Си распространен очень широко. Но он слишком сложен для восприятия новичком, программы на нем пишутся со значительным трудом и с него лучше не начинать. Если вам очень уж хочется программировать на Си, рекомендую начать с Бейсика. После него освоение Си пойдет гораздо легче.
По мнению профессионалов наиболее легок и прост из упомянутых языков как раз Бейсик. Профессиональные программисты любят его за то, что для создания на нем приличного продукта требуется гораздо меньше времени, чем, скажем, на Си. Поэтому популярность у него огромная. Конечно, за все приходится платить, и у Visual Basic есть свой недостаток – программы, написанные на нем, не такие быстрые, как на Си, однако новичок почувствует эту разницу очень не скоро.
Паскаль по простоте программирования и эффективности получающихся программ занимает промежуточное положение между Бейсиком и Си. Паскаль существует сейчас в виде его современной версии Object Pascal и программирование на нем ведется в среде Delphi. Но Паскаль не входит в состав Visual Studio .NET.
Сделать выбор я предоставляю читателю.
Почему Visual Basic NET, а не старый Visual Basic?
Почему надо изучать именно Visual Basic .NET, а не другую версию Visual Basic, например, последнюю из версий до-NETовской эпохи – Visual Basic 6.0?
Рассмотрим «За» и «Против»:
За: Потому что это самая последняя и мощная версия Visual Basic. Она предоставляет многие возможности, недоступные в предыдущих версиях.
За: Потому что это первая по-настоящему объектно-ориентированная версия Visual Basic. В этом она догоняет Delphi и C++.
За: Старый Visual Basic будет в ходу еще несколько лет, потом, наверное, уйдет.
Против: Visual Basic .NET сложнее старого Visual Basic. Поэтому новичку проще изучать старый.
Выбор за вами.
Вы спрашиваете, почему я написал книжку именно по Visual Basic .NET? – Потому что книжку по Visual Basic 6.0 я уже написал раньше. Вы можете найти ее на сайте www.learncomp.narod.ru.
Подстановочные знаки, используемые при сравнении строк
Встроенное сопоставление с шаблоном предоставляет гибкий инструмент для сравнения строк. В следующей таблице показаны подстановочные знаки, используемые с оператором Like, и наборы цифр или строки, которым они соответствуют.
Символ(ы) в шаблоне
Группа из одного или более символов (списокСимволов), заключенный в скобки ([ ]), служит для сопоставления с любым одиночным символом в выражении и может содержать практически все символы из набора символов ANSI, включая цифры. Особые символы - открывающая скобка ([ ), знак вопроса (?), знак номера (#) и звездочка (*) - могут использоваться непосредственно для сопоставления только когда заключены в скобки. Закрывающая скобка ( ]) внутри группы не может использоваться для этой цели, но может использоваться вне группы, как отдельный символ.
Помимо просто списка символов, заключенных в скобки, списокСимволов может задавать диапазон символов посредством дефиса (-), разделяющего нижнюю и верхнюю границы диапазона. Например, использование в шаблоне [А-Я] приведет к совпадению, если соответствующий символ в выражении содержит любую заглавную букву в диапазоне от А до Я. Несколько диапазонов включаются в скобки без всяких разделителей. Например, [а-яА-Я0-9] сопоставимо с любым буквенно-цифровым символом.
Ниже перечислены другие важные правила сопоставления с шаблоном:
Восклицательный знак (!) в начале спискаСимволов означает, что сопоставление выполняется, только если символ из выражения не входит в списокСимволов. При использовании вне скобок восклицательный знак сопоставляется только с собой.
Использование дефиса (-) для сопоставления с собой допускается либо в начале (после восклицательного знака, если таковой присутствует), либо в конце спискаСимволов. В любой другой позиции дефис служит для задания диапазона символов ANSI.
При указании диапазона символов границы следует задавать в порядке возрастания (А-Я или 0-100). [А-Я] является допустимым шаблоном, а [Я-А] - нет.
Символьная последовательность [ ] не принимается во внимание; полагается, что это строка нулевой длины ("").
Положение объекта на экране Система координат
Чтобы рисовать фигуры, чтобы помещать объекты в нужное место экрана или формы, чтобы при анимации двигать объекты в нужном направлении, вы должны уметь объяснить компьютеру, где, в каком месте экрана или формы вы хотите нарисовать фигуру или поместить объект. Научиться этому можно быстрее, имея представление о системе координат. Но если вы не знаете, что это такое, то вот вам вся суть без использования этого понятия.
В режиме проектирования выделите любой объект на форме, щелкните в окне свойств плюсик у его свойства Location (местоположение) и загляните в составляющие его свойства X и Y.
X – это расстояние левого края объекта от левого края формы.
Y – это расстояние верхнего края объекта от верхнего края формы.
Потаскайте любой объект по форме, следя за значениями X и Y. Добейтесь:
нуля в одном свойстве
нуля в другом свойстве
нуля в обоих свойствах
максимума в одном свойстве
максимума в другом свойстве
максимума в обоих свойствах
минуса в одном свойстве
минуса в другом свойстве
минуса в обоих свойствах
Теперь увеличьте как следует размер формы, поместите в произвольное место формы какую-нибудь кнопку и попробуйте угадать, чему равны ее свойства X и Y. А теперь проверьте в окне свойств – угадали или нет. Проделайте так несколько раз. Если ошибаетесь каждый раз не больше, чем на 200, значит, все в порядке, вы освоились.
Единицей измерения расстояния на экране в VB является пиксель. Одновременно пикселем называют самую маленькую возможную светящуюся точку на экране. Любое изображение на экране составляется из множества пикселей. О пикселе удобно думать, как о маленьком квадратике. Экран состоит из пикселей, как школьная тетрадь в клетку из клеточек (см. Рис. 3.11). Вы видите, что ширина буквы А на рисунке – 7 пикселей.
Рис. 3.11
Столбцы пикселей пронумерованы слева направо, а строки – сверху вниз. Пиксель – очень маленькая величина. Его размер зависит от разрешающей способности видеорежима. На рисунке режим – 640х480. На современных компьютерах с большими экранами режимы – 1280х960 и выше.
Подробнее об изображении на экране читайте в Приложении 1.
В пикселях выражаются значения свойств X, Y, а также Width (ширина объекта), Height (высота объекта) и других.
В режиме проектирования мы не можем таскать форму по экрану за заголовок, да это и не нужно. Как управлять местом ее появления на экране после запуска проекта, написано в 3.4.3. Если свойство StartPosition установлено в Manual, то мы делаем это, изменяя свойства X и Y. При этом измерение ведется относительно левого и верхнего краев экрана.
В режиме [run] положением объектов мы управляем так:
Button1.Left
= 200
Button1.Top
= 100
Здесь:
Left и Top – эквиваленты свойств X и Y .
Система координат
В школе вы привыкли к такой системе координат, как на Рис. 3.12.
Рис. 3.12
На экране компьютера, как вы догадались, применяется такая, как на Рис. 3.13.
Рис. 3.13
Как видите, ось у направлена вниз. Это не очень привычно. Если вас это раздражает, то в 12.8 вы можете запрограммировать в своем проекте возврат к привычной системе. Однако, редко кто пользуется этой возможностью, поэтому и вам будет полезно привыкнуть к общепринятой компьютерной системе координат.
Для объектов на форме начало компьютерной системы координат находится в верхнем левом углу формы. Для формы начало компьютерной системы координат находится в левом верхнем углу экрана.
Похвальное дело снабжения нашего калькулятора различными трюками я вывожу в задание для самостоятельной работы:
Задание 3.
«Нервная клавиша». Пусть при нажатии на клавишу вычитания эта клавиша прыгает куда-нибудь совсем в другое место калькулятора и на ней вместо минуса появляется текст типа "Я устала вычитать" или "Не трогай меня – я нервная!". Предусмотрите также значительное увеличение ширины клавиши, а то текст на ней не поместится. Когда это у вас получится, сделайте так, чтобы при нажатии на клавишу СБРОС клавиша вычитания скромно возвращалась на место и принимала свой прежний вид. Не пытайтесь программировать изменение размера шрифта: вы этого еще не умеете.
Помещаем фото на объекты
Пусть мы хотим, чтобы поверхность формы была покрыта каким-нибудь графическим изображением, например, фотографией. Для этого необходимо, чтобы файл с этой фотографией уже хранился на каком-нибудь диске вашего компьютера. Если фото нет, то сойдет и рисунок, созданный вами в каком-нибудь графическом редакторе, например, в Paint. В крайнем случае найдете что-нибудь по адресу
Program Files\Microsoft Visual Studio .NET\Common7\Graphics\bitmaps
или в папке Windows отыщете обои рабочего стола.
Создайте копию папки вашего проекта и экспериментируйте уже на ней. Выделите форму. Найдите свойство BackgroundImage (изображение на заднем плане). Затем щелкните по троеточию. В открывшемся окне доберитесь до нужного вам графического файла. Щелкните по Open – в результате фото окажется на форме.
Рис. 3.14
Если форма больше фотографии, то фотография укладывается на ее поверхности мозаикой.
Графическое изображение можно поместить на кнопку, на метку и на некоторые другие объекты. Для этого вы аналогичным образом используете их свойства Image (изображение) или BackgroundImage. На Рис. 3.14 вы видите графические изображения на форме, на левой кнопке и на метке.
Свойство ImageAlign выравнивает графику на поверхности объекта подобно тому, как свойство TextAlign (см. 3.4.1) выравнивает текст.
То же, но в коде. Фотографии на объекты можно помещать и в коде. Например, оператор
Кл_деления.Image = Image.FromFile("D:\Фотографии\Earth.JPG")
поместит на клавишу деления картинку, адрес файла которой указан в кавычках. Вы можете поместить этот оператор внутрь процедуры деления и тогда при нажатии на клавишу деления она приобретет картинку. Подробно об этом рассказано в 12.3.1.
«Прозрачный» цвет. Выделите кнопку или метку. Зайдите в свойство BackColor, там – в закладку Web и установите значение Transparent («прозрачный» цвет). На Рис. 3.15 вы видите «прозрачный» цвет установленным у всех кнопок и меток. Если же у элемента управления имеется картинка, то картинка эта, естественно, не прозрачна, что мы и видим на клавише сложения и метке результата.
Рис. 3.15
Слово «прозрачный» я взял в кавычки, потому что прозрачность работает только на фоне изображения заднего плана формы. Так, например, другие элементы управления через «прозрачный» цвет не видны. На Рис. 3.16 вы видите растянутую «прозрачную» кнопку вычитания, через которую совершенно не видны другие кнопки и текстовое поле. Получается, что вместо того, чтобы обеспечивать настоящую прозрачность элемента управления, VB просто переносит на него задний план формы.
Рис. 3.16
Для размещения графики в VB предусмотрен также специальный элемент управления PictureBox. О нем поговорим в 12.3.1.
Более подробно об использовании картинок рассказано в 12.3.
Понятие о переменных величинах Оператор присваивания
Понятие переменной величины вам известно из школьной математики. Пусть несколько лет назад ваш рост равнялся 130 см. Обозначим этот факт так: r=130. Теперь он равен 160 см, то есть r=160. Получается, что величина r изменилась. Поэтому она называется переменной величиной. Числа 130 и 160 называются значениями
переменной величины r.
Любой язык программирования умеет обращаться с переменными величинами. Без них он был бы очень слаб и смог бы извлечь из компьютера только возможности калькулятора. Точно так же алгебра без переменной величины превратилась бы в арифметику. Однако, преимущества применения переменных величин в компьютере нам откроются позже, а пока наша задача – к ним привыкнуть.
Понятие об операторе присваивания
Что же мы можем делать с переменными величинами, программируя на VB? Прежде всего, мы можем задавать компьютеру значение той или иной переменной величины. Это мы можем сделать при помощи оператора, который называется оператором присваивания. Так, если мы хотим сказать, что а имеет значение 6, то должны просто написать в окне кода а=6. Запись а=6 и называется оператором присваивания. Говорят, что величине а присваивается значение 6. С момента выполнения оператора а=6 компьютер будет помнить, что а равно шести. Не надо пока проверять это на компьютере, я скажу, когда надо за него садиться.
Примечание: В старых версиях Бейсика оператор присваивания для понятности записывали так – Let a = 6, что означало "Пусть a = 6".
Мы широко пользовались оператором присваивания в части I. Например, в операторе
Button2.BackColor = Color.Red
мы присваивали свойству "цвет" нашей кнопки значение "красный". Пока, чтобы не рассеивалось внимание, мы в операторе присваивания не часто будем касаться объектов, их свойств и значений. Ограничимся в основном переменными величинами, имеющими численные значения.
После выполнения следующего фрагмента программы
a = 2 * 3 + 4
b = a
y = a + b + 1
компьютер будет знать, что a равно 10, b равно 10, y равно 21. Проверьте в уме.
Получается, что при помощи оператора присваивания вы можете и вычислять тоже. Мы видим, что справа от знака равенства в операторе присваивания можно писать не только числа, но и переменные величины, и выражения. Выражения в VB могут быть разных типов, но об этом мы будем говорить позже. Пока под выражением будем понимать арифметическое выражение, то есть такое, к которому вы привыкли в школьной математике. Здесь мы видим три выражения: 2*3+4, a, a+b+1. Любое арифметическое выражение имеет численное значение.
Теперь чуть-чуть о свойствах объектов. Выражение может включать в себя не только переменные величины, но и свойства объектов, имеющие подходящее значение. Например,
y = a + b + Button1.Width
Пусть a равно 1, b равно 1, а ширина кнопки равна 100. Тогда y станет равным 102.
В левой части оператора присваивания также может стоять не только переменная, но и свойство объекта. Например,
Button1.Width = a + b + d
Действие последнего оператора вы сразу увидите на экране. Пусть a равно 100, b равно 100 и d равно 100. Тогда ширина кнопки станет равной 300.
Еще пара примеров:
|
ФРАГМЕНТ ПРОГРАММЫ |
ЧТО ЗАПОМНИТ КОМПЬЮТЕР |
|
v = -2+10 : h = 10*v : s = v+h+0.01 |
v 8 h 80 s 88.01 |
|
t = 0 : n = 2*t+40 : z = -n |
t 0 n 40 z -40 |
Определите устно, какое значение будет присвоено переменной t после выполнения фрагмента:
k = 1 + 2 : s = 2 * k : t = 6 – s
Порядок работы над проектом в VB
Просуммируем наш опыт создания проекта. Это нужно сделать для того, чтобы написать для себя незыблемые правила создания всех будущих проектов. Я, например, до сих пор им следую. Да и все следуют. Эти правила немного напоминают описание жизни Сизифа, с той разницей, что в основном камень на вершину мы все-таки доставляем!
Вот эти правила:
(1) Откройте проект.
(2) Поработайте немного над проектом в режиме проектирования, то есть разместите на форме несколько элементов управления или запишите в окно кода одну-две строки программы.
(3) Сохраните проект
(4) Запустите проект на выполнение. Если результаты вас удовлетворяют, перейдите к пункту 2
(5) Исправьте ошибки в проекте. Вернитесь к пункту 3
На моей практике преподавания программирования я ни разу не встречался с теми, кто пренебрегает пунктами 1 и 4. Но очень часто встречались те, кто пренебрегает пунктами 3 и 5 и неправильно выполняет пункт 2.
Как их наказывала жизнь? Достаточно сурово. Те, кто пренебрегал пунктом 3, часто терял свои проекты. Те, кто пренебрегал пунктом 5 и шел вперед, отложив исправление смысловых ошибок на потом, наконец запутывался в огромном числе накопленных ошибок. Те, кто старался на 2 пункте ввести сразу весь код, а не маленькую часть его, в 9 случаях из 10 получал неправильные результаты и не мог понять, где искать ошибку, так как код большой.
Порядок создания простого вычислительного проекта
Всем известна поговорка «Порядок бьет класс». Это наглядно доказала сборная Греции на чемпионате Европы по футболу в 2004 году. Эта поговорка верна и в программировании. Даже неопытный новичок, если он будет соблюдать надлежащий порядок создания проекта, добьется успеха.
Все, что здесь сказано, справедливо не только для вычислительных, но и для всех других проектов. Рассмотрение будем вести на примере.
Задача: Даны размеры спичечной коробки. Вычислить площадь основания коробки, ее объем и полную площадь поверхности.
Порядок создания проекта:
1. Программист сам должен знать решение задачи. Ведь программа – это инструкция по ее решению. Нельзя давать инструкцию, не зная, как решать. Имейте в виду, что сам компьютер абсолютно ничего не знает и все ему приходится растолковывать.
В нашем случае программист должен знать формулы для вычисления всего, что нужно:
площадь основания = ширина х толщину
объем = площадь основания х высоту
периметр основания = две ширины + две толщины
площадь боковой поверхности = периметр основания х высоту
полная площадь поверхности = две площади основания + площадь боковой поверхности
Как видите, я для стройности вычислений ввел периметр основания и площадь боковой поверхности.
Решение задачи должно быть известно программисту абсолютно четко, абсолютно точно, абсолютно правильно. Малейшая нечеткость, неточность или неправильность приведет к неверным результатам. Вы, возможно, не знаете, что профессиональный программист, получив серьезную задачу, не бросается сразу за компьютер, а сначала долгие дни, недели и даже месяцы, обложившись книжками, решает задачу «в уме» или на бумаге.
2. Нужно придумать имена переменным. Имя переменной должно говорить о ее смысле. Если смыслом является ширина коробки, то не ленитесь и не называйте ее а, потому что через полгода, разбираясь в своей полузабытой программе, вы будете долго тереть лоб и думать – Что, черт возьми, я обозначил через а? Называйте ее Ширина (если вы не знаете английского) или, к примеру, Width (если знаете). Так делают все профессиональные программисты (а все они, как известно – отъявленные лентяи и терпеть не могут трудиться зря J), значит, зачем-то это им нужно?
Удовлетворимся такими именами:
Ширина - ширина
Толщина - толщина
Высота - высота
S_основ - площадь основания
V - объем
Периметр - периметр основания
S_бок - площадь боковой поверхности
S_полн - полная площадь поверхности
3. Нужно определить, какого типа будут переменные.
Поскольку нам заранее неизвестно, будут ли исходные данные целыми, объявляем все переменные – Double. Первые строки программы будут такими:
'Программа вычисления площади основания, объема и полной площади поверхности
'спичечной коробки по известным ее размерам
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
'Объявляем переменные величины
Dim Ширина As Double 'ширина коробки
Dim Толщина As Double 'толщина
Dim Высота As Double 'высота
Dim S_основ As Double 'площадь основания
Dim V As Double 'объем
Dim Периметр As Double 'периметр основания
Dim S_бок As Double 'площадь боковой поверхности
Dim S_полн As Double 'полная площадь поверхности
Создайте проект с кнопкой. Введите эти строки. Не забудьте End Sub. Запустите проект. Ничего, что до результатов еще далеко! Ошибок VB не выдал? Значит, пока все в порядке. Не забывайте, что после ввода очередных 2-3 строк проект нужно запускать и его работу проверять.
4. Перед вычислениями нужно задать исходные данные решения задачи. Для этого нужно придумать, каким способом пользователь будет задавать размеры коробки – при помощи текстовых полей, функции InputBox или как-то по-другому. Выберем InputBox.
Вот следующие строки программы:
'Ввод исходных данных
Ширина = InputBox("Введите ширину коробки")
Толщина = InputBox("Введите толщину коробки")
Высота = InputBox("Введите высоту коробки")
5. Теперь нужно задать компьютеру действия, которые он должен проделать с исходными данными, чтобы получить результат.
'Вычисление результатов
S_основ = Ширина * Толщина
V = S_основ * Высота
Периметр = 2 * Ширина + 2 * Толщина
S_бок = Периметр * Высота
S_полн = 2 * S_основ + S_бок
Не забывайте, что порядок записи операторов бывает критически важен. Так, например, нельзя поменять местами две последние строки фрагмента.
6. После получения результатов их нужно показать человеку. Действительно, все операторы присваивания компьютер выполняет «в уме». После их выполнения в ячейках памяти будут находиться числовые результаты решения задачи. Чтобы их увидеть, человек может использовать текстовые поля, как это мы только что делали, улучшая калькулятор. Я же использую знакомый нам Debug.WriteLine, но с нововведениями:
'Отображение результатов
Debug.WriteLine ("Площадь основания = " & S_основ)
Debug.WriteLine ("Объем = " & V)
Debug.WriteLine ("Полная площадь поверхности = " & S_полн)
End Sub
Обратите внимание, что здесь в первом операторе Debug.WriteLine – два элемента вывода, разделенные символом &: текстовое пояснение "Площадь основания = " и собственно переменная, значение которой мы хотим увидеть – S_основ. То же самое и в других операторах Debug.WriteLine.
7. Запустите проект и убедитесь в его работоспособности. Введите в качестве размеров коробки числа 4, 2, 5. Вот результаты:
Площадь основания = 8
Объем = 40
Полная площадь поверхности = 76
Попробуйте ввести дробные числа и проверьте результат.
Вы спросите – зачем было так долго трудиться для решения такой простой задачи? Действительно, для простых исходных данных эту задачу быстрее решить даже в уме. Однако, соблюдение приведенного мной порядка составления программы облегчит вам в дальнейшем программирование реальных задач для компьютера. Напомню: начинаем со ввода исходных данных, затем преобразовываем их в переменные величины, затем, обрабатывая переменные величины, получаем результат, затем преобразовываем результат из переменных величин в нечто видимое. Этот порядок общепринят.
Варианты вывода результатов. Результаты можно выводить и в текстовое поле, и в метку, и в MsgBox. Вот примеры:
TextBox1.Text = "Площадь основания = " & S_основ
Label1.Text = "Объем = " & V
MsgBox("Полная площадь поверхности = " & S_полн)
Сравните с выводом тех же результатов при помощи Debug.WriteLine. Вы видите, что вывод совершенно аналогичен.
А вот те же результаты, но отформатированные, причем одинаково:
TextBox1.Text = "Площадь основания = " & Format(S_основ, "0.###")
Label1.Text = "Объем = " & Format(V, "0.###")
MsgBox("Полная площадь поверхности = " & Format(S_полн, "0.###"))
Задание 11.
Автомобиль 3 часа ехал со скоростью 80 км/час и 2 часа со скоростью 90 км/час. Вычислить среднюю скорость автомобиля (она равна суммарному пути, деленному на суммарное время). Значения переменным задать операторами присваивания, результат напечатать оператором Debug.WriteLine с 3 знаками после запятой.
Задание 12.
В самом углу прямоугольного двора стоит прямоугольный дом. Подсчитать площадь дома, свободную площадь двора и длину забора. Примечание: в углу, где дом, забора, естественно, нет. Размеры дома и двора вводим при помощи InputBox, результаты с пояснениями отображаем в текстовых полях и метке. Все числа целые.
В Задание 18 вы начертите чертеж двора и дома.
Задание 13.
Вычислить длину окружности и площадь круга. Радиус окружности задать в операторе Dim. Результаты с 5 знаками после запятой и с пояснениями выводить в два MsgBox.
Префиксы
Как по вашему, почему мы написали
Dim Чис1 As Double
Dim Чис2 As Double
Dim Рез As Double
а не
Dim Число1 As Double
Dim Число2 As Double
Dim Результат As Double
Потому что имена Число1, Число2 и Результат уже имеют текстовые поля, а называть одинаковыми именами разные объекты – значит заставлять спутаться и себя и компьютер. И все же имена Чис1, Чис2 и Рез придуманы не очень удачно, так как по ним не очень даже догадаешься, какие слова они сокращают: может быть, «чистка» и «резинка»?
В практике программирования сплошь и рядом встречаются ситуации, когда одинаковыми именами хочется назвать разные объекты. В таких случаях некоторые профессиональные программисты начинают каждое имя с так называемого префикса, который говорит программисту (не компьютеру!) о том, кому принадлежит имя (кнопке (префикс btn), строковой переменной (префикс str) или кому-нибудь другому).
В нашем случае можно было бы назвать текстовые поля так:
txtЧисло1, txtЧисло2, txtРезультат,
а переменные так:
dblЧисло1, dblЧисло2, dblРезультат.
А теперь о чувстве меры. Некоторые имена, будь то имя переменной, формы или другого элемента, в программах используются очень часто. Например, так называемую переменную цикла, которую мы с вами еще будем проходить, принято именовать буквой i. Если таким переменным давать «по науке» длинные имена с префиксами, то текст вашей программы будет очень громоздким. Поэтому никто на вас не обидится, если вы вместо
intПеременная_цикла = intПеременная_цикла + 1
y(intПеременная_цикла) = 2 * a(intПеременная_цикла)
напишете просто
i = i + 1
y(i) = 2 * a(i)
Существует более-менее общепринятое соглашение о том, какие объекты и какие типы какими префиксами обозначать. Сам я префиксы не люблю и употребляю их редко.
Преобразование типов
Трудности. Итак, мы видим, что когда дело касается типов, VB проявляет некоторую придирчивость. Например, как мы только что видели, он не разрешает литералам без специальных символов иметь любой тип. Или требует, чтобы результат сложения, вычитания или умножения чисел определенного целочисленного типа умещался в этот же тип. Например, после запуска процедуры
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
Dim a As Byte = 200
Dim b As Byte = 100
Debug.WriteLine(a - b)
Debug.WriteLine(a + b)
End Sub
будет выдана ошибка переполнения, так как 200+100 больше 255 – предельного значения для типа Byte.
Вы столкнетесь также с придирчивыми функциями, требующими себе аргументов определенного типа и жалующимися, если они имеют другой тип.
Во всех этих случаях перед вами встанет вопрос: уступать требованиям VB или не уступать. Казалось бы: чего проще! – уступи и дело с концом. Например, я советовал для предотвращения переполнения объявлять все переменные, участвующие в вычислениях, самым вместительным типом из тех, что могут понадобиться для результатов вычислений. И это хороший совет.
Еще один совет: если ничего не помогает, откажитесь от объявления типа у переменных, являющихся причиной придирок, смирившись с отрицательными последствиями неопределенности типа. То есть просто пишите Dim a.
И с придирчивой функцией тоже нетрудно согласиться и объявить переменную так, как она требует.
Но не всегда эти уступки бывают программисту удобны. Мы еще столкнемся с конкретными случаями такого неудобства. И поэтому сейчас я покажу вам, как сделать так, чтобы и волки были сыты, и овцы целы.
Функции преобразования типов. Существуют специальные функции, назначение которых – преобразовывать свой аргумент к определенному типу. Например, функция CInt преобразовывает свой аргумент к типу Integer. Поэтому оператор
Debug.WriteLine(CInt(2.4 + 10))
напечатает 12, а не 12,4.
Пусть в предыдущем примере про 200+ 100 мы не хотим менять тип переменных Byte на более вместительный Short. Как же тогда избавиться от переполнения? Применить CShort – функцию преобразования своего аргумента в тип Short. Вот так:
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
Dim a As Byte = 200
Dim b As Byte = 100
Debug.WriteLine(a - b)
Debug.WriteLine(CShort(a) + CShort(b))
End Sub
Здесь функция CShort преобразует перед сложением значения переменных a и b из типа Byte в тип Short. Не переменные, а их значения, и не везде, а только в данном месте. Сами переменные как были, так и остались типа Byte, и их значения в других местах программы (там, где вычитание) тоже остались типа Byte.
Преобразование состоялось и сложение поэтому выполнялось над числами типа Short и результат (300) обязан был умещаться именно в этот тип, куда он свободно и уместился.
Вот таблица функций преобразования типов, куда я для справки включил и функции преобразования в нечисловые типы:
|
Функция |
Преобразует в тип |
|
CByte |
Byte |
|
CShort |
Short |
|
CInt |
Integer |
|
CLng |
Long |
|
CSng |
Single |
|
CDbl |
Double |
|
CDec |
Decimal |
|
CChar |
Char |
|
CStr |
String |
|
CBool |
Boolean |
|
CDate |
Date |
|
CObj |
Object |
Вообще,
выполняя арифметические действия над числами разных типов, VB преобразует их к единому типу, который вмещал бы типы обоих чисел, после чего присматривает, чтобы результат тоже умещался в этом типе.
Вот список числовых типов в порядке возрастания вместительности:
Byte, Short, Integer, Long, Single, Double, Decimal
Пример: при выполнении фрагмента
Dim a As Short = 32700
Dim b As Byte = 100
Debug.WriteLine(a + b)
VB преобразует число 100 в тип Short, а затем выдаст переполнение, так как результат сложения не умещается в тип Short.
При делении целочисленных типов VB преобразует делимое и делитель в основном к типу Double и результат получается тоже типа Double.
Например, при делении 2 на 3 VB видит, что результат не получится целым, поэтому он сначала преобразует оба целых числа в тип Double и результат получает того же типа.
Существуют определенные правила неявного преобразования типов, в которые мы не будем подробно вдаваться.
Тип арифметического выражения. Пусть VB вычисляет выражение a+b*c. Спрашивается, какой тип будет у вычисленного выражения? Рассуждаем по цепочке. Сначала VB выполняет умножение b*c и тип произведения определяет по только что приведенному правилу. Затем, имея уже произведение и зная его тип, VB прибавляет его к a, определяя тип суммы опять по тому же правилу.
Так, по цепочке выполняемых действий, VB определяет тип любого самого длинного выражения.
При объявлении нужно указывать тип
Попытаемся вернуть нашей программе способность вычислять периметр:
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
Dim a, b, S, p
a = InputBox("Введите длину прямоугольника")
b = InputBox("Введите ширину прямоугольника")
S = a * b 'Площадь
p = a + a + b + b 'Периметр
Debug.WriteLine(S)
Debug.WriteLine(p)
End Sub
Запустите проект. Введите длину 3 и ширину 2. Вы получите неожиданный результат:
6
3322
Площадь равна 6. Правильно. А вот периметр должен бы равняться 10, а не 3322. Откуда взялись эти 3322? Да ведь это не что иное, как две тройки и две двойки! И получились они из a+a+b+b.
Здесь тот же случай, что и с калькулятором (см. 3.3). Там было то же самое, пока мы не применили Val. Почему так получается?
Первое: VB считает содержимое текстового поля в окне InputBox (точно так же, как и обычного текстового поля) текстом, а не числом, если даже оно состоит из цифр. А раз так, то и значения переменных a и b, взятые из текстового поля, он тоже считает текстом, а не числами. Не пей из копытца – козленочком станешь!
Второе: VB знает, что по правилам языка знак + имеет несколько смыслов в зависимости от того, к чему он применяется. В частности, при работе с числами это приказ складывать, а вот при работе с текстом это не приказ складывать, а приказ выстраивать в цепочку. А раз так, то и результат получился тот, что мы видели.
Почему же тогда площадь вычислилась нормально? Потому что там было не сложение, а умножение. VB знает, что по правилам языка знак умножения * не имеет смысла при работе с текстом. Значит (догадывается умный и услужливый VB) мой господин-человек не хочет, чтобы переменные a и b имели текстовое значение, иначе он не стал бы применять знак умножения, ведь мой хозяин умный. Значит иметь им числовое значение! Проверьте: подсуньте компьютеру вместо чисел буквы – VB запротестует при вычислении площади.
При вычислении площади VB догадался правильно, а при вычислении периметра ума не хватило. Ну что? – теперь везде при сложении применять Val? Не хочется, программы будут получаться громоздкими. Да и разве все дело только в сложении? Как узнаешь, где в следующий раз соломки подстелить?
Так вот: чтобы не перенапрягать умственные способности VB и предохранить себя от неприятностей, нужно при объявлении переменных величин указывать их так называемый тип (на балу – титул!).
Что это такое? Сделаем небольшое добавление к оператору Dim. В остальном оставим процедуру неизменной. Вот что у нас получится (добавление я выделил полужирным шрифтом):
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
Dim a, b, S, p As Integer
a = InputBox("Введите длину прямоугольника")
b = InputBox("Введите ширину прямоугольника")
S = a * b 'Площадь
p = a + a + b + b 'Периметр
Debug.WriteLine(S)
Debug.WriteLine(p)
End Sub
Оператор объявления
|
Dim |
a, b, S, p |
As |
Integer |
|
Объявляю переменные величины |
a, b, S, p |
как |
целые числа |
Операторы объявления будем пока писать в окне кода только внутри процедур, в их начале. Подробнее о местах, где можно делать объявления и о способах, написано в 21.9, но вам пока рано это знать.
Запустите проект. Проверьте его работу. Теперь все работает нормально.
Примеры и задачи
При создании книги очень важно было решить – какие выбрать примеры, на основе которых строить изложение материала. Здесь действует суровое правило: плохие примеры – плохая книжка, хорошие примеры – хорошая книжка, скучные примеры – скучная книжка, интересные примеры – интересная книжка.
Все примеры, разобранные в этой книжке, дают солидные, прочные знания, годные и для школьника, и для студента. Но примерно одну треть из этих примеров я постарался сделать занимательными. Вот некоторые из них:
Примеры задач на программирование, решенные в книге:
Игра «Автогонки», где вы управляете простеньким автомобилем
Игра «Ловец», где вы должны ловить множество движущихся шариков
Игра «Угадай число»
Задача: Как поставить пароль на свою программу, чтобы никто, кроме вас, не мог ее запустить
Задача: Как запрограммировать сохранение в играх
Задача: Как в Интернете зайти в чужой компьютер (предварительно постучавшись)
Задача: Как в Интернете поместить на свою страничку игру
Собственный калькулятор (при желании – с вашей фотографией, музыкой, прыгающими кнопками и прочими шутками)
Собственный будильник-секундомер
Собственный плеер для воспроизведения музыки и видео.
Собственный мультфильм
Собственный графический редактор
Рисование разнообразных рисунков и узоров (круги на воде, звездное небо, мыльные пузыри, компакт-диск, башня, ковер и тому подобное)
Размещение в приложениях Windows меню, кнопок и других элементов управления
Зашифровка и расшифровка секретных файлов (объяснена простейшая шифровка и расшифровка)
«Осмысленный» диалог с компьютером
Определитель быстроты реакции вашей и ваших друзей
Программа, определяющая, «экстрасенс ли вы»
Примеры задач, предлагаемых для самостоятельного решения:
Изготовление собственного компакт-диска с любимыми песнями
Игра-стрелялка «Торпедная атака»
Игра в крестики-нолики на бесконечном поле (пять в линию)
Игра в морской бой
Игра «Танковый бой» на неподвижном поле (вид сверху), где одновременно движутся и стреляют маленькие фигурки ваших и вражеских танков
Если вы энтузиаст программирования игр, то я должен вам сказать о том, какие игры будет НЕ под силу создавать начинающему программисту после изучения только моей книги. Прежде всего это трехмерные (3D) игры типа Quake или Unreal. Учтите, что эти игры создают не новички, а профессиональные программисты, и не в одиночку, а целыми фирмами. И используют они для этого специальные программные средства (например, библиотеку Direct X), разобраться в которых можно, только съев пуд соли в геометрии и программировании. Изучение конкретного языка программирования – это всего лишь первая ступенька в деле создания таких солидных продуктов, как качественная 3D-игра. Так что, если ваш приятель за неделю освоил редактирование сценариев игры Heroes III и теперь важно заявляет, что он программирует, вы можете, тихо улыбаясь, сказать ему, что он немножко ошибается.
А вот какие игры вы сможете создавать: Мрачная городская улица. Появляется автомобиль. Он стремительно приближается к главному герою, спрятавшемуся с бластером в руках за рекламной тумбой. Из автомобиля доносятся выстрелы. Пули щелкают по тумбе. В последний момент – визг тормозов и машина застывает. Теперь не медли – бей по клавишам клавиатуры, стреляй, пока крестные отцы наркомафии до тебя не добрались! Автомобиль вспыхивает, из него выскакивают «братки» и, спасаясь от твоих выстрелов, бросаются в ближайшие укрытия, откуда открывают ожесточенный огонь. Схватка продолжается…
А вот что вы сможете реально сделать в описанной игре: На экране – картинка города, сколь угодно красивая, нарисованная вами самостоятельно или где-нибудь добытая. Вы можете, кстати, следуя за сюжетом игры, менять картинки улиц, кварталов, помещений, в нужные моменты помещая на экран нужную картинку. По городу движутся автомобили, прохожие, летят пули, вспыхивают лазерные лучи. Вы сможете создать голоса персонажей, звуки выстрелов и прочее. Однако движения персонажей будут не такими реалистичными, как в 3D-играх. Вам легко будет сделать, чтобы фигуры персонажей в застывшей позе двигались в любых нужных вам направлениях и даже при этом уменьшались в размерах (удаляясь в перспективе) или увеличивались (приближаясь). Немного труднее будет заставить их при этом передвигать ногами. Больше времени уйдет, чтобы запрограммировать более сложные движения, такие как повернуться боком, пригнуться, лечь, зарядить винтовку, улыбнуться, залезть в карман и тому подобное. Если герою вздумается долго идти направо, то вы сможете заставить город услужливо прокручиваться налево, как это происходит в играх-аркадах.
Если вы думаете, что начав изучать программирование не с VB, а с Delphi или C++, вы быстрее и легче придете к программированию более сложных игр и других задач, то глубоко ошибаетесь. Если бы вы обратились за советом, с чего начать, к профессиональному программисту, который всю жизнь писал игры и другие программы на C++, то в ответ почти наверняка услышали бы: «Начни с Бейсика, дружок!»
Пробный запуск
Запускаем. Пока мы с вами создаем то – «сами не знаем что». Ведь никакой конкретной задачи мы перед собой не поставили за исключением туманного пожелания «покрасить форму». Тем не менее, перескочим через 2 этап (составление программы) и сразу выполним 3 этап, то есть запустим наш бессмысленный проект на выполнение. Для этого щелкнем мышкой по кнопке
Запустили. Исторический момент. Что мы видим? Некоторое время проект компилируется, то есть с языка VB переводится на язык близкий к машинному (подробнее, что такое компиляция, написано в Приложении 1). Через несколько секунд работы компьютера на экране появляется «еще один экземпляр» нашей формы. Это и есть наше приложение Windows, то есть запущенный, откомпилированный и работающий проект (см. правую половину Рис. 1.6). То, что мы видим, это уже не форма, а окно приложения. Оно отличается от формы, как дочь от матери, то есть они очень похожи. Поэтому в дальнейшем я часто буду называть работающее окно нашего приложения тоже формой. Я надеюсь, вы не будете путать ее с ее родительницей в окне проектирования.
Мы видим, что наша работающая форма все-таки немного отличается от формы на этапе проектирования, из которой она родилась: пропали точки, преображенная форма потеряла связь с главным окном VS и ведет себя, как независимое окно, каковым она, в общем, и является. Для убедительности сверните главное окно VS на панель задач. Теперь форма одна царит на экране. Ее можно таскать по всему экрану, ухватившись за заголовок, и ее значок вы можете видеть на панели задач Windows. Она надлежащим образом реагирует на щелчки по кнопкам в ее правом верхнем углу. Если подвести острие курсора к краю или углу формы, то можно менять ее размеры. А вот размеры кнопок и других элементов мы не можем больше менять.
Зато теперь на кнопки можно нажимать мышкой. Нажимаем. Ничего не происходит. Естественно – мы ведь не написали программу, объясняющую компьютеру, что нужно делать при нажатии на кнопку. В текстовое поле теперь можно вводить текст и как угодно там его менять и стирать. Щелчками мыши вы можете ставить и убирать флажки (галочки) в элементах CheckBox. Щелчками мыши вы можете устанавливать переключатель в какое угодно положение из четырех. Вы можете мышкой перемещать ползунок на полосах прокрутки. Но все это без толку. Компьютер никак не реагирует, что бы вы там ни делали. Причина та же.
Итак, мы видим, что без программы наш проект не стоит ни гроша.
Если работающая форма находится на фоне какого-нибудь окна (например, главного окна VS) и вы случайно щелкнете по этому окну мышкой мимо формы, то форма пропадет из вида, так как будет загорожена этим окном. Не беда – щелчок по значку формы на панели задач Windows вернет ее на передний план.
Обратите внимание на слово [run] (бег, работа) в заголовке главного окна VS. Оно говорит о том, что в настоящий момент VB находится в режиме работы, то есть в режиме выполнения проекта (3 этап), во время которого мы ни собирать проект (1 этап), ни писать для него программу (2 этап) не можем, о чем сообщают слова [Read Only] в том же заголовке.
Завершаем. Завершим выполнение проекта кнопкой
Сетка. В режиме проектирования мы видим, что форма покрыта сеткой из точек. Цель у сетки двоякая. С одной стороны она помогает нам визуально оценивать положение элементов управления на форме, с другой стороны мы можем настроить VS так, чтобы очертания элементов управления располагались строго по линиям сетки. Это помогает программисту делать элементы управления одинаковыми по величине и располагать их на форме правильными рядами.
Проектируем
Создайте новый проект и разместите на форме три текстовых поля и четыре кнопки. У вас получится так, как на Рис. 3.2.
Рис. 3.2
Чтобы продолжить дальше, нам нужно поближе познакомиться со свойствами форм и элементов управления.
Программируем Проект готов
Запустим проект. Введем в верхнее текстовое поле число 3, а в среднее введем 2. Щелкнем по кнопке сложения. Ничего не произошло. Естественно. Ведь никакой процедуры мы для кнопки не написали. Завершим работу проекта. Двойным щелчком по кнопке сложения создадим заготовку процедуры в окне кода. Поскольку никаких знаний у нас нет, попытаемся выдумать, что же там написать. Рассуждать будем так: 3 и 2 – не что иное, как значения свойства Text текстовых полей Число1 и Число2. По-другому, это Число1.Text и Число2.Text. Нам нужно, чтобы Результат.Text равнялся их сумме. Что если написать такой оператор:
Результат.Text = Число1.Text + Число2.Text
Сказано – сделано. Получаем:
Private Sub Кл_сложения_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Кл_сложения.Click
Результат.Text = Число1.Text + Число2.Text
End Sub
Запускаем проект. Вводим 3 и 2. Щелкаем по кнопке сложения. Результат есть. Но не совсем тот, что мы ожидали. Вместо 5 получилось 32. В чем причина? Дело в том, что VB привык считать знак + по отношению к содержимому текстовых полей не знаком сложения, а знаком «соединения», выстраивания в цепочку. Проверьте. Вместо 3 и 2 введите Коро и бочка, в результате получится Коробочка. Недаром текстовые поля называются текстовыми, а не числовыми. То, что мы назвали их Число1 и Число2, делу никак не помогло, потому что VB не обращает внимания на смысл имен, для него имена – просто бессмысленные сочетания символов.
Что делать? Надо приказать VB обращаться в данном случае с содержимым текстовых полей не как с текстом, а как с числами. Для этого достаточно записывать его не в таком виде –
Число1.Text Число2.Text
а в таком –
Val(Число1.Text) Val(Число2.Text)
Здесь функция Val – сокращение от Value – величина, численное значение. Теперь наш оператор будет выглядеть так:
Результат.Text = Val(Число1.Text) + Val(Число2.Text)
Запускаем проект. Вводим два любых целых числа и убеждаемся, что все складывается правильно.
Аналогично программируем три остальные кнопки. Помните мой совет о том, чтобы не вводить за один раз в окно кода больше 2-3 строк. Ввели процедуру вычитания, запустите проект, проверьте, как она работает. Теперь ввели процедуру умножения, запустили, проверили. И так далее.
Вот как будут выглядеть после этого 4 получившиеся процедуры:
Private Sub Кл_сложения_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Кл_сложения.Click
Результат.Text = Val(Число1.Text) + Val(Число2.Text)
End Sub
Private Sub Кл_вычитания_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Кл_вычитания.Click
Результат.Text = Val(Число1.Text) - Val(Число2.Text)
End Sub
Private Sub Кл_умножения_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Кл_умножения.Click
Результат.Text = Val(Число1.Text) * Val(Число2.Text)
End Sub
Private Sub Кл_деления_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Кл_деления.Click
Результат.Text = Val(Число1.Text) / Val(Число2.Text)
End Sub
Итак, калькулятор готов! Испытайте его как следует. Вводите дробные и отрицательные числа. При этом:
При вводе в текстовые поля десятичных дробей вместо запятой ставьте точку. Результат же будет выводиться с запятой.
Предостережения: Наш калькулятор пока не защищен от ввода вместо чисел всякой ерунды (например, текста КУ-КУ), от ввода слишком больших или слишком маленьких чисел, от деления на ноль. В таких случаях VB даст нам неправильный или неудобочитаемый результат. Защиту и улучшения вы найдете в 5.4 и 7.7.
Выполните следующие два задания. Они позволят вам обогатить ваш калькулятор новыми возможностями. Ответы к заданиям вы найдете в конце книги.
Задание 1.
Создайте кнопку возведения в квадрат числа из верхнего текстового поля. Указание: Возвести в квадрат – значит умножить само на себя.
Задание 2.
На нашем калькуляторе не хватает кнопки СБРОС, которая опустошала бы все три текстовых поля. Создайте ее. Указание: Для этого вам понадобятся операторы типа Число1.Text = "". В окне кода текстовое содержимое текстовых полей должно указываться в двойных кавычках. В данном случае у нас внутри кавычек пусто, что и требовалось.
Project
Это меню нужно в основном для того, чтобы добавлять в проект различные компоненты: формы, классы, модули и др. Процесс этот описан в соответствующих местах книги (например, в 21.1.2).
Работа с файлами и папками в окнах Open Project и Open File
В этом подразделе я научу вас путешествовать внутри окон Open Project и Open File по папкам и дискам, находить в них нужный проект, нужную папку, нужный файл, а кроме этого – не выходя из окон создавать, копировать, перемещать и удалять файлы и папки, без чего в работе с VB не обойтись. Вся упомянутая работа в окнах Open Project и Open File очень похожа на аналогичную работу в окнах Windows, которая описана в Приложении 2.
Окно Open Project. Запустите VS. Затем: File ® Open ® Project ® перед вами появится диалоговое окно открытия проекта (Рис. 1.11).
Рис. 1.11
Щелкните в нем по кнопке My Projects. Вы увидите содержимое папки Visual Studio Projects.
Путешествуем по папкам. В большом белом поле в середине диалогового окна вы видите список папок и файлов. Это содержимое папки, название которой вы видите в находящемся чуть выше раскрывающемся списке Look in. Вы можете двойным щелчком мыши войти в любую из папок в этом поле. Тогда именно она появится в списке Look in, а в большом поле появится ее содержимое. Таким образом вы можете продвигаться вглубь папок, как внутрь матрешки. А как продвигаться наружу? Для этого есть кнопка
Если вы сейчас дважды щелкнете по папке Красим форму, то окажетесь внутри нее, то есть увидите то, что изображено на Рис. 1.10.
Щелкнув по черной треугольной стрелке в раскрывающемся списке Look in, вы раскроете список папок в виде части дерева, похожего на дерево Проводника Windows (см. Рис. 1.12). Это позволит вам быстрее путешествовать по папкам.
Рис. 1.12
Потренируйтесь. У вас должна возникнуть уверенность, что вы можете добраться до любой папки на любом диске вашего компьютера, а значит открыть любой проект.
Окно Open File. В окне Open Project вы видите все папки, но вот файлы видите не все, а лишь те, типы которых указаны в списке Files of type. Чтобы видеть все файлы, вам надо вызвать на экран не диалоговое окно открытия проекта, а диалоговое окно открытия файла, то есть выполнить не File ® Open ® Project, а File ® Open ® File. Сделайте это и тут же зайдите в папку Красим форму (см. Рис. 1.13).
Рис. 1.13
На Рис. 1.10 мы видим в папке только два файла, а здесь – семь. В принципе окна Open Project и Open File похожи как по виду, так и по назначению, только второе показывает все файлы и работает со всеми файлами, а первое – нет.
Диалоговое окно открытия файла может открывать и проекты и просто файлы. При этом VS открывает их в своей среде, а если посчитает их слишком уж чужими – вызывает подходящее с ее точки зрения приложение Windows.
Дальнейшие пояснения я буду вести на примере окна Open File.
Когда вы совершаете какие-то действия с папками и файлами в диалоговых окнах, не советую во избежание неприятных последствий производить их над папками и файлами открытого проекта.
Создаем папки. Внутри папки, выбранной в списке Look in, вы можете создавать новые папки. Новая папка будет создана, если вы щелкнете по кнопке
Создаем файлы. Щелкните правой клавишей мыши по белому пространству большого поля и в контекстном меню выберите New. В возникшем подменю вы увидите типы файлов, которые вы можете создать внутри папки, выбранной в списке Look in (см. Рис. 1.14). Щелкайте по нужному типу и создавайте. Среди этих типов вы найдете и Folder, что означает создание папки.
Рис. 1.14
Копируем файлы и папки. Чтобы скопировать файл или папку в другое место, выберите в контекстном меню файла или папки опцию Copy (копировать). Затем доберитесь до папки, в которую хотите данный файл или папку скопировать, то есть добейтесь ее присутствия в списке Look in, и щелкните правой клавишей мыши по свободному пространству. В открывшемся контекстном меню выберите Paste (вставить). Если вы хотите, чтобы копия находилась рядом с оригиналом, добираться до другой папки не нужно.
Перемещаем файлы и папки. Чтобы переместить файл или папку в другое место, делайте все то же, что и при копировании, только вместо Copy выберите в контекстном меню опцию Cut (вырезать).
Переименовываем файлы и папки. Чтобы переименовать файл или папку, выберите в контекстном меню опцию Rename (переименовать) и введите новое имя.
Удаляем файлы и папки. Чтобы удалить файл или папку, выберите в контекстном меню опцию Delete (удалить) и ответьте утвердительно на вопрос компьютера.
Размещаем объекты на форме
Что на Рис. 1.4 должно вас больше всего интересовать, так это серый прямоугольник или квадрат, расположенный на белом фоне. Он покрыт сеткой из точек и имеет заголовок Form1. Это так называемая форма. Если форму вы по какой-то причине не видите или впоследствии потеряли из виду, то в главном меню окна VS выберите View ® Designer.
Что же это такое – форма? Вспомним нашу игрушечную железную дорогу. Так вот, форма – это пустой стол, тот самый стол, на котором мы эту дорогу будем собирать. Когда вы запустите проект, он станет приложением Windows, а форма станет окном Windows, в котором будет работать ваше приложение.
Обратите внимание на три белых квадратика – маркера – в правой нижней части формы. Ухватившись за них мышкой, вы можете менять размеры формы. Но таскать форму по экрану вам здесь не удастся.
Начнем работу над проектом с 1 этапа. Чтобы собрать железную дорогу, нам нужны объекты: рельсы, вагоны и т.п. Чтобы создать проект, нам тоже нужны объекты – и VB нам их предоставляет. В левой части главного окна VS мы видим значок
Рис. 1.5
Это окно Toolbox («Ящик» с элементами управления), то есть набор наиболее популярных стандартных объектов, применяемых при создании проектов на VB (это наши паровозики и вагончики). Каждый объект-элемент управления имеет свое название: кнопка, текстовое поле, таймер, графическое поле и т.п.
Если вы убрали мышку с окна Toolbox, то оно уплывет обратно, мудро освобождая дефицитное место на экране. Чтобы снова увидеть его, поставьте опять мышку на значок.
Замечание: Понятие «Объект» – центральное в VB. Оно имеет гораздо более широкий смысл, чем форма или элемент управления, но поскольку других объектов мы пока не знаем, я буду называть объектами именно их. Постепенно я буду расширять и уточнять понятие объекта.
Ну что ж, начнем сборку. Я пока не буду объяснять «зачем», а буду только объяснять «что» и «как». Поместим на форму так называемую кнопку. Для этого щелкнем в Toolbox по кнопке (Button). Мышиный курсор приобретет характерный вид крестика с кнопкой. Затем проведем мышкой внутри формы небольшую «рамочку». Что значит провести «рамочку»? Это значит поместить мышиный курсор куда-нибудь внутрь формы, нажать на левую клавишу мыши и, не отпуская клавишу, «протащить» мышь немного наискосок. При этом за курсором будет тянуться «рамочка». Отпустите мышь. На месте рамочки возникнет кнопка с надписью Button1. Впрочем, рамочку можно и не проводить, достаточно просто щелкнуть где-нибудь внутри формы.
По краям кнопки вы увидите 8 белых квадратиков - маркеров изменения размеров (Рис. 1.5). Если щелкнуть по форме мимо кнопки, они пропадут, если снова щелкнуть по кнопке – появятся. Только не надо пока двойных щелчков (если все-таки сделаете двойной щелчок, у вас на месте прежнего откроется другое окно. В этом случае просто выберите в окне закладку Form1.vb [design] и все вернется на место. Перетащите мышкой любой из маркеров – размеры кнопки изменятся. Можно таскать кнопку по форме, если ухватиться мышью не за маркер, а за любое место внутри кнопки. Можно передвигать кнопку клавишами перемещения курсора на клавиатуре. Чтобы уничтожить кнопку, щелкните по ней правой клавишей мыши и в выскочившем контекстном меню выберите опцию Delete или нажмите клавишу стирания на клавиатуре. Проделайте все это. А теперь, если вы ее уничтожили, то снова создайте.
Аналогичным образом поместите из Toolbox на форму еще одну кнопку, а также следующие объекты: метку (Label), несколько флажков (CheckBox), несколько элементов переключателя (RadioButton), горизонтальную полосу прокрутки (HScrollBar), вертикальную полосу прокрутки
(VScrollBar) и текстовое поле (TextBox). Расположите их примерно так, как в левой половине Рис. 1.6.
Рис. 1.6
Вы обратили внимание, что текстовое поле сопротивляется увеличению своего размера по вертикали? В дальнейшем (3.4.2) мы преодолеем это сопротивление.
Обратите внимание на слово [design] (дизайн, проектирование) в заголовке главного окна VS. Оно говорит о том, что в настоящий момент VB находится в режиме проектирования, во время которого мы можем собирать, конструировать наш проект (1 этап) и писать для него программу (2 этап). Белое окно с формой, в котором мы выполняем конструирование, называется окном конструктора (дизайнера) форм (Windows Forms Designer).
Обратите внимание, что когда мы размещаем на форме несколько одинаковых объектов, например Button, VB надписывает их с указанием порядкового номера: Button1, Button2, Button3…
