Первый способ – опускаем названия пространств имен
В большинстве случаев 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.
Положение объекта на экране Система координат
Чтобы рисовать фигуры, чтобы помещать объекты в нужное место экрана или формы, чтобы при анимации двигать объекты в нужном направлении, вы должны уметь объяснить компьютеру, где, в каком месте экрана или формы вы хотите нарисовать фигуру или поместить объект. Научиться этому можно быстрее, имея представление о системе координат. Но если вы не знаете, что это такое, то вот вам вся суть без использования этого понятия.
В режиме проектирования выделите любой объект на форме, щелкните в окне свойств плюсик у его свойства 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…
Разные необходимые вещи
Первые три подраздела касаются оформления программы в окне кода. Компьютеру они не нужны, а нужны вам.
Режим прерывания Пошаговый режим выполнения программы
Компьютер выполняет программу со страшной скоростью. Не успели мы нажать кнопку – а результаты уже получены. Если дела идут нормально, этот факт нас восхищает. Но предположим, что результаты получились не те, что нам надо. Это значит, что в программе есть ошибки. И искать их трудно. В такой ситуации скорость компьютера начинает раздражать. Хотелось бы, чтобы компьютер работал помедленнее и мы успевали проследить за его работой. И хорошо бы как-нибудь во время работы подсмотреть значения переменных в памяти, это помогло бы найти ошибку. Режим прерывания для этого и предназначен. Подробно о режиме прерывания и об отладке программы поговорим в Глава 9. , а сейчас вкратце и без особых пояснений остановимся на самом необходимом.
Щелкните в нашем проекте по вертикальной серой полосе в левой части окна кода против строки заголовка процедуры. На полосе появится черная точка и вся строка будет выделена черным (см. Рис. 5.3). Была создана так называемая точка прерывания (Breakpoint). Убираются точки прерывания так же, как и ставятся – щелчком мыши.
Рис. 5.3
Запустите проект обычным образом (кнопка Start или клавиша F5). Проект начнет выполняться как обычно. На экране появится форма. Нажмите, как водится, кнопку Button1. И тут вы почувствуете разницу. Вместо того, чтобы полностью выполниться и показать результат, проект остановится на точке прерывания, в знак чего эта строка окажется подсвечена желтым цветом и на нее укажет желтая стрелка (Рис. 5.4). Итак, только-только начав выполняться, наш проект «замерз» до тех пор, пока мы его не разморозим. «Мгновение остановилось». Говорят, что проект перешел в так называемый режим прерывания.
Рис. 5.4
Интересно, чему во время остановки равны значения переменных в памяти компьютера? Для того, чтобы узнать это, достаточно поместить не нажимая мышиный курсор на обозначение переменной в тексте процедуры в окне кода – во всплывающей подсказке вы увидите значение переменной (на Рис. 5.4 вы видите, что y=0). Поводите мышью по переменным. Как и положено, пока «на табло одни нули».
Продолжим выполнение проекта не кнопкой Start, как привыкли, а клавишей F11 на клавиатуре. Это горячая клавиша для Debug ® Step Into (кстати, если ваш профиль настроен на Visual Basic 6, то горячей клавишей будет F8, а не F11). Ничего не происходит, только полоса подсветки прыгает на строку a = 10. Операторы Dim выполняются заранее, поэтому полоса подсветки через оператор Dim перепрыгнула.
F11. VB выполняет a = 10, а следующий оператор подсвечивается. Проверьте мышкой, чему сейчас равны a, b, y в памяти.
F11. VB выполняет b = 6, а следующий оператор подсвечивается. Проверьте, чему сейчас равны a, b, y в памяти.
Итак, правило простое – при нажатии на F11 VB выполняет очередной оператор программы и подсвечивает тот оператор, которому предстоит быть выполненным.
Обратите внимание, что сменился режим VB. Мы знаем пока два режима: режим проектирования [design] и режим работы [run]. Теперь в заголовке главного окна VB вы видите слово [break]. Это означает, что VB сейчас находится в режиме прерывания. Можно сказать, что режим прерывания – это режим существования проекта, когда выполнение программы прервано, но не закончено. Когда вы нажимаете на F11, вы приказываете Бейсику останавливаться на каждом операторе. Такая разновидность режима прерывания называется пошаговым режимом. Режим прерывания можно настроить и на более редкие остановки.
F11. VB выполняет y = a+b+1, а следующий оператор подсвечивается. Проверьте, чему сейчас равны a, b, y в памяти.
F11. VB выполняет Debug.WriteLine (y + 200), а следующий оператор подсвечивается. В окне Output возникает число 217.
F11. Подсветка уходит, так как процедура выполнена. Можно снова жать на кнопку Button1.
Итак, компьютер сделал все то, что сделал бы при нажатии Start, но только в медленном темпе.
В любой момент пошагового выполнения программы вы можете вместо F11 нажать Start, которая по такому случаю переименовывается в Continue, и программа продолжит выполняться в обычном режиме.
Когда VB находится в режиме прерывания, на экране вы видите панель инструментов для отладки – Debug (Рис. 5.5).
Рис. 5.5
Когда вам вздумается завершить отладку, вы можете сделать это привычным способом, закрыв форму крестиком, а можете и нажать кнопку Stop Debugging на панели Debug (она имеет форму черного квадратика). Если панели Debug не видно, поместите ее туда обычным образом: View ® Toolbars ® Debug.
Замечание: При отладке в пошаговом режиме вам часто нужно на экране видеть одновременно главное окно VS и саму запущенную форму. Но при нажатии на F11 форма часто пропадает из вида, будучи закрыта другими окнами. Чтобы этого не происходило, еще до начала отладки главное окно VS уменьшите до части экрана. Затем после запуска отладки перетащите форму на освободившуюся часть экрана. Тогда окно VS не будет перекрывать форму и проблема исчезнет.
Single и Double – десятичные дроби
С типом дробных чисел Double мы встретились в 5.2.3. Познакомимся поближе с ним и с типом Single. Оба они предназначены для работы с целыми и дробными числами и различаются, согласно таблице, точностью и диапазоном значений.
Создайте кнопку и введите такую программу:
Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button3.Click
Dim a, b, c As Single
a = 23.456
b = 100
c = a + b
WriteLine(a) : WriteLine(b) : WriteLine(c)
Dim d, f, g As Double
d = 123456789
f = 0.000555
g = d + f
WriteLine(d) : WriteLine(f) : WriteLine(g)
End Sub
Обратите внимание, что оператор Dim d, f, g As Double находится не на самом верху процедуры. Это ничего. Надо только, чтобы объявление переменной было расположено в процедуре раньше ее «употребления».
Запустите проект. Вот результат:
23,456
100
123,456
123456789
0,000555
123456789,000555
Все правильно. Попробуем теперь проверить тип Single на прочность, как мы проверяли тип Integer. Попробуем записать вместо a = 23.456 очень длинную дробь:
a = 23.45678901234567890123456789
Но VB не дает нам роскошествовать. Он прямо в окне кода укорачивает строку до:
a = 23.456789012345681
причем даже чуть-чуть искажает число. Поставим курсор мыши на этот литерал и увидим подсказку «Double». Почему? Ведь переменная a имеет тип Single! Дело в том, что VB, пока проект не запущен, не утруждает себя угадыванием смысла литералов в окне кода и все дробные литералы «стрижет под Double». Запустим проект. Вот первые три числа результатов:
23,45679
100
123,4568
Как видите, VB обрезал наши длинные числа до 7 значащих цифр. Сделал он это потому, что 4 байта, отведенные под ячейку памяти для переменной типа Single, не в состоянии вместить больше. Если мы хотим иметь большую точность, то объявляем наши переменные типом Double. Под переменную типа Double компьютер отводит в памяти 8 байтов и поэтому она может быть гораздо длиннее – 17 значащих цифр.
Попробуем задать очень маленькое число. Вместо f = 0.000555 напишем:
f = 0.0000000000000000000000000000000000000000000000000000000000000543
Но VB не любит в дробных числах большого числа нулей и вот, хоть запись и правильная и вполне по зубам типу Double, VB прямо в окне кода укорачивает строку до:
f = 5.43E-62
Это тоже правильная запись, а что она значит, объяснено чуть позже, в 5.4.7.
Поговорим о точности вычислений. Если вы до сих пор считаете, что компьютер все вычисления выполняет абсолютно точно, то ошибаетесь. Компьютер всего лишь очень точен. Очень, а не абсолютно. И в этом вы скоро убедитесь. Начнем хотя бы с того, что VB не умеет работать с обыкновенными дробями. Он не знает, что такое 1/3, поэтому нам приходится задавать компьютеру вместо числа 1/3 число 0,333333333333. Но это ведь не точная дробь 1/3, а только приблизительное значение. Чтобы она стала точным значением, число знаков после запятой должно быть бесконечным, а такое число не уместится в памяти компьютера. Следовательно, даже теоретически компьютер не может быть абсолютно точен.
Во-вторых, из-за ограниченности типа Double 17 значащими цифрами операции даже над очень точными числами выполняются не совсем точно. Что, например, напечатает такой фрагмент?:
Dim d, f, g As Double
d = 123456789
f = 0.00987654321098765
g = d + f
WriteLine(d) : WriteLine(f) : WriteLine(g)
Если вы думаете, что точную сумму 123456789,00987654321098765, то ошибаетесь, так как такое длинное число не уместится в типе Double. А напечатано будет вот что:
123456789
0,00987654321098765
123456789,009877
Десяток цифр из точного значения суммы обрезаны.
Целые литералы VB автоматически относит к типу Integer, а если они слишком длинные для Integer – к типу Long. Дробные литералы VB относит к типу Double. Все это он делает, не особенно обращая внимание на то, что переменные в том же операторе имеют другой тип.
Смысл оператора присваивания
Имейте в виду, что в операторе присваивания слева от знака равенства не может стоять число или выражение. Можно писать с=34, но нельзя писать 34=с. Можно писать z=f-v+990, но нельзя писать f-v+990=z. Правило это принято исходя из механики работы оператора присваивания. Оператор присваивания устроен так, что сначала смотрит или вычисляет, какое значение имеет правая часть, а затем присваивает это значение тому, что стоит в левой
части. То, что справа от знака равенства, присваивается тому, что слева от знака равенства, а не наоборот. Нет смысла присваивать значение числу или выражению.
Обратите внимание еще на один важный момент. Когда школьник видит выражение (например, d+2d), он не обязательно его вычисляет. Он может его преобразовать или, скажем, упростить (получив 3d), даже не поинтересовавшись, чему равно d. Компьютер же, видя выражение, сначала его, может быть, и упростит в уме, но затем обязательно вычислит. А для этого он должен знать численные значения входящих в него величин (в нашем случае это величина d). Таким образом, вычисляя правую часть оператора присваивания (например, y=a+b+1), компьютер должен обязательно заранее знать, чему равны переменные, из которых эта правая часть состоит (в нашем случае это a и b). Ответственность за это знание лежит полностью на программисте. Пусть забывчивый программист записал такой фрагмент: … а=10 : y=a+b+1…, нигде в программе не придав b никакого значения. Естественно, при вычислении выражения a+b+1 компьютер не будет знать, чему равно b. В такой ситуации разные языки программирования поступают по-разному. Некоторые «злые» языки просто отказываются вычислять выражение, «коварный» Турбо-Паскаль может подставить вместо b какую-нибудь ерунду (и молчок, между прочим). VB добрый – он подставляет вместо b нуль.
Проверим. Заставим VB в нашем последнем проекте про прямоугольник не выполнять оператор a = 27018. Для этого его можно просто стереть, но удобнее закомментировать: поставить перед ним кавычку, тогда VB подумает, что это комментарий и выполнять не будет:
‘a = 27018 'Длина прямоугольника
Вот результат:
0
7908
Действительно, все выполнилось так, как если бы a было равно нулю.
События и их обработка
Разные события. Напомню, что объекты обладают свойствами, методами и событиями. Мы с вами уже познакомились с несколькими свойствами и методами. Но вот о событиях говорили мало. Фактически нам знаком лишь один сорт событий – щелчки мышкой по кнопке и пункту меню. Но у объектов VB (в частности – у формы и элементов управления) имеется большое количество и других событий. Так, у кнопки есть следующие события: щелчок мышкой по кнопке, появление мыши над кнопкой, нажатие клавиши мыши над кнопкой, отпускание клавиши мыши над кнопкой, изменение цвета кнопки, изменение размеров кнопки и несколько десятков других. У текстового поля есть следующие события: двойной щелчок мышкой по текстовому полю, изменение текста в текстовом поле и несколько десятков других. У формы есть следующие события: движение мыши над формой, изменение размеров формы, загрузка формы (например, появление при запуске проекта), закрытие формы (например, щелчком по крестику в правом верхнем углу) и несколько десятков других.
Обработка событий. Каждый раз, когда в предыдущих проектах мы щелкали мышкой по кнопке Button1 (то есть наступало событие – щелчок мышкой по кнопке Button1), компьютер делал то, что мы ему приказали: красил, показывал текст, играл мелодию и т.п. Делал он это только потому, что мы в окне кода заранее написали процедуру, в которой объяснили компьютеру, что ему в этом случае делать. Например:
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
HScrollBar1.Width = 100
RadioButton2.Hide()
End Sub
Посмотрим в заголовок процедуры. Где в нем сказано, что процедуру эту надо выполнять именно при щелчке мышью и именно по кнопке Button1? Ответ: в правой части заголовка после скобок:
Handles Button1.Click
Здесь Click – щелчок мышью (событие), Button1 – объект, с которым происходит это событие, Handles – по-русски «обрабатывает». Полностью заголовок процедуры можно перевести так: Процедура, которая обрабатывает щелчок мышью по кнопке Button1, или по-другому – указывает, что нужно сделать при щелчке мышью по кнопке Button1.
Нечто похожее написано и в левой части заголовка процедуры:
Button1_Click
Но это всего лишь имя процедуры. Вы можете его как угодно изменить, процедура все равно будет работать.
О смысле того, что написано внутри скобок, мы будем говорить позже.
Как получить заготовку процедуры для обработки любого события? Чтобы получить заготовку процедуры для обработки щелчка мышью по кнопке или пункту меню, мы в режиме проектирования просто делали двойной щелчок по кнопке или пункту меню. И в окне кода получали заготовку:
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
End Sub
Почему появлялась заготовка именно для щелчка мышью, а не для какого-нибудь другого события? Потому что так удобней программисту, ведь щелчок мышью – самое популярное событие, когда речь идет о кнопке или пункте меню. А как нам получить заготовку для обработки какого-нибудь другого события? Разберем на примере.
Создайте проект с двумя текстовыми полями и кнопкой (Рис. 3.25).
Рис. 3.25
Поставим такую задачу: Пусть при появлении мышки над кнопкой Button1 в текстовом поле TextBox1 появляется текст «Мышь появилась над кнопкой».
Зайдите в окно кода. В его верхней части вы увидите два белых поля. Щелкните по черной треугольной стрелке в левом поле. Откроется список. В нем вы увидите имена всех элементов управления на форме и самой формы (Рис. 3.26).
Рис. 3.26
Поскольку нас интересует кнопка Button1, выберем в списке именно ее. Теперь наш путь – в правое поле. Щелкните по черной стрелке в правом поле. Откроется список. В нем вы увидите имена событий, связанных с кнопкой Button1 (Рис. 3.27).
Рис. 3.27
Выберите событие MouseEnter, которое в данном случае можно перевести так: «Появление мыши над». В окне кода появляется заготовка
Private Sub Button1_MouseEnter(ByVal sender As Object, ByVal e As System.EventArgs) Handles Button1.MouseEnter
End Sub
Завершающий фрагмент заголовка (Handles Button1.MouseEnter) говорит, что эта процедура обрабатывает (Handles) появление мыши (MouseEnter) над кнопкой Button1 .
Запишем внутрь процедуры нужный оператор. Получим:
Private Sub Button1_MouseEnter(ByVal sender As Object, ByVal e As System.EventArgs) Handles Button1.MouseEnter
TextBox1.Text = "Мышь появилась над кнопкой"
End Sub
Важное замечание по оформлению программного текста в книге: Заголовки процедур в заготовках, которые возникают в окне кода, получаются очень длинными и, будучи перенесенными на этот книжный лист, часто не умещаются по ширине листа. В то же время они содержат имена пространств имен, которые VB вполне разрешает выбросить. Например, в предложенном заголовке
Private Sub Button1_MouseUp(ByVal sender As System.Object, ByVal e _
As System.Windows.Forms.MouseEventArgs)Handles Button1.MouseUp
можно безнаказанно выбросить пространства имен, которые я выделил полужирным шрифтом. Получится гораздо компактнее:
Private Sub Button1_MouseUp(ByVal sender As Object, ByVal e As MouseEventArgs)Handles Button1.MouseUp
В дальнейшем я часто так и буду поступать.
Примеры обработки событий. Ниже приведена программа из нескольких процедур для обработки в нашем проекте нескольких популярных событий формы и элементов управления. Введите программу в окно кода. Для этого добейтесь описанным выше способом, чтобы в окне кода появились заготовки процедур для каждого события. Для обработки событий формы выберите, если вы работаете в Visual Studio .NET 2003, в левом поле Form1 Events, а если в Visual Studio .NET – Base Class Events. Не забывайте, что после ввода очередной процедуры проект рекомендуется запускать и результаты работы процедуры проверять. Пояснения приведены ниже.
Private Sub Button1_MouseEnter(ByVal sender As Object, ByVal e As System.EventArgs) Handles Button1.MouseEnter
TextBox1.Text = "Мышь появилась над кнопкой"
End Sub
Private Sub Button1_MouseDown(ByVal sender As Object, ByVal e As System.Windows.Forms.MouseEventArgs) _
Handles Button1.MouseDown
TextBox1.Text = "Нажата клавиша мыши над кнопкой"
End Sub
Private Sub Button1_MouseUp( ByVal sender As Object, ByVal e As MouseEventArgs) Handles Button1.MouseUp
TextBox1.Text = "Отпущена клавиша мыши над кнопкой"
End Sub
Private Sub TextBox2_TextChanged(ByVal sender As Object, ByVal e As System.EventArgs) _
Handles TextBox2.TextChanged
TextBox1.Text = "Текст в нижнем текстовом поле изменился"
Beep()
End Sub
Private Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles MyBase.Load
MsgBox("Выполняется процедура Form1_Load. Форма еще не видна.")
TextBox1.Text = "Форма загружена"
End Sub
Private Sub Form1_Closed(ByVal sender As Object, ByVal e As System.EventArgs) Handles MyBase.Closed
MsgBox("Форма закрыается")
End Sub
Private Sub Form1_Resize(ByVal sender As Object, ByVal e As System.EventArgs) Handles MyBase.Resize
TextBox1.Text = "Форма изменила размер"
End Sub
Private Sub Form1_MouseMove(ByVal sender As Object, ByVal e As System.Windows.Forms.MouseEventArgs) _
Handles MyBase.MouseMove
TextBox1.Text = "Мышь сдвинулась над формой"
End Sub
Пояснения.
Событие TextChanged. Изменения текста отслеживаются в поле TextBox2, а не TextBox1, которое нам нужно только для выдачи сообщений. Не путайте. Проверяется это событие просто – попробуйте изменить текст в нижнем поле – сразу же в верхнем поле появится сообщение и вы услышите звук. Кстати, вы услышите его и при запуске проекта, потому что при запуске проекта VB записывает в поля их текст. А вот почему тогда мы не видим при запуске в верхнем поле сообщения "Текст в нижнем текстовом поле изменился", это загадка. Которую чуть позже попробуйте отгадать сами.
Форма Form1 в правой части заголовка обработчика обозначается MyBase.
Событие Load формы – загрузка формы – происходит при запуске проекта. Это очень важное и широко используемое событие. Пока процедура Form1_Load выполняется, форму на экране вы ее еще не видите. Поэтому и все действия, которые вы запрограммировали в этой процедуре, выполняются до появления формы на экране. Тем не менее, как сама форма, так и элементы управления к этому моменту уже незримо присутствуют в проекте и с ними можно работать. Некоторые события успели произойти и быть обработаны до выполнения процедуры Form1_Load, о чем свидетельствовал звук перед появлением сообщения «Выполняется процедура Form1_Load. Форма еще не видна».
Событие Closed формы – закрытие формы – происходит, когда вы закрываете форму, например, крестиком в ее правом верхнем углу. Раз форма закрыта, она исчезла из поля зрения вместе со своими текстовыми полями. Поэтому сообщение об этом факте я доверил не текстовому полю, а окну MsgBox.
Когда вы водите мышью над формой, событие MouseMove возникает много раз в секунду.
Список событий объекта с пояснениями вы можете найти и в системе помощи (см. 4.4.9), поставив текстовый курсор на имя объекта и нажав F1. В открывшемся окне помощи вы найдете события по заголовку (Events) и по значкам молнии.
С остальными популярными событиями мы будем знакомиться по мере изучения книжки.
Сохранение, закрытие, открытие, создание проекта, выход из VS
Сохранение. А теперь нам пора сохранить проект. Вообще-то, сохраниться нам надо было еще давно, до первого запуска, но не хотелось отвлекаться. Помните, что несохраненный проект пропадет, если внезапно отключится электричество или компьютер зависнет. Сохраните сейчас проект, нажав на кнопку
Вы должны понимать одну вещь. Каждый раз, когда вы нажимаете на кнопку Save All, VS, ни о чем вас не спрашивая, стирает с диска весь ваш проект (в том виде, как он был сохранен в последний раз) и на его место записывает с тем же именем его исправленную и дополненную вами версию, то есть ту, что вы видите на экране. Так поступают все современные программные продукты. На усмотрение программиста оставляется решать, а не хуже ли новая версия старой и не жалко ли старой версии.
Дальнейший материал подраздела прочтите, не выполняя. Выполнение отложите на потом, когда действительно понадобится закрывать, открывать или создавать проект.
Закрытие. Если вы хотите закончить работу над проектом, вам нужно сохраниться, а затем так закрыть его: File ® Close Solution. Теперь в окне Solution Explorer у вас должно быть пусто. Если вы забыли сохранить проект, VS перед закрытием предложит вам сделать это.
Выход из VS совершенно такой же, как и из большинства других приложений Windows – щелчок мышкой по крестику в правом верхнем углу главного окна VS или File ® Exit. Если вы забыли сохранить проект, VS перед выходом предложит вам сделать это.
Открытие. Сохранившись и закрыв проект, вы можете спокойно выйти из VS и можете даже выключить компьютер. Можно и не выходить из VS. Чтобы продолжить через некоторое время работу над проектом, снова запустите VS (если вы вышли из нее) и так загрузите (откройте) сохраненный проект: File ® Open ® Project ® перед вами откроется диалоговое окно открытия проекта ® зайдите в папку проекта (Рис. 1.10). Если вы не знаете, как добраться до папки нужного проекта, читайте следующий подраздел.
Рис. 1.10
Затем щелкните по одному из двух файлов, а именно, по файлу так называемого решения (на рисунке он выделен). Другой файл (на рисунке он ниже) – это файл проекта (кстати, можно щелкнуть и по нему). Как вы видите, эти два файла различаются значками и расширениями. Вообще о проектах и решениях (Solution) поговорим позже (21.3).
Затем – Open. Перед вами появится ваш проект. Если же не появится и даже закладки окон конструктора форм и кода не появляются над окном, сделайте двойной щелчок по значку Form1.vb в окне Solution Explorer (Рис. 1.5). Появится окно конструктора форм. Если же нигде не видно окна Solution Explorer, сделайте следующее: View ® Solution Explorer. Еще один способ: View ® Designer (чтобы появилось окно конструктора форм) и View ® Code (чтобы появилось окно кода).
Создание. Если вы работаете над каким-нибудь проектом, а затем хотите бросить его и начать новый проект, то сначала сохраните и закройте проект, над которым работаете. Убедитесь, что в окне Solution Explorer у вас пусто. Затем выполните File ® New ® Project, а далее – как уже описано в 1.3.1.
При создании нового проекта не забудьте дать ему подходящее имя. Всем вашим проектам придумывайте, конечно, разные имена. Для каждого нового проекта VS создает отдельную папку с данным вами именем. Через некоторое время у вас накопится несколько папок с сохраненными проектами. Все они расположены рядышком внутри папки Visual Studio Projects.
Ситуации. Если вы работали в некотором проекте, а затем, не сохранив и не закрыв его, решили открыть или создать другой проект, то VS сначала предложит вам сохранить старый и после сохранения автоматически удалит его из среды (не с диска, конечно), освобождая место для нового.
Если вы по ошибке вместо File ® Open ® Project
или File ® New ® Project выполните File ® Add Project, то старый проект не будет удален и в главном окне VS вы будете иметь вместо одного сразу два проекта. Вы это сразу же заметите, взглянув в окно Solution Explorer. Иногда иметь в среде сразу два проекта удобно, иногда просто необходимо, но пока вам это не нужно. Если это все же произошло, жмите, пока вы еще неопытны, File ® Close Solution, отвечая отказом на предложения сохраниться, до тех пор, пока окно Solution Explorer не опустеет.
Часто новый проект, который мы создаем, бывает похож на старый, и удобнее не новый создавать с нуля, а старый переделывать. Мой опыт таков. Я, не открывая старый проект, копирую целиком его папку. Таким образом, теперь у меня на диске два одинаковых проекта. Затем я обычным образом открываю копию проекта и переделываю ее в новый проект. Как копировать папки, написано в Приложении 2 «Действия над файлами и папками». Вы спросите: Зачем копировать, если можно просто переделывать старый проект в его папке? Ответ: в процессе переделки вы можете потерпеть неудачу, тогда у вас и новый проект не будет создан и старый испорчен.
Solution Explorer
Теперь поговорим о смысле некоторых окон VS.
В окне Solution Explorer (оно видно, например, на Рис. 1.5) мы видим структуру нашего проекта. Пока от этого окна пользы мало, так как у наших проектов структура простая – одна форма и связанный с ней код. Сложные проекты могут состоять из многих форм и других компонентов, взаимосвязь которых как раз и удобно видеть в этом окне.
Вы можете одновременно работать с несколькими проектами, объединенными в так называемое решение (Solution). О том, зачем это бывает нужно, вы узнаете позже. Все проекты решения видны в этом же окне Solution Explorer. До сих пор мы работали с одиночными проектами, но все равно считалось, что мы работаем не просто с проектом, а с решением, состоящим из одного проекта. Так считать мы будем и в будущем. Поэтому часто я не буду различать проект и решение.
Более подробно о решении и работе Solution Explorer написано в 21.3.
Создаем меню
Скопируйте папку проекта Калькулятор и работайте над копией.
Чтобы создать меню, нужно в Toolbox найти новый для нас элемент MainMenu (Главное меню) и разместить его на форме. Но, странное дело, оно оказывается не на форме, а под ней (значок MainMenu1 на Рис. 3.18). Эта область, где расположен значок, называется дизайнером компонентов (Component Designer). VB помещает на дизайнер компонентов те элементы, которым во время работы проекта ни к чему быть видимыми.
Однако, одновременно на том же рисунке мы видим и «зародыш» нашего будущего меню: в левой верхней части формы, там, где обычно и размещается Главное меню, появилось белое поле со словами Type Here, что означает «Печатай сюда». Вот его-то мы видеть будем.
Рис. 3.18
Щелкните по этому полю и введите в него текст «Внешний вид». Как только вы начнете вводить этот текст, появятся еще дополнительные поля со словами Type Here (см. Рис. 3.19). Они появляются там, где по мнению VB вы можете пожелать создавать другие пункты меню. Сравнив местоположение этих полей с заданным местоположением пунктов меню на Рис. 3.17, сделаем вывод, что на месте правого поля должен быть текст «О программе», а на месте нижнего – «Прозрачный».
Рис. 3.19
Введя текст «Внешний вид», щелкните по правому полю и введите текст «О программе». При этом появятся новые поля с текстом Type Here (см.Рис. 3.20). Взглянув на Рис. 3.17, мы понимаем, что они нам не понадобятся.
Рис. 3.20
Введя текст «О программе», снова щелкните по полю с надписью «Внешний вид». При этом ниже него снова появится поле с текстом Type Here, куда мы и вводим текст «Прозрачный» (см.Рис. 3.21).
Рис. 3.21
Взглянув на Рис. 3.17, мы видим, что ниже этого поля мы должны ввести текст «Цвет полей». Когда мы его будем вводить, справа от поля «Цвет полей» появится поле со словами Type Here, в которое мы, следуя за Рис. 3.17, введем текст «Желтый» (см. Рис. 3.22), а ниже текста «Желтый» – текст «Белый», оставив без внимания другие поля.
Рис. 3.22
Все в порядке – внешний вид меню готов. Запустите проект. Вы видите, что задуманное меню появилось на калькуляторе. Пощелкайте по пунктам. Вложенные меню выпадают, как положено, но больше, естественно, ничего не происходит. Для того, чтобы происходило, нужно заставить меню работать, а для этого нужно для каждого пункта написать свою процедуру.
Создаем проект
Теперь вам нужно сообщить компьютеру, что вы хотите создать новый проект на языке VB. Ваши действия: File ® New ® Project. Перед вами возникает диалоговое окно (см. Рис. 1.3):
Рис. 1.3
В левом поле вы выбираете Visual Basic Project в знак того, что хотите создавать проект именно на языке VB. В правом поле вы выбираете Windows Application (Приложение Windows) в знак того, что собираетесь создавать обычную программу, которая должна работать на вашем настольном компьютере или ноутбуке под управлением Windows в обычном окне. В этом поле вы могли бы выбрать, например, создание программы для работы в Интернете или что-нибудь другое.
Чуть пониже, в поле Name компьютер предлагает нам название вашего будущего проекта и одноименной папки, в которой он будет сохраняться – WindowsApplication1, а еще ниже, в поле Location компьютер предлагает папку, в которой будут храниться папки всех ваших будущих проектов – E:\Documents and Settings\Sergey Lukin\My Documents\Visual Studio Projects. Если вы сейчас нажмете ОК, то внутри этой папки тут же будет создана папка WindowsApplication1 и в ней немедленно появятся все необходимые файлы, которые и будут составлять ваш будущий проект.
Если вам не нравится папка Visual Studio Projects, то вы можете выбрать другую кнопкой Browse (неопытным не рекомендую).
Но мы щелкать на ОК все равно пока не будем, так как нам нужно придумать более подходящее, чем WindowsApplication1, имя для проекта. Поскольку смысл его, как я наметил, будет заключаться в том, чтобы «покрасить» некую «форму, то и введем в поле Name название Красим форму, после чего и нажмем ОК. Проект теперь будет храниться в папке с этим названием.
Перед вами возникнет следующая картинка (Рис. 1.4), говорящая о том, что вы можете приступать к проектированию (внешний вид картинки у вас может быть немножко другой).
Рис. 1.4
В заголовке окна вы теперь видите слова Microsoft Visual Basic.NET. Это означает, что среда разработки программ Visual Studio .NET приняла одно из своих обличий, а именно стала Средой разработки программ на VB. Если бы вы создавали проект на C++ .NET, то VS надела бы другую маску и выглядела бы немного по-другому.
Перейдите в Windows и проверьте содержимое появившейся папки Красим форму. Вы видите, что ваш проект состоит из нескольких файлов и папок.
На будущее хочу предупредить, что, если до вас в VS уже кто-то работал, то он мог перенастроить среду так, что она в чем-то будет вести себя совсем по-другому, чем я написал. В этом случае, если вы наткнетесь на трудности, изучите предварительно Глава 4. . Во всяком случае, не рекомендую щелкать по кнопкам и пунктам меню, смысла которых вы не понимаете. Старайтесь также не отвлекаться на большое количество присутствующих на экране кнопок и окон, о которых я пока умалчиваю, чтобы не утонуть в подробностях.
Стартовая страница
Когда вы впервые запускаете VS, первое, что вы видите, это стартовая страница (Рис. 1.1 или Рис. 1.2). Открыта она на закладке My Profile («Мой профиль»). Если у вас есть какие-то предпочтения и опыт программирования, то можете здесь настроить свой профиль в среде VS, если нет – оставьте все, как есть. Рекомендую только установить фильтр Help Filter на Visual Basic, чтобы система помощи не забивала экран ненужной вам информацией по другим языкам. Если раньше вы программировали на Visual Basic 6.0, то можете здесь выбрать соответствующий профиль, тогда VS предоставит вам привычные настройки.
В следующий раз при запуске стартовая страница откроется на закладке Projects (в Visual Studio .NET 2003) или закладке Get Started (в Visual Studio .NET). Эта закладка предлагает вам выбрать для открытия один из последних проектов, с которыми вы работали, или создать новый проект, что весьма удобно.
Остальные закладки связаны с Интернет.
Если вам надоело, что при каждом запуске VS появляется стартовая страница, зайдите в закладке My Profile в список At Startup (Рис. 4.22) и выберите один из вариантов. Вот они по порядку:
Показывать стартовую страницу.
Открывать решение (проект), с которым работали последним.
Показывать окно открытия проекта.
Показывать окно создания нового проекта.
Ничего не показывать.
Рис. 4.22
Если вы соскучились по стартовой странице, то Help ® Show Start Page..
Ставим задачу
Пусть нам нужно создать меню, которое выглядит так, как на Рис. 3.17.
Рис. 3.17
Меню, которое располагается непосредственно под заголовком приложения, называется главным меню. Значит, мы будем создавать главное меню.
Задачу для меню поставим такую: Щелкнув по пункту «Внешний вид», мы должны увидеть выпадающее меню из двух пунктов: «Прозрачный» и «Цвет полей». Щелкнув по пункту «Прозрачный» этого выпавшего меню, мы делаем калькулятор полупрозрачным. Наведя мышку на пункт «Цвет полей», мы должны увидеть другое выпадающее меню из двух пунктов: «Желтый» и «Белый». Щелкнув по пункту «Желтый», мы красим все три текстовые поля в желтый цвет, щелкнув по пункту «Белый» – в белый. Щелкнув по пункту «О программе», мы вызываем сообщение с кратким описанием программы.
Нам предстоит сначала создать меню, а затем
заставить его работать.
Строковые переменные
Переменные величины могут быть не только числовыми. Следующий тип переменных, с которым мы познакомимся, это строковые переменные. Строковые переменные очень важны. Без них, например, невозможен разговор с компьютером. Да и вообще, значительная часть информации, с которой работает компьютер – текстовая (то есть строковая).
Свойства формы
WindowState (состояние окна). Определяет, в каком виде возникает на экране форма при запуске проекта: в нормальном, в минимизированном (то есть вы найдете ее на панели задач Windows) или максимизированном (во весь экран).
StartPosition (стартовая позиция). Определяет, в каком месте экрана возникает форма при запуске проекта. Так, вы можете заставить ее появиться в центре экрана (CenterScreen) или предоставить себе возможность вручную (Manual) настраивать место появления формы при помощи свойства Location (см. следующий раздел).
MaximizeBox (кнопка максимизации – квадратик в правом верхнем углу формы). Сейчас значение этого свойства – True (Правда). Если установить его в False (Ложь), то квадратик станет недоступен. Свойство FormBorderStyle может совсем убрать этот квадратик.
MinimizeBox (кнопка минимизации – горизонтальная черточка в правом верхнем углу формы). Сейчас значение этого свойства – True (Правда). Если установить его в False (Ложь), то черточка станет недоступна. Свойство FormBorderStyle может совсем убрать эту черточку.
MinimumSize (минимальный размер). Устанавливает минимальную ширину и высоту формы, меньше которых форму нельзя уменьшить как в режиме [run], так и в режиме проектирования.
MaximumSize (максимальный размер). Устанавливает максимальную ширину и высоту формы, больше которых форму нельзя увеличить как в режиме [run], так и в режиме проектирования.
Icon (значок, пиктограмма, иконка). В левом верхнем углу формы вы видите значок. Его же вы видите на панели задач, когда проект запущен. Если он вам не нравится, вы можете его заменить на другой. Щелкните по свойству Icon. В поле значения появилась кнопочка с троеточием. Щелкните по ней – перед вами появится привычное вам окно открытия файла. Множество иконок вы можете найти в нем по адресу
Program Files\Microsoft Visual Studio .NET\Common7\Graphics\icons
ShowInTaskbar (показывать значок на панели задач). Вы можете запретить значку формы появляться на панели задач, установив это свойство в False.
Opacity (непрозрачность). Очень живописное свойство, которого не было в предыдущих версиях Visual Basic. Сейчас оно установлено в 100% и форма после запуска проекта полностью и привычно непрозрачна. Установите его, например, в 50% и запустите проект. Форма станет полупрозрачной (см. Рис. 3.10).
Рис. 3.10
При значении 0% форма будет невидима полностью. В 12.9мы поставим задачу материализации привидений, а сейчас вы вполне можете сделать полупрозрачным наш Калькулятор. А что – очень удобно!
Свойства из окна свойств
Начнем в режиме проектирования совершенствовать и украшать наш калькулятор. Для этого нам понадобится изменять некоторые другие свойства формы, кнопок, текстовых полей, меток – объектов, из которых калькулятор сконструирован. Рассмотрим эти свойства. Многие из них имеются и у большинства других элементов управления, некоторые – только у одного-двух. Прочтя материал об очередном свойстве, вам надлежит тут же поэкспериментировать, проверить, как его различные значения влияют на вид и поведение объектов проекта в режиме [run].
Добрый совет: После нескольких экспериментов ваш проект будет напоминать помесь попугая с дикобразом. К тому же у объектов очень много и других свойств, которые я не объясняю, а природная любознательность толкнет вас «поперед батьки» разобраться, что они значат, придавая им для этого наугад какие-нибудь значения. Нет проблем – ломайте голову и проект на здоровье. Проблема же в том, что кое-кто норовит сохранить проект с измененными значениями неведомых свойств. А потом не может обломать попугаю рога. Выход такой. Перед началом экспериментов скопируйте папку проекта. И экспериментируйте над копией. «Чувство защищенности!».
Свойства текстового поля
Multiline (многострочное). Когда вы создаете текстовое поле, значение этого свойства – False. Это значит, что в текстовое поле нельзя ввести больше одной строки текста и высоту поля нельзя сделать больше, чем в одну строку. Если установить его в True, то все это становится можно. Установите. Увеличьте высоту поля. Попробуйте поработать. В режиме [run] такое текстовое поле ведет себя, как окно документа простейшего текстового редактора. Введите в него несколько строк произвольного текста. Правая клавиша мыши позволяет осуществлять простейшие операции редактирования.
WordWrap (свертывание). Сейчас значение этого свойства – True. Это значит, что когда при вводе строки в многострочное текстовое поле текст доходит до правого края поля, ввод, как мы и привыкли, автоматически продолжается с начала следующей строки. Если установить его в False, то ввод будет продолжаться в той же строке с прокруткой текста.
ScrollBars (полосы прокрутки). Чтобы легче было прокручивать текст в многострочном текстовом поле, вы можете снабдить его вертикальной полосой прокрутки, а если свойство WordWrap установлено в False, то и горизонтальной.
ReadOnly (только для чтения). Когда вы создаете текстовое поле, значение этого свойства – False. Если установить его в True, то вы не сможете вводить туда информацию вручную, а только программным путем. Я думаю, имеет смысл установить это свойство в True текстовому полю, предназначенному для результата, в вашем Калькуляторе. Правда, при этом оно изменит цвет, но вы снова сможете его восстановить, задав свойство BackColor.
CharacterCasing (регистр). Вы можете заставить все буквы в текстовом поле быть только заглавными или только строчными, несмотря на то, что вводите вы в него (с клавиатуры или программно) и те и другие.
Типы переменных в VB
Типы Integer и Double. Много ли прав на нашем балу у барона Integer? Посмотрим. Попробуем ввести дробное значение длины прямоугольника – две целых одну десятую – 2,1. Именно так – с запятой, а не точкой. (Я полагаю, что ваш Windows настроен на Россию, где в дробных числах пишут запятую. В противном случае вам нужно писать точку, как это делают на Западе, причем не только в тексте программы, но и в текстовых полях). Посмотрим результат. VB при вычислениях считает a целым числом 2. А теперь – 2,8. VB считает a целым числом 3. Все правильно. Наш барон, как ему и положено, высокомерно отказывается быть дробным числом и поэтому любое число, которое мы ему предлагаем, округляет до целого. Так устроен тип Integer.
Предположим, мы этим недовольны. Мы желаем, чтобы все числа могли быть и дробными тоже. Пожалуйста! Для этого достаточно всех гостей объявить князьями. Изменив оператор Dim вот так:
Dim a, b, S, p As Double
Оператор объявления
| Dim | a, b, S, p | As | Double |
переводится так:
| Объявляю | a, b, S, p | как | десятичные дроби двойной точности |
то есть вы обязуете VB обращаться с переменными величинами a, b, S, p, как с десятичными дробями и ничем иным. Десятичная дробь – это не только число, меньшее единицы. Нет – это вообще любое число, которое может иметь целую и дробную часть (например, 27,3908). В частности это и любое целое число. О смысле двойной точности попозже.
Законный вопрос: зачем нам нужен тип Integer, когда тип Double очевидно «гораздо богаче и лучше»? Ответ: Не во всем и не всегда он лучше, иначе не стали бы его создавать вообще. Подробнее об этом – в 5.4.5.
Список типов VB. На бал к VB вхожи не только бароны и князья, то есть типов переменных в VB довольно много и каждый полезен по-своему. Рассматривать новые типы я буду по мере надобности. Вот какие типы данных вы найдете в этой книжке:
| Тип | Описание | Ссылка | |||
| Byte | Целое число – очень короткое, положительное (от 0 до 255) | 5.4.3 | |||
| Short | Целое число – короткое (от -32768 до 32767) | 5.4.3 | |||
| Integer | Целое число – обычное (от -2147483648 до 2147483647) | 5.4.3 | |||
| Long | Целое число – длинное (от -9223372036854775808 до 9223372036854775807) | 5.4.3 | |||
| Single | Десятичная дробь обычной точности | 5.4.4 | |||
| Double | Десятичная дробь двойной точности | 5.4.4 | |||
| Decimal | Десятичная дробь длинная, абсолютной точности | 5.4.5 | |||
| Char | Символ (любой из 65536 знаков, букв, цифр и других символов) | 19.1.2 | |||
| String | Строка (произвольный текст) | 19.1 | |||
| Boolean | Логический тип (истина – ложь) | 7.5.4 | |||
| Date | Дата и время | 13.1 | |||
| Массивы | Глава 15. | ||||
| Enumerations | Перечисления. Типов перечислений много и все с разными именами. | 13.3 | |||
| Structures | Структуры – пользовательские типы. Типов структур много и все с разными именами. | 16.3 | |||
| Классы | Типов классов огромное количество и все с разными именами. | 21.4 | |||
| Object | Объект – всеобъемлющий тип-хамелеон | 11.5.1 |
Для каждого из упомянутых в таблице типов вы можете объявлять переменные при помощи оператора Dim.
Toolbox
Взгляните на Рис. 1.5. В окне Toolbox имеются закладки Data, Components, Windows Forms и в нижней части окна – другие. В закладках расположены элементы управления. Наибольшая их часть расположена в закладке Windows Forms. Закладки не очень похожи на обычные закладки и ведут себя непривычно: разъезжают вверх-вниз. Но ничего, привыкнуть можно.
Обычно все элементы управления в закладке Windows Forms не помещаются по высоте окна Toolbox. Чтобы добраться до непоместившихся, прокручиваем окно черными треугольными стрелочками в верхней и нижней частях окна.
Вы можете таскать элементы управления вверх-вниз по окну Toolbox, размещая их удобным вам образом. Щелкните правой клавишей мыши по поверхности окна и в появившемся контекстном меню выберите Sort Items Alphabetically. Элементы управления расположатся в алфавитном порядке. Не выбирайте Cut и Delete, не то Toolbox лишится элементов управления.
Если Toolbox вашего компьютера слишком узкий или широкий, вы можете перетащить мышкой его границу.
В стандартном наборе элементов управления в окне Toolbox отсутствуют многие полезные и приятные элементы управления. Чтобы поместить на Toolbox нужный вам элемент управления, выберите в контекстном меню Toolbox пункт Add/Remove Items. Появляется окно Customize Toolbox (см. Рис. 4.16).
Рис. 4.16
В закладке .NET Framework Components
(новые компоненты) или COM Components (старые компоненты) вы в длинном списке ставите галочку там, где она еще не поставлена, напротив нужного элемента. Затем – ОК. Соответствующий элемент управления оказывается в окне Toolbox. Теперь его можно размещать на форме обычным образом.
Tools
Здесь нам интересен пункт Options, который позволяет настраивать среду VS, то есть регулировать внешний вид и поведение окон, панелей инструментов и других элементов среды. Будьте осторожны и не меняйте настроек, которых вы не понимаете, иначе VS будет вести себя непривычным или неприятным образом. Некоторые настройки вступают в действие не сразу, а только после перезагрузки VS.
Загляните в пункт Options (Рис. 4.23).
Рис. 4.23
Слева вы видите список основных страниц, каждая из которых посвящена той или иной стороне настройки среды. Страницы сгруппированы в папки. Рассмотрим те, что могут представить интерес для начинающих.
Страница General папки Environment. На Рис. 4.23 вы видите страницу General
(Общая) из папки Environment (Среда). Верхний переключатель позволяет вам выбрать для центральной группы окон один из двух способов представления окон: с закладками, к которому вы уже привыкли в VS (Tabbed Documents), и без закладок – тот, к которому вы привыкли в других приложениях Windows (MDI environment), когда окна могут перемещаться независимо друг от друга. Вы помните, что в других группах окон вы делаете выбор между этими двумя способами при помощи их контекстного меню – Dockable – Floating.
Справа (At startup) вы видите список того, чем вас встречает VS при загрузке. Вы его уже видели на Рис. 4.22, там же он и описан.
Флажок Show status bar заведует появлением в нижней части экрана строки состояния. Снимите его, если вам не хватает места на экране.
Следующий флажок с регулятором позволяют регулировать скорость «выползания» из-за края экрана окна Toolbox и других окон с включенным Auto Hide.
Страница Fonts and Colors папки Environment. На Рис. 4.24 вы видите страницу Fonts and Colors (Шрифты и цвета) из папки Environment. Она позволяет выбрать шрифты и цветовое оформление окон, предназначенных для текстовой информации.
Рис. 4.24
Сначала в поле Show settings for мы выбираем окно или тип окон, для которого будем настраивать шрифты и цвета. На рисунке выбран Text Editor, то есть попросту окно кода (а, например, для настройки окна Output нам понадобится Text Output Tool Windows). В полях Font и Size мы выбираем шрифт и размер шрифта для этого окна. Установив флажок Bold, мы делаем шрифт полужирным.
Теперь займемся цветом. В поле Display items мы выбираем элемент окна, для которого будем настраивать цвет. Так, Text означает основной текст в окне кода, Selected Text – выделенный текст, а Keyword – ключевые (зарезервированные, служебные) слова VB (вы привыкли видеть их синими). В списках Item foreground (цвет переднего плана) и Item background (цвет заднего плана) мы настраиваем соответственно цвет самого текста и цвет фона для этого текста. Кнопки Custom позволяют настроить цвет более тонко.
Поле Sample позволяет нам видеть результат наших настроек.
Страница Projects and Solutions папки Environment. На Рис. 4.25 вы видите страницу Projects and Solutions (Проекты и решения) из папки Environment.
Рис. 4.25
В поле Visual Studio Projects location мы вручную пишем или при помощи кнопки Browse выбираем папку, в которой VS будет по умолчанию сохранять новые проекты. По умолчанию означает, что человек не вмешается и не выберет другой вариант.
Если вам не нужно, чтобы при каждом запуске проекта на выполнение появлялось окно Output, а при ошибках во время запуска появлялось окно Task List, то снимите следующие два флажка.
Переключатель Build and Run Options определяет, будет ли VS перед любым запуском проекта на выполнение автоматически сохранять проект (Save changes to open documents), предлагать сохранить проект (Prompt to Save Changes to open documents) или не сохранять (Don't save changes to open documents). Беспечным советую первое.
Папка Projects. Здесь мы включаем или отключаем опцию Option Explicit (см. 5.2.4) и две другие опции.
Страница General папки Windows Forms Designer. Здесь мы устанавливаем расстояние между линиями сетки на форме по горизонтали и вертикали (Grid Size) и имеем возможность скрывать или показывать эту сетку (Show Grid). Установив в True опцию SnapToGrid, мы приказываем, чтобы очертания элементов управления проходили только по линиям сетки.
Третий этап - инсталляция
Инсталляцию вообще я уже вкратце описал в начале раздела. Начнем с того, что в качестве эксперимента проведем инсталляцию на том же компьютере, на котором вы создавали инсталляционный пакет.
1. Сделайте двойной щелчок мышкой по файлу Мой калькулятор.msi. Инсталляция запустилась. Появившееся окно мастера установки (Рис. 4.40) предупреждает, что тот, кто установит эту программу без вашего разрешения, сядет в тюрьму. После этого с легким сердцем можете нажимать Next.
Мастером называется программа, позволяющая пользователю делать сложные вещи с минимальной затратой умственных сил. Обычно работа мастера состоит из нескольких шагов, на каждом из которых мастер задает пользователю вопросы. Переход к следующему шагу осуществляется кнопкой Next. Вернуться назад вы можете кнопкой Back, прервать установку – кнопкой Cancel.
Рис. 4.40
2. В следующем окне (Рис. 4.41) вам предлагается адрес папки, в которую будет устанавливаться ваша программа. Если он вам не нравится, нажмите кнопку Browse и выберите нужную папку или впишите адрес в текстовое поле. При помощи переключателя внизу задайте, кто будет пользоваться этой программой: все пользователи компьютера (Everyone) или только вы (Just me). Next.
Рис. 4.41
3. Следующее окно (Confirm Installation) предлагает вам на всякий случай подтвердить, что вы хотите начать инсталляцию (ведь это связано с записью файлов на компьютер и бог знает чем может закончиться). Next.
4. Идет процесс установки (Рис. 4.42).
Рис. 4.42
5. Последнее окно сообщает, что установка завершена (Installation Complete). Можно нажимать Close.
Программа установилась. Теперь можете запускать ее из стартового меню «Пуск», там появился необходимый ярлык.
Вам будет полезно заглянуть в папку Мой калькулятор в папке Program Files, куда установилась ваша программа, и обнаружить там запускающий файл Калькулятор.exe и графический файл Earth.JPG.
Инсталляция на другом компьютере.
Чтобы установить вашу программу на другом компьютере, скопируйте любым способом инсталляционный файл Мой калькулятор.msi на диск этого компьютера и запустите его там (скопировать вы можете, например, при помощи сети или дискеты, или CD-RW).
Проблема на сегодняшний день (начало 2005) состоит в том, что далеко не на каждом компьютере инсталляция может успешно осуществиться. Однако эта проблема должна уйти в прошлое, как только .NET Framework станет стандартной составной частью Windows.
Усложняем проект
Закройте проект ошибок. Скопируйте папку проекта «Красим форму» тут же, рядышком с собой внутри папки Visual Studio Projects. Переименуйте как-нибудь скопированную папку, например, «Красим форму 1». Над копией будем продолжать работу. Откройте проект из этой папки. Это можно сделать в Windows двойным щелчком по файлу проекта или решения. Обратите внимание, что от изменения названия папки имя проекта не изменилось.
Усложним проект. Пусть при щелчке по кнопке Button1 происходит что-нибудь еще, кроме изменения ширины полосы прокрутки, а именно три вещи:
В текстовом поле TextBox1 появляется текст Ширина полосы = 100
Исчезает второй элемент переключателя (RadioButton2).
Вторая кнопка (Button2) окрашивается в желтый цвет.
Для этого достаточно в процедуру добавить 3 оператора. Начнем по порядку.
Меняем текст в TextBox1. У текстового поля TextBox1 есть свойство Text, значением которого является текст в этом поле. Поэтому добавим в процедуру оператор
TextBox1.Text = "Ширина полосы = 100"
Запомните: В окне кода значение свойства Text для текстового поля и других объектов должно браться в двойные кавычки.
Привыкайте к похожим обозначениям в VB разных вещей (у нас это TextBox1 и Text) и будьте внимательны. Наш оператор можно перевести так: Содержимое текстового поля TextBox1 сделать таким – Ширина полосы = 100.
Не думайте, что смысл слов Ширина полосы = 100 что-то значит для компьютера. Во-первых, он по-русски не понимает, а во-вторых, что бы ни было написано внутри двойных кавычек, он в это не вдумывается и как приказ не воспринимает, а просто воспроизводит в текстовом поле. Чтобы проверить, можете написать внутри кавычек любую абракадабру и запустить проект.
Вот что у нас должно получиться:
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
TextBox1.Text = "Ширина полосы = 100"
End Sub
End Class
Для экономии места по вертикали я стер здесь пустые строки. И вам тоже не возбраняется.
Запустим проект. Нажмем кнопку Button1. При щелчке по кнопке Button1 VB выполнит по порядку все операторы процедуры между строками Private Sub Button1… и End Sub. Убедимся, что оба оператора выполнились. Поскольку компьютер работает очень быстро, нам будет казаться, что оба оператора выполнились одновременно. Но это не так: сначала поменялась ширина полосы прокрутки, а уж затем текст в текстовом поле.
Измените вручную текст в текстовом поле. Снова нажмите кнопку Button1. Что произошло? Завершите выполнение проекта.
Исчезает RadioButton2. Для исчезновения элемента RadioButton2 достаточно дописать в процедуру такой оператор:
RadioButton2.Hide()
Пояснение: Кроме свойств, объекты обладают и так называемыми методами. Метод – это то, что данный объект умеет делать. Вспомним пример с игрушечной железной дорогой. Там были объекты: паровозы, светофоры, стрелочники и т.п. У паровоза могут быть такие методы: ехать, гудеть, выпускать пар … У светофора – зажигать красный, зажигать зеленый … У стрелочника – переводить стрелку, петь песни … Команды паровозу и стрелочнику могли бы звучать так:
Паровоз . гуди
Стрелочник . переводи стрелку
Поскольку «Hide» по-английски означает «прятаться», то оператор RadioButton2.Hide() означает не что иное, как приказ элементу RadioButton2 спрятаться, сделаться невидимым. Говорят, что выполнился метод Hide объекта RadioButton2. На скобки ( ) пока внимания не обращаем. О них позже.
Многие методы называют функциями. Но и об этом тоже позже.
Запишите оператор, запустите проект, проверьте его работу.
Красим Button2. Теперь нам нужно покрасить кнопку Button2 в желтый цвет. Приведу аналогию. Чтобы покрасить в желтый цвет газету, мы бы написали так:
Газета . цвет = желтый
Однако это было бы неточно, так как слово «желтый» может иметь переносный смысл – «желтая пресса». Поэтому лучше было бы написать так:
Газета . цвет бумаги = желтый
Однако и это было бы неточно, так как желтая краска из разных коробочек с красками может иметь разные оттенки. Поэтому лучше было бы написать так:
Газета . цвет бумаги = Коробка №5 . желтый
Теперь не спутаешь.
Компьютер тем более требует точности, поэтому нужный нам оператор мы пишем так:
Button2.BackColor = Color.Yellow
Пояснение: Здесь BackColor – свойство объекта Button2. Оно означает цвет поверхности кнопки. (А есть еще, например, ForeColor – цвет букв на кнопке.) Слово Yellow переводится «желтый». А слово Color, которое стоит перед ним – не что иное, как название «коробки с красками». Не путайте близкие по написанию, но абсолютно разные по смыслу слова: Color и BackColor. А также пусть не обманывает вас их буквальный перевод с английского. Не спрашивайте также меня, что значит с точки зрения VB «коробка с красками». Завтра, завтра, не сегодня!
Вот как теперь выглядит ваша процедура:
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
HScrollBar1.Width
= 100
TextBox1.Text
= "Ширина полосы = 100"
RadioButton2.Hide()
Button2.BackColor
= Color.Yellow
End Sub
Запустите проект, нажмите кнопку Button1. Вы должны увидеть такую картинку (Рис. 1.20).
Рис. 1.20
Вглубь пространства имен
Аналогия. До сих пор все, что мы достигали в VB, нам удавалось легко. Захотели укоротить полосу прокрутки – раз! – и коротенькой строкой кода это сделали. Захотели спрятать элемент переключателя – раз! – и сделали это строкой, состоящей вообще из двух слов. Вам достаточно было знать простое название «инструмента», которым вы добивались цели – Width, Hide и т.д.
Но не все в VB делается так просто.
Помните сказку, где Ивану-царевичу нужно было разделаться с Кащеем Бессмертным? Для этого ему надо было переломить иглу. Но добраться до этой иглы было довольно трудно, потому что игла-то – в яйце, а яйцо – в утке, а утка – в зайце, а заяц – в ларце. Если ларец у вас в руках и вы знаете устройство этой «матрешки», тогда – другое дело. Вернее, полдела. Полдела, но не все дело. Потому что заяц из ларца выпрыгнет – его надо догнать, утка из зайца выскочит, да в небо – ее надо подстрелить и т.п. В общем – морока. Так ведь и не зря же! Через эту мороку мы многое поймем в программировании на VB.
Если вы хотите в VB что-нибудь совершить какой-нибудь заковыристой «иглой», то, чтобы ее найти, вам нужно будет проделать весь путь вглубь «ларца». Мы уже отчасти столкнулись с этой ситуацией, когда в поисках «иглы» Yellow вместо простого
Button2.BackColor = Yellow
нам пришлось писать более сложное
Button2.BackColor = Color.Yellow.
Здесь дополнительное слово Color – и есть то «яйцо», в котором находилась «игла» Yellow. Правда, «утку» и прочее VB нам простил, не потребовал. Но не всегда он бывает таким добрым. Нам нужно точно знать, как добраться до нужной «иголки». А также, когда нас прощают, а когда нет. И об этом наш разговор.
Вглубь ларца. При программировании для платформы .NET «ларцом» является как раз упомянутая Библиотека классов .NET Framework. Открыв крышку этого ларца, мы увидим внутри два других ларца. Они называются пространствами имен. (не будем пока вникать в буквальный смысл этого названия, ибо сказано: «Хоть горшком назови, только в печь не сажай!»). У каждого пространства имен есть свое имя. Одно из двух упомянутых называется System, а другое – Microsoft. Каждое из них – настоящая кладовая возможностей!
Создайте новый проект. Проделаем сейчас весь путь вглубь наших ларцов.
Чтобы узнать, что находится внутри у пространств имен System и Microsoft, достаточно написать их имя с точкой. Создайте кнопку, дважды щелкните по ней. В получившейся заготовке процедуры мы и будем пробовать что-нибудь написать.
View
Это меню нужно в основном для того, чтобы показывать окна и панели инструментов, и состоит главным образом из названий этих окон и панелей. Щелчок по нужному пункту – и окно или панель появляется на экране.
Второй этап – создание инсталляционного пакета
Итак, у нас имеется проект Калькулятор, готовый к тому, чтобы из него можно было создавать инсталляционный пакет. В среде VS инсталляционный пакет создается так. Прежде всего создается некий новый проект особого типа, который будет инструментом для получения из проекта Калькулятор инсталляционного пакета. Затем программист производит в этом новом проекте определенные действия по настройке будущего инсталляционного пакета. Затем этот новый проект компилируется обычным образом. Результатом компиляции и является инсталляционный пакет.
Рассмотрим эти шаги по порядку.
Создаем инсталляционный проект. Запустите VS. Затем File ® New ® Project ® в левом поле окна создания проекта (Рис. 4.30) выберите Setup and Deployment Projects, а в правом – Setup Project ® придумайте название для инсталляционного проекта, например, Мой калькулятор.® OK.
Рис. 4.30
Инсталляционный проект и решение созданы. Инструмент создан (Рис. 4.31).
Рис. 4.31
Если бы вы собирались инсталлировать Web-приложения, то вам нужно было бы выбрать Web Setup Project.
Добавляем нужный проект. Теперь инструменту нужно объяснить, над чем он должен трудиться, чтобы получить инсталляционный пакет. Этим «предметом труда» и будет как раз наш проект Калькулятор. Нужно просто добавить проект Калькулятор в решение. Делается это привычным образом: File ® Add Project ® Existing Project ® …
Таким образом, наше решение теперь состоит из двух проектов: инсталляционного проекта Мой калькулятор и самого проекта Калькулятор (Рис. 4.32). Очевидно, эти проекты не могут иметь одинаковые имена, иначе VB спутается. Более подробно о нескольких проектах в решении и о Solution Explorer написано в 21.3.
Рис. 4.32
Определяем содержание будущей инсталляции. Следующий шаг. Выделите в Solution Explorer проект Мой калькулятор. Далее: Project ® Add ® Project Output. Перед вами возникнет окно (Рис. 4.33).
Рис. 4.33
Проследите, чтобы вся информация в полях окна была такая же, как на рисунке. В этом окне мы указываем, что инсталляционный пакет нужно создавать именно для проекта Калькулятор (верхнее поле), и определяем содержание работы инсталляционного пакета (список в центре окна). Выделенный элемент Primary output означает, что результатом инсталляции будет то главное, что требуется, а именно: исполняемый файл приложения (exe) или библиотека (dll). Однако результатом инсталляции могут быть и другие, вспомогательные объекты, например, файлы с исходным кодом программы. При необходимости вы можете выделить в списке все элементы, но сейчас нам достаточно Primary output.
Нажмите ОК. В окне Solution Explorer проект Мой калькулятор начал наполняться содержанием (Рис. 4.34).
Рис. 4.34
Окно File System. Поговорим о структуре окна File System нашего инсталляционного проекта Мой калькулятор, которое вы видите на рисунке. Оно позволяет производить определенную настройку инсталляции. В его левой панели вы видите схематическое изображение некоторых (имеющих отношение к инсталляции) элементов файловой системы компьютера, на который будет устанавливаться приложение. Вот смысл этих элементов:
|
File System on Target Machine |
Файловая система компьютера, на который будет устанавливаться приложение |
|
Application Folder |
Папка приложения |
|
User’s Desktop |
Рабочий стол пользователя |
|
User’s Programs Menu |
Программы в стартовом меню пользователя |
Убираем производителя. Займемся настройкой папки приложения. Выделите элемент Application Folder и зайдите в окно свойств. Значением свойства DefaultLocation (Расположение по умолчанию) является некая условная схема:
[ProgramFilesFolder][Manufacturer]\[ProductName]
Она означает, что файлы инсталлируемого приложения по умолчанию располагаются на компьютере в папке с названием этого приложения (ProductName), которая располагается внутри папки с именем производителя приложения (Manufacturer) , которая располагается внутри папки Program Files. Вы можете оставить все как есть, а можете, если знаете механику этой схемы, что-то изменить. Давайте, например, выкинем производителя. Получится вот что:
[ProgramFilesFolder]\[ProductName]
Ярлык в меню «Пуск».Теперь позаботимся о том, чтобы в стартовом меню пользователя оказался ярлык нашего приложения, иначе пользователь не сможет запускать наше приложение из стартового меню. Для этого, выделив в левой панели элемент Application Folder, щелкните правой клавишей мыши по элементу Primary output в правой панели и в контекстном меню выберите Create Shortcut to Primary output. Ярлык с длинным названием добавляется в папку приложения (Рис. 4.35).
Рис. 4.35
Там ему делать нечего, перетащите его в папку User’s Programs Menu, а там переименуйте во что-нибудь более удобоваримое и короткое, например, в Калькулятор.
Добавляем файлы в папку приложения. Если в коде вашего проекта Калькулятор есть ссылки на какие-нибудь внешние файлы, о чем я говорил в предыдущем подразделе, то эти файлы должны быть включены в инсталляционный пакет. Пусть в коде проекта Калькулятор есть такой оператор:
Кл_деления.Image = Image.FromFile("Earth.JPG")
Это значит, что в папке BIN внутри папки проекта Калькулятор имеется графический файл Earth.JPG, которым проект пользуется во время работы. Этот файл необходимо включить в инсталляционный пакет. Для этого выделяем в Solution Explorer проект Мой калькулятор, затем Project ® Add ® File ® находим на диске файл и делаем по нему двойной щелчок. Файл оказывается в папке приложения (Рис. 4.36). После инсталляции на компьютер пользователя он окажется там тоже в папке приложения.
Рис. 4.36
Добавляем файлы в другие папки. Если вы хотите, то можете сделать так, чтобы при инсталляции какие-то другие нужные вам файлы добавлялись не в папку приложения, а в другие папки на компьютере пользователя. Щелкните правой клавишей мыши по элементу File System on Target Machine и в контекстном меню выберите одну из предложенных папок, например, Windows Folder. Она появится в окне File System рядом с другими (Рис. 4.37).
Рис. 4.37
Теперь добавьте в папку приложения несколько нужных вам файлов, а затем перетащите их оттуда в папку Windows Folder. После инсталляции они появятся на компьютере пользователя в папке Windows (чего я делать, в общем, не рекомендую).
Значок приложения. Если вы хотите, чтобы запускающий файл вашего приложения имел значок, отличающийся от надоевшего стандартного значка запускающих файлов, проделайте следующее. Щелкните правой клавишей мыши в окне Solution Explorer по проекту Калькулятор и в контекстном меню выберите Properties. В появившемся окне свойств (Рис. 4.38) выберите Build. Нажав на кнопку с троеточием, выберите подходящую пиктограмму. Затем ОК.
Рис. 4.38
Это не значит, что на панели задач ваше приложение будет иметь этот значок. Для этого нужно, как написано в 3.4.3, установить соответствующим образом свойство Icon формы.
Настраиваем конфигурацию. Ваши действия: Build ® Configuration Manager. Появляется окно (Рис. 4.39).
Рис. 4.39
Проекты могут иметь конфигурацию Debug, удобную для отладки, а могут иметь конфигурацию Release, необходимую, когда уже все отлажено и приложение выпускается (Release) в большой свет. Нам отлаживать уже ничего не надо, поэтому в верхнем списке выбираем Release. Все должно быть как на рисунке. Нажмите Close.
Компиляция. Основные необходимые настройки мы сделали. Завершающий аккорд – компиляция инсталляционного пакета. Для этого – Build ® Build Solution. Некоторое время компьютер компилирует (причем компилируются оба проекта), в окне Output появляются сообщения, наконец в строке состояния возникает сообщение Build Succeeded. Это значит, что создание инсталляционного пакета успешно завершено.
Где же он – наш инсталляционный пакет? Выйдем из VS в Windows. Заглянем в папку проекта Мой калькулятор. Там появилась папка Release. В ней вы видите среди других файлов файл Мой калькулятор.msi. Этот файл и есть наш инсталляционный пакет.
Второй способ – Imports
И все же хотелось бы быть еще лаконичнее. Оператор Imports позволяет опускать имена не только пространств имен, но и объектов, в них входящих: классов, модулей (не путать с абсолютной величиной), структур, перечислений. Поставим задачу опустить в нашей программе имена классов Debug и Math. Для этого самой верхней строкой в окне кода вы должны записать оператор Imports:
Imports System.Diagnostics.Debug , System.Math
После слова Imports через запятую перечисляются имена объектов (в нашем случае классов Debug и Math) с обязательным указанием пространств имен, в которые они входят. Вот как теперь будет выглядеть наше окно кода (для краткости я оставил в процедуре только две строки):
Imports
System.Diagnostics.Debug, System.Math
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
WriteLine(3 + 2)
WriteLine(Abs(-20))
End Sub
End Class
Как видите, теперь вместо Debug.WriteLine вы можете писать WriteLine, а вместо Math.Abs – просто Abs.
А как же теперь с двусмысленностями, когда объекты с одинаковыми именами входят в разные пространства имен? В этом случае отказывайтесь от Imports или пользуйтесь его дополнительными возможностями, на которых я не останавливаюсь.
В дальнейшем я буду писать фрагменты программ, где опуская, а где не опуская имена объектов. Там, где имена опущены, подразумевается, что использован соответствующий оператор Imports.
это новый мощный язык программирования,
Visual Basic .NET – это новый мощный язык программирования, созданный корпорацией Microsoft в начале тысячелетия. Сохранив во многом внешнюю простоту своего предшественника – языка Visual Basic 6.0 – он радикально обогатил и усложнил свое внутреннее содержание, предоставив программисту огромное количество новеньких, с иголочки, инструментов. Самый главный из них – настоящее, полноценное объектно-ориентированное программирование.
Visual Basic .NET конечно же по-прежнему чрезвычайно силен во всех областях традиционного программирования для обычных настольных компьютеров, то есть там, где был силен и Visual Basic 6.0. Но, откликаясь на веление времени, он приобрел и новую направленность – программирование в сетях. Теперь он позволяет удобно и легко писать программы для локальных сетей и Интернета, для карманных компьютеров и даже для мобильных телефонов.
Visual Basic .NET – это производительное и надежное оружие в руках профессионального программиста. К тому же очень удобное и, несмотря на мощь, достаточно простое. Поэтому Visual Basic .NET более других профессиональных языков подходит для освоения начинающими программистами. На написание программы уходит минимум времени. Изучив эту книгу, вы сможете быстро писать такие, например, приложения, как собственные калькулятор или проигрыватель MP3-файлов, шифровщик секретных сообщений или будильник, веб-браузер или простенькая игра…. Приложив же достаточные усилия, вы сможете создавать вполне солидные продукты, такие, например, как система управления базами данных, графический редактор или сложная, красивая игра, которую не стыдно опубликовать в Интернете.
В дальнейшем для краткости я часто буду обозначать Visual Basic .NET как VB. Иногда, впрочем, я буду писать Visual Basic или даже просто
Бейсик.
Вывод сообщений – MsgBox
Можно заставить компьютер в любой момент выполнения программы выводить нам какое-нибудь сообщение. Поместите внутрь какой-нибудь процедуры (пусть это будет процедура сложения) такой новый для нас оператор:
MsgBox ("Привет всем!")
Теперь каждый раз, как вы нажимаете на клавишу сложения, вы увидите на экране такое окно сообщения:
Прочитав сообщение, щелкните ОК. Не щелкнув, вы не сможете продолжать работать с проектом. Окно сообщения специально сделано таким назойливым, чтобы программист вынужден был обратить на него внимание и прочитать, что там написано. Для этого писать туда нужно действительно важные вещи.
Вскоре мы дадим окну сообщения реальное дело. А сейчас мы с ним только познакомились.
Какие главные моменты нужно вывести
Какие главные моменты нужно вывести из рассмотрения этих двух примеров? Их два:
1. Библиотека классов .NET Framework включает в себя колоссальное количество объектов, их свойств, методов и других элементов. До всех них можно добраться рассмотренным выше способом.
2. Разберемся в строении двух написанных операторов. Каждый из них состоит из трех частей, разделенных точками. Пойдем справа налево:
Крайняя правая часть – это свойство или метод со скобками или без.
Левее через точку идет объект – «хозяин» этого метода или свойства.
И самая левая часть – одно или несколько пространств имен, разделенных точками.
Запомните эту простейшую архитектуру. Скоро мы будем ее и укорачивать и разнообразить.
Пространство имен можно называть так: «Пространство имен Diagnostics, находящееся в пространстве имен System». А можно называть короче: «Пространство имен System.Diagnostics». Говорят еще так: «Сработал метод WriteLine объекта Debug из пространства имен System.Diagnostics».
Еще точки. Чтобы перед нами развернулся список, нам нужно начинать запись со слов System или Microsoft или с известного нам имени объекта, который входит в упомянутые пространства имен. А еще с чего? В 1.3 мы начинали запись с имени элемента управления, который уже находится на вашей форме, например, Button1. И с «местоимения» формы Me. Можно начинать и с имени проекта, но это нам пока не нужно.
Доберемся «по всем правилам» до желтого цвета. Добавьте в процедуру следующую строку:
Button1.BackColor = System.Drawing.Color.Yellow
В процессе ее ввода вы уяснили, что Color – это, оказывается, объект пространства имен System.Drawing, а Yellow – его свойство. А раньше мы писали короче. Когда можно писать короче, рассказано в следующем разделе.
Не вся библиотека классов .NET Framework в настоящий момент подключена к вашему проекту. Сделано это из экономии. Если у вас уже есть опыт и вы точно знаете, чего именно вам не хватает, вы можете быстро подключить дополнительные пространства имен из этой библиотеки (см. 21.3.1).
В дальнейшем вы увидите, что свойства и методы сами могут «быть объектами», тогда после них тоже можно ставить точку, и так до бесконечности.
Window
Здесь нам интересен пункт Split. Он позволяет смотреть на ваш код через два окна, а не через одно, что бывает удобно, когда кода много. Пусть в вашем коде содержится несколько десятков процедур. Все они, естественно, не умещаются в поле зрения и, чтобы увидеть, например, нижнюю процедуру, вам приходится окно кода прокручивать. Но тогда из поля зрения уходят верхние процедуры. Пусть вам нужно держать в поле зрения самую верхнюю и самую нижнюю процедуры одновременно. Для этого пункт Split делит окно кода на два окна, расположенных одно под другим (Рис. 4.27). В них вы видите один и тот же код, точно так же, как через два окна в вашей квартире вы видите один и тот же двор. Если вы поменяете текст кода в одном окне, вы сможете увидеть эти изменения и в другом. Каждое окно вы можете прокручивать независимо и поэтому в поле зрения направлять любой участок кода.
Чтобы снова превратить два окна кода в одно, еще раз щелкните по этому пункту (который на этот раз будет именоваться Remove Split).
Есть более быстрый способ делить окно на два и вновь соединять. Поставьте мышь в область, помеченную на Рис. 4.26 овалом.
Рис. 4.26
Мышь изменит свою форму. Тащите ее вниз. Два окна получены (Рис. 4.27).
Рис. 4.27
Чтобы вновь слить окна, таким же движением задвиньте мышь наверх.
Задание на проект «Калькулятор»
В Глава 1. мы с вами ничего путного не создали, зато прошли с начала до конца весь путь создания проекта на VB.
Сейчас мы поставим перед собой задачу сделать реальную вещь – калькулятор. Примерно такой же, какой имеется в Windows. Если вы его забыли, то в Windows (а отнюдь не в VS), выполните такие действия: Пуск ® Программы ® Стандартные ® Калькулятор. Посчитайте в нем что-нибудь. Как по вашему – много сил затратила фирма Microsoft на его создание? Калькулятор, который создадим мы, в смысле математики будет попроще, зато он будет красивым, снабжен музыкой, паролем и разными другими шутками.
Начнем с того, что придумаем нашему калькулятору внешний вид (пока скромный) – см. Рис. 3.1.
Рис. 3.1
Идея такая – вы набираете в двух верхних текстовых полях первое и второе число, затем щелкаете по одной из кнопок и в нижнем текстовом поле получаете результат.
Запись нескольких операторов в одной строке
VB допускает писать в одной строке несколько операторов, разделяя их двоеточиями. Например, вместо
Button1.Width = 200
Button2.Width = 100
Button3.Width = 140
можно написать вот так:
Button1.Width = 200 : Button2.Width = 100 : Button3.Width = 140
Это приятно экономит место по вертикали экрана.
Запускаем наши программы без VS
В Windows вы привыкли запускать игры и другие программы двумя способами: щелкнув по значку программы на рабочем столе Windows (или в папке или в проводнике) или выбрав программу в стартовом меню на панели задач. Созданные нами в VB приложения запускаются пока только из среды VS, что, возможно, уязвляет вашу гордость. Попробуем запустить их, как независимые программы, то есть без запуска VS.
Завершите работу VS. Находясь в Windows, зайдите (при помощи проводника или из значка Мой компьютер) в папку вашего проекта, например, Калькулятор. Там вы увидите несколько файлов и папок, созданных компьютером. Зайдите в папку BIN. Там вы увидите файл Калькулятор.exe. Это и есть программа вашего калькулятора, которая может запускаться без запуска VS. Запустите ее щелчком (или двойным щелчком). Она работает. Вы можете ее скопировать куда угодно или создать для нее ярлык где угодно в компьютере.
Как попал запускающий файл Калькулятор.exe в папку BIN? Когда мы запускали наш проект в VS, проект автоматически компилировался и откомпилированный файл Калькулятор.exe записывался в эту папку. Можно добиться того же и без запуска: Build ® Build Solution.
Однако, если вы попытаетесь скопировать ваш Калькулятор.exe на другой компьютер и там его запустить, то вас может ждать неудача. Здесь могут понадобиться более сложные действия, чем я описал (см.4.6).
Запускаем Visual Studio NET
Как я уже писал во введении, VB входит в состав единой программы, которая называется среда программирования Visual Studio.NET и обеспечивает программисту возможность удобной разработки программ на VB и некоторых других языках. Поэтому, чтобы программировать на VB, вам нужно запустить Visual Studio.NET. Английские слова «Visual Studio» можно вольно перевести, как «Визуальная студия», то есть то место, где художник (программист) может творить свои произведения (программы) визуально (имеется в виду 1 этап – сборка вручную).
В дальнейшем вместо слов «Visual Studio .NET» я часто для краткости буду писать VS. Не путайте VS и VB. Когда я пишу VB, я имею в виду язык программирования, все то, что связано с самой программой, с правилами написания программного текста и его смыслом. Когда я пишу VS, я имею в виду среду программирования, то есть все то, что создает удобства и возможности программирования, загрузки, сохранения программ, их просмотра и настройки взаимодействия. Аналогии: VB – это бифштекс, VS – ресторан и официанты; VB – это мозг, VS – это тело; VB – это программа, VS – это компьютер. Однако, надо признаться, что не всегда удается четко сказать, где кончается VS и начинается VB.
Если VS у вас на компьютере не установлена, читайте 4.1, а если установлена, то запускайте ее следующим образом:
Нажмите на панели задач Windows кнопку «Пуск» (Start), в появившемся меню выберите «Программы» (Programs), затем в появившемся меню – Microsoft Visual Studio.NET, а затем в появившемся меню – снова Microsoft Visual Studio.NET. (В дальнейшем вместо словесного описания щелчков мыши в меню я для краткости буду писать так: Пуск ® Программы ® Microsoft Visual Studio .NET ® Microsoft Visual Studio .NET).
Если вы впервые запускаете VS, то в результате запуска на экране появляется главное окно VS со стартовой страницей (Start Page). Если у вас установлена Visual Studio .NET 2003, то окно имеет примерно такой вид, как на Рис. 1.1.
Рис. 1.1
Если у вас установлена Visual Studio .NET, то окно имеет примерно такой вид, как на Рис. 1.2. Разница между окнами чисто внешняя.
Рис. 1.2
Если вы запускаете VS не впервые, то в главном окне может и не быть стартовой страницы или она может иметь несколько другой вид. Сейчас это не важно, стартовая страница нам пока не понадобится. В любом случае вы можете почитать о ней в 4.3.
В заголовке окна вы видите слова Microsoft Development Environment, что означает «Среда разработки программ фирмы Microsoft». Смысл этих слов такой же, что и у слов «Visual Studio».
Заставляем меню работать
Каждый пункт меню – это объект. Чтобы убедиться в этом, щелкните в режиме проектирования по пункту «Прозрачный» и загляните в окно свойств. Вы видите, что у пункта меню есть свойства, как и у других объектов. Замените его имя (Name) на Menu_Прозрачный. Это для того, чтобы им было удобнее пользоваться при программировании.
Теперь сделайте по пункту «Прозрачный» не одиночный, а двойной щелчок мышью. В окне кода возникнет заготовка процедуры, которая будет выполняться при выборе этого пункта меню:
Private Sub Menu_Прозрачный_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Menu_Прозрачный.Click
End Sub
Слова Menu_Прозрачный.Click в правой части заголовка означают, что речь идет о щелчке (Click) мыши по пункту Menu_Прозрачный. Остается написать код для выполняемого действия:
Private Sub Menu_Прозрачный_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Menu_Прозрачный.Click
Me.Opacity = 0.7
End Sub
Здесь словом Me обозначена форма, Opacity – ее свойство непрозрачности (см. 3.4.3). Число 0.7 обозначает величину 70%.
Запустите проект, проверьте работу этого пункта меню.
Аналогично организуем работу остальных 3 пунктов меню. Сначала дайте им имена: Menu_Желтый, Menu_Белый, Menu_О_программе. Затем запрограммируйте их действия в окне кода:
Private Sub Menu_Желтый_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Menu_Желтый.Click
Число1.BackColor = Color.Yellow
Число2.BackColor = Color.Yellow
Результат.BackColor = Color.Yellow
End Sub
Private Sub Menu_Белый_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Menu_Белый.Click
Число1.BackColor = Color.White
Число2.BackColor = Color.White
Результат.BackColor = Color.White
End Sub
Private Sub Menu_О_программе_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Menu_О_программе.Click
MsgBox("Калькулятор создан в 2003 году")
End Sub
В первых двух процедурах речь идет о цвете трех текстовых полей: Число1, Число2, Результат. В операторах все привычно (см. 1.3.9). В последней процедуре создается окно сообщения (см. 3.7).
Введя очередную процедуру, запускайте проект и проверяйте работу соответствующего пункта меню.
Если вам не хочется щелкать по меню мышкой, вы можете для каждого пункта меню выбрать комбинацию клавиш клавиатуры с тем же действием. Эта комбинация называется Shortcut и выбирается установкой одноименного свойства пункта меню в режиме проектирования в окне свойств.
Средствами VB можно создавать, преобразовывать и уничтожать меню, причем не только в режиме проектирования, но и в режиме работы. Но на этом я не буду останавливаться. Кроме обычных меню VB умеет создавать и контекстные меню (как это делать, рассказано в 18.9).
Знакомимся с некоторыми объектами
Для тренировки и для полезного знакомства с некоторыми функциями вам надлежит записать в процедуру еще несколько строк. Но сначала разберитесь в пояснениях, приведенных ниже, а уж потом записывайте. Вот как должна выглядеть процедура:
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
Debug.WriteLine(10 - 2 * 2 + 30 / 3)
Dim a = 4 - 3
Debug.WriteLine(a)
Debug.WriteLine(a + 1000)
Debug.WriteLine("Привет всем!")
Dim b = System.Math.Abs(-20)
Debug.WriteLine(b)
Debug.WriteLine(System.Math.Abs(-20))
Debug.WriteLine(Math.Abs(-20))
Debug.Write(Microsoft.VisualBasic.Strings.Len("Мир"))
Debug.Write(Strings.Len("Мир"))
Debug.Write(Len("Мир"))
Debug.WriteLine(Len("Война") + Math.Abs(-80) + a + 1)
End Sub
Когда вы запустите проект и нажмете кнопку, в окне Output вы увидите следующий результат:
16
1
1001
Привет всем!
20
20
20
33387
Перед тем, как вы перейдете к чтению пояснений, прочтите очень полезный совет по работе над программами:
Когда вы проверяете, как работает программа из книжки (например, только что приведенная) или как работает программа, созданная вами, никогда не вводите всю программу целиком, чтобы потом запустить ее и посмотреть, как она целиком работает. Вводите и запускайте понемножку.
Причина вот в чем. Каждый программист, даже самый опытный, при вводе программного текста допускает ошибки и просто описки. И большим грехом это не считает. На 100 строк программы ошибок 5-10 – это норма. Не все эти ошибки VB обнаружит. Поэтому, хотите вы этого или нет, запускать на выполнение вам придется программу ошибочную. Когда вы получите результаты работы ошибочной программы, они тоже, конечно, будут ошибочными. И вам, глядя на эти результаты, предстоит догадываться, в чем ошибки состоят. Трудно искать ошибки в длинной программе, да еще когда их там несколько!
Делайте так. Ввели первые две- три строки программы, запустили проект, посмотрели результаты, проверили, правильные ли они или хотя бы правдоподобные ли. Если все в порядке, вы можете быть спокойны: в этих строках ошибок скорее всего нет. Добавили к ним следующие две-три строки, снова запустили проект, проверили. И так далее. Каждый раз, натыкаясь на ошибочный результат, вы можете быть почти уверены, что причина его – в последних 2-3 строках программы.
Еще одна причина: так легче изучать материал из книжки. Чтобы не сломать зубы о гранит науки, от него нужно откусывать понемножку.
Учитывая все это, переходите к чтению пояснений, параллельно вводя по одной строчке кода и запуская проект.
Пояснения к первым 5 строкам:
Debug.WriteLine(10 - 2 * 2 + 30 / 3)
Этот оператор выводит первое число (16). После слова WriteLine
вы обязаны поставить скобки и в скобках указать, что именно вы хотите вывести. Здесь звездочка * обозначает умножение, а косая черта /
(slash) – деление. Таким образом, в скобках, стоящих за именем метода WriteLine, можно писать любое арифметическое выражение.
Dim a = 4 - 3
Здесь мы объявляем (Dim) переменную величину a и задаем ей значение 4-3 = 1.
Debug.WriteLine(a)
Значение a, равное 1, выводится в окно Output. Таким образом, в скобках, стоящих за именем метода WriteLine, можно писать переменные величины
Debug.WriteLine(a + 1000)
и любые арифметические выражения, содержащие переменные величины,
Debug.WriteLine("Привет всем!")
а также любую строку символов, взятую в двойные кавычки.
Поясняю математические функции
Dim b = System.Math.Abs(-20)
Здесь мы объявляем переменную b и присваиваем ей модуль[†] числа ?20. Как мы это делаем? Модуль есть математическая функция и чтобы компьютер нам ее вычислил, нам нужно в VB найти соответствующий инструмент. Пишем после знака равенства название пространства имен System, затем точку и в развернувшемся списке выбираем класс Math. Он предназначен для того, чтобы снабжать нас различными математическими функциями. Затем снова пишем точку и в развернувшемся списке выбираем метод Abs этого класса. Он-то как раз и вычисляет модуль. В скобках после него пишем ?20[‡]. Напоминаю, что многие методы называются функциями, так как сообщают нам какое-нибудь число или другую информацию.
Debug.WriteLine(b)
Значение b, равное 20, выводится в окно Output.
Debug.WriteLine(System.Math.Abs(-20))
Этот оператор тоже выводит в окно Output число 20, то есть делает то, что предыдущие два оператора вместе взятые. Я написал его, чтобы показать, что можно было обойтись и без переменной b, потому что в скобках, стоящих за именем метода WriteLine, можно писать и обращения к математическим функциям.
Debug.WriteLine(Math.Abs(-20))
Здесь я выбросил название пространства имен System
и все обошлось – выведено еще одно число 20.
Поясняю работу с текстовой информацией: Часто нам бывает нужно узнать что-нибудь про какой-нибудь текст. Например, хотя бы, сколько в нем букв.
Debug.Write(Microsoft.VisualBasic.Strings.Len("Мир"))
Функция Len класса Strings пространства имен Microsoft.VisualBasic находит, сколько символов (букв, других знаков и пробелов) присутствует в строке, являющейся ее аргументом. В слове «Мир» 3 буквы, поэтому в окно Output выводится число 3. Обратите внимание, что здесь я пользуюсь не методом WriteLine, а методом Write. Разница в том, что следующая за нашей тройкой информация в окне Output будет напечатана в той же строке, что и 3, а не в следующей.
Можем писать короче:
Debug.Write(Strings.Len("Мир"))
Debug.Write(Len("Мир"))
Последняя строка вычислит и выведет 5+80+1+1=87:
Debug.WriteLine(Len("Война") + Math.Abs(-80) + a + 1)
Знакомимся со строками
Создайте двухкнопочный проект с такой программой:
Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
Dim a As Integer
a = 98
Debug.WriteLine(a)
End Sub
Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
Dim b As String
b = "Привет всем!"
Debug.WriteLine(b)
End Sub
Сравним две процедуры.
Объявление Dim a As Integer говорит о том, что переменная a обязана иметь числовое значение, и поэтому в первой процедуре оператор a=98 записывает в ячейку a число 98.
Объявление Dim b As String говорит о том, что переменная b обязана иметь строковое (текстовое) значение. Это значит, что ее значением будет не число, а произвольная цепочка символов, например, Привет всем! или рпН2Н(+*fD6:u . Оператор b ="Привет всем!" записывает в ячейку b строку Привет всем! . Оператор Debug.WriteLine(b), поскольку он обязан всегда выводить на экран содержимое ячейки b, выведет на экран текст Привет всем!
Обратите внимание, что в окне кода текст должен браться в двойные кавычки, а в памяти он хранится без кавычек и на экран выводится без кавычек. И когда вы его вводите в текстовое поле или в InputBox, то тоже вводите без кавычек.
Информация в ячейке памяти под строковую переменную может в процессе выполнения программы меняться точно так же, как и в ячейке для числовой переменной. Например, при выполнении процедуры
Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button3.Click
Dim a As String
a = "Минуточку!" : Debug.WriteLine(a) : a = "Здравствуйте!" : a = "До свидания!" : Debug.WriteLine(a)
End Sub
в ячейке a будут по очереди появляться строки
Минуточку! Здравствуйте! До свидания!
а на экран будут выведены строки:
Минуточку!
До свидания!
Размеры ячейки под строковую переменную не фиксированы, они прямо зависят от размеров строки.
Операция &. Над строками, так же как и над числами, можно выполнять некоторые операции. Простейшая операция обозначается символом & и мы с ней знакомы – она просто соединяет строки в одну. Рассмотрим программу:
Private Sub Button4_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button4.Click
Dim S As String = "беда"
Dim T As String
T = "По" & S
Debug.WriteLine(T)
Debug.WriteLine(T & T & T)
Debug.WriteLine(T + T + T)
End Sub
Вот что она печатает:
Победа
ПобедаПобедаПобеда
ПобедаПобедаПобеда
Вы видите, что операция +
по отношению к строкам равнозначна операции &.
Строковые выражения и литералы. Встретившиеся нам выражения
"По" & S
T & T & T
"Объем = " & Format(V, "0.###")
и другие являются ни чем иным, как строковыми выражениями. По той простой причине, что в них производятся действия, результатом которых является строка. Конкретные взятые в двойные кавычки строки текста, которые мы видим в окне кода, будем называть строковыми литералами. Так, в приведенных выше строковых выражениях мы видим литералы "По", "Объем = ", "До свидания!" и другие. Строковые же выражения, как и любые другие выражения, не заключаются в двойные кавычки. В них заключаем только конкретные строковые литералы.
Операция & по отношению к числам. Если операцию & применить к числам, то она их «насильно» преобразует в строки и соединит, как привыкла, в одну строку. Рассмотрим программу:
Private Sub Button5_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button5.Click
Dim a As Integer = 1234
Debug.WriteLine("Здесь было " & 76 & a & a & 908 & " зайцев")
End Sub
Вот что она печатает:
Здесь было 7612341234908 зайцев
Разумеется, строка цифр 7612341234908 это просто строка символов и не имеет никакого отношения к реальному числу. Это просто бывшие числа, ставшие строками и затем соединенные вместе.
Задание 14.
Определите без компьютера, что напечатает следующая программа?:
Private Sub Button6_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button6.Click
Dim a As String = "Цикл"
a = a & a
Debug.WriteLine(a)
a = a & a
Debug.WriteLine(a & a & "Конец цикла")
End Sub
Пример. Строковую переменную можно задавать не только оператором присваивания, но и функцией InputBox:
Private Sub Button7_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button7.Click
Dim a As String
a = InputBox("Введите какое-нибудь слово")
Label1.Text = "Вы ввели слово " & a
End Sub
Пусть после нажатия на кнопку вы ввели слово Вперед. Вот результат в метке:
Вы ввели слово Вперед
Обратите внимание на пробел между буквой «о» и кавычкой в литерале "Вы ввели слово ". Пробел нужен для того, чтобы слова при выводе не сливались. Если бы его не было, результат был бы такой:
Вы ввели словоВперед
Звук и видео Проект «Плеер»
Поскольку у вашего компьютера есть видеоадаптер (видеокарта) и наверняка есть звуковой адаптер (звуковая карта), вы можете добавлять в ваш проект просмотр видео и прослушивание звука. Например, можно сделать так, чтобы при нажатии на кнопку или прямо при запуске проекта раздавалась музыка или на экране, помещенном на форму, воспроизводился видеоклип. Для этого необходимо, чтобы видеофайл или звуковой файл с музыкой или вашим голосом уже находились на диске компьютера.
Свой голос вы можете записать в звуковой файл, если у вас есть микрофон. Делается это стандартным приложением Windows «Звукозапись», до которого добираются так: В среде Windows нажмите Пуск ® Программы ® Стандартные ® Развлечения ® Звукозапись.
Вы можете прекрасно прослушивать и просматривать с помощью VB файлы самых разных форматов.
Звук и видео в Windows. Для воспроизведения звуковых и видеофайлов нужна специальная программа. Работая в Windows, вы наверняка для этого пользовались медиаплеером. Возможно, вы просто щелкали по значку звукового или видеофайла, после чего слушали и смотрели, не обращая внимания, что проигрывает вам эти файлы именно программа «Медиаплеер» (Windows Media Player). Медиаплеер входит в стандартный состав Windows последних версий. Если вы никогда им не пользовались, вам сейчас полезно чуть-чуть потренироваться в его использовании. Откройте его: Пуск ® Программы ® Стандартные ® Развлечения ® Windows Media Player. Приблизительный внешний вид медиаплеера вы можете видеть на Рис. 3.23. Правда, в последних версиях Windows он перенастраивается и может быть весьма причудливым.
Рис. 3.23
Дальнейшие ваши действия интуитивно ясны. При помощи File ® Open (затем, возможно, Browse) вы ищете и открываете на жестком или компакт-диске или в сети звуковой или видеофайл. Затем воспроизводите его при помощи привычных кнопок и регуляторов в нижней части медиаплеера: «Воспроизведение», «Пауза», «Стоп», «Громкость» и т.д.
Если вы не можете найти ни одного файла, подскажу, что несколько звуков и мелодий находятся на жестком диске вашего компьютера по адресу Windows\Media, а несколько простейших коротеньких видеоклипов – по адресу
Program Files\Microsoft Visual Studio .NET\Common7\Graphics\videos
Если звука не слышно, проверьте настройки вашей звуковой карты в приложении Микшер. Для этого в среде Windows нажмите Пуск ® Программы ® Стандартные ® Развлечения ® Регулятор громкости. В возникшем окне снимите флажки (галочки) выключения канала и установите максимальный уровень у каналов Wave (для WAV-файлов и MP3-файлов) и MIDI (для MID-файлов и RMI-файлов). Если вы сначала хотите записать звуковой файл с микрофона, зайдите в «Свойства», затем в закладку «Запись», установите флажок включения канала «Микрофон» и установите достаточно большой уровень канала «Микрофон».
Звук и видео в VB. Медиаплеер может быть вставлен в ваш VB проект, где вы имеете возможность свободно им пользоваться, управлять и настраивать, причем как в режиме проектирования, так и в режиме работы. Чтобы воспользоваться медиаплеером в VB, вам нужно расположить на форме специальный элемент управления Windows Media Player, который является «копией» медиаплеера в вашем проекте. Но его нет в стандартном наборе на панели Toolbox. Сначала его нужно туда поместить. Для этого: Tools ® Customize Toolbox ® COM Components ® вы находите Windows Media Player в длинном списке и ставите против него галочку ® OK. Он появился в Toolbox. Теперь его можно размещать на форме обычным образом. Подробнее процесс добавления нового элемента управления в Toolbox рассмотрен в 4.2.3.
Постановка задачи. Давайте на основе медиаплеера создадим собственный небольшой проигрыватель примерно такого вида, как на Рис. 3.24.
Рис. 3.24
Мы видим его в момент воспроизведения видеофайла. В центре расположен элемент управления Windows Media Player в виде экрана с инструментами управления сразу под ним. Кроме этого на форме мы видим 12 кнопок: по бокам 6 белых и внизу 6 серых. Слева – 3 белые кнопки с названиями звуковых клипов. Справа – 3 белые кнопки с названиями видеоклипов. Я сделал только по 3, но их может быть, сами понимаете, хоть сотня. В дальнейшем, чтобы не связываться с кнопками, мы научимся пользоваться списком (18.5) или просто просматривать диск (20.2).
Пользоваться нашим проигрывателем просто. Сначала щелчком по белой кнопке выбираем, что будем проигрывать. Затем запускаем воспроизведение щелчком по кнопке «Старт». Щелчком по кнопке «Стоп» – останавливаем. Мы можем пользоваться и собственными инструментами управления медиаплеера, которые видны сразу под экраном.. А вот 4 кнопки в центре внизу убеждают нас, что средствами VB вы можете управлять медиаплеером тоньше и удобнее, чем в Windows.
Проектируем проигрыватель. Создадим новый проект. Поместим Windows Media Player в Toolbox, а оттуда – на форму. Там он будет иметь примерно такой вид, как на Рис. 3.23, только без меню. В окне свойств мы видим большое количество его свойств. Не нужно менять значения тех свойств, которые вы не понимаете.
Проделайте следующее:
Дайте ему имя (например, Плеер).
Установите свойство AutoRewind (автоперемотка) в True, чтобы после окончания воспроизведения плеер устанавливался на начало клипа.
Установите свойство AutoStart в False, чтобы плеер не начинал воспроизводить файл сразу после открытия его щелчком по белой кнопке, а ждал нажатия на кнопку воспроизведения (хотя, можно и не делать этого).
Щелкните правой клавишей мыши по плееру и выберите в контекстном меню Properties. Здесь вы тоже можете настроить кое-какие его свойства.
Поместим на форму 2 метки и 12 кнопок. Дадим кнопкам подходящие имена (лучше всего, если они будут похожи на текст кнопок).
Пишем программу. Для того, чтобы конкретный файл начал воспроизводиться, нужно выполнить всего два оператора. Первый должен указать плееру адрес этого файла на диске, чтобы плеер знал, «что играть». Второй должен непосредственно отдать плееру команду начать воспроизведение. Вот пример записи этих двух операторов:
Плеер.FileName = "E:\WINNT\Media\Windows Logon Sound.wav"
Плеер.Play()
Здесь:
Плеер – это наш объект плеер.
FileName – это его свойство (имя, адрес файла). В кавычках указывается полный адрес файла.
Play – это метод объекта Плеер – приказ начать воспроизведение.
Двойными щелчками по кнопками переходим в окно кода и заполняем заготовки процедур. Не забывайте, что после ввода очередной процедуры проект нужно запускать и результаты работы процедуры проверять. Вот что у нас должно получиться (пояснения ниже):
Private Sub Звук_загрузки_Windows_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) _
Handles Звук_загрузки_Windows.Click
Плеер.FileName = "D:\WINNT\Media\Windows Logon Sound.wav"
End Sub
Private Sub Каньон_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Каньон.Click
Плеер.FileName = "D:\WINNT\Media\canyon.mid"
End Sub
Private Sub В_пещере_горного_короля_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) _
Handles В_пещере_горного_короля.Click
Плеер.FileName = "D:\WINNT\Media\In the Hall of the Mountain King.RMI"
End Sub
Private Sub Штопор_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Штопор.Click
Плеер.FileName = "D:\Program Files\Microsoft Visual Studio .NET\Common7\Graphics\videos\DRILLRLE.AVI"
End Sub
Private Sub Счетчик_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Счетчик.Click
Плеер.FileName = "D:\Program Files\Microsoft Visual Studio .NET\Common7\Graphics\videos\COUNT24.AVI"
End Sub
Private Sub Notre_Dame_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Notre_Dame.Click
Плеер.FileName = "D:\Documents and Settings\d\My Documents\Visual Studio Projects\Разное\Notre2.avi"
End Sub
Private Sub Старт_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Старт.Click
Плеер.Play()
End Sub
Private Sub Стоп_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Стоп.Click
Плеер.Stop()
End Sub
Private Sub Играть_непрерывно_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) _
Handles Играть_непрерывно.Click
Плеер.PlayCount = 0
End Sub
Private Sub Играть_1_раз_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Играть_1_раз.Click
Плеер.PlayCount = 1
End Sub
Private Sub Быстрее_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Быстрее.Click
Плеер.Rate = 2
End Sub
Private Sub В_обычном_темпе_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) _
Handles В_обычном_темпе.Click
Плеер.Rate
= 1
End Sub
Пояснения. Прежде всего, некоторые операторы из-за их длины я перенес на следующую строку при помощи «знака переноса», состоящего из пробела и знака подчеркивания. Подробнее об этом – в 3.12.2
Первые 6 процедур соответствуют 6 белым кнопкам. Вы легко их различите по именам кнопок в заголовках процедур. Все они делают одно и то же дело – подготавливают для последующего воспроизведения конкретный файл. Конечно, адреса файлов на вашем компьютере будут совершенно другими.
Смысл остальных 6 процедур ясен после следующих пояснений:
Stop – это метод объекта Плеер – приказ остановить воспроизведение. При следующем нажатии на кнопку «Старт» воспроизведение продолжится с того места, на котором оно было остановлено.
PlayCount – это свойство объекта Плеер (сколько раз подряд проигрывать файл). Если установить его в 0, то воспроизведение будет повторяться бесконечно.
Rate – это свойство объекта Плеер (темп воспроизведения). Если установить его, например, в 2, то воспроизведение будет осуществляться в 2 раза быстрее нормального, то есть люди на экране будут бегать, как сумасшедшие, и разговаривать голосом Буратино. А если в 0,5 – будут ползать, как вареные, и рычать.
Запустите проект. Проверьте, как работают все кнопки. Потаскайте влево-вправо указатель текущей позиции воспроизведения, подвигайте регулятор громкости.
Дополнительные замечания. Если вы установите свойство Visible плеера в False, то плеер вместе со своими инструментами управления не будет виден на форме, но вы все равно сможете им управлять, так как на форме останутся кнопки, созданные вами. Таким образом, вы сможете прослушивать звуковые клипы даже при «отсутствии» плеера на форме. Правда, когда вы попытаетесь просмотреть видеоклип, он все же появится.
Скопируйте папку с проектом и поэкспериментируйте над ней. Вот простые методы и свойства, с которыми можно поэкспериментировать:
|
AboutBox |
Метод, показывающий окно с краткими сведениями о медиаплеере. |
|
Duration |
Свойство – общая продолжительность выбранного клипа в секундах. |
|
CurrentPosition |
Свойство – на какой секунде находится в данный момент воспроизведение клипа. |
|
Volume |
Свойство – громкость. Отрицательное число -10000 означает самую маленькую громкость – полную тишину. Число 0 (ноль) – самую большую громкость. промежуточные числа – промежуточную громкость. |
|
Show… |
Несколько свойств, начинающиеся на Show, управляют тем, какие части медиаплеера показывать на экране. |
TextBox1.Text = Плеер.Duration
Он означает, что значение свойства Text текстового поля TextBox1 становится равным значению свойства Duration объекта Плеер.
Множество остальных свойств и методов медиаплеера позволят вам пользоваться всем богатством его возможностей, включая выбор клипов из списка, проигрывание DVD и аудиодисков. Но на них я останавливаться не буду.
Microsoft Multimedia Control 6.0. В Visual Basic 6. 0 есть собственный проигрыватель звуковых и видеофайлов – Microsoft Multimedia Control 6.0. Если у вас на компьютере установлен не только VB, но и Visual Basic 6.0, вы можете им воспользоваться и в VB. Но методы и свойства там другие. Описаны они в моей книжке (см. Список литературы).
Задание 4.
Усовершенствуйте ваш проигрыватель:
Добавьте кнопку для замедленного воспроизведения. В будущем вы сможете вместо кнопок организовать плавный регулятор темпа воспроизведения.
Добавьте несколько кнопок для задания разной громкости. В будущем вы сможете вместо кнопок организовать плавный регулятор громкости, поудобней стандартного.
Добавьте большую метку. Когда вы щелкнете по белой кнопке, на метке должны появиться несколько слов или предложений, описывающих ваше впечатление от выбранного клипа.
Добавьте кнопку и текстовое поле для определения продолжительности клипа. Когда вы щелкнете по кнопке, в поле должно появляться значение общей продолжительности выбранного клипа.
Добавьте кнопку и два текстовых поля для определения текущей позиции воспроизведения. Когда вы щелкнете по кнопке, в одном поле должно появляться число секунд, прошедших с начала воспроизведения, в другом – число секунд, оставшихся до конца воспроизведения. В будущем вы сможете сделать так, чтобы цифры в этих полях менялись автоматически.
Добавьте кнопку и текстовое поле для задания текущей позиции воспроизведения. При щелчке по кнопке текущая позиция воспроизведения должна устанавливаться в то значение в секундах, которое вы ввели в текстовое поле.
Задание 5.
«Музыка в кнопках калькулятора». Пусть при нажатии на калькуляторе каждой из четырех кнопок арифметических действий раздается какой-нибудь короткий мелодичный звук, причем для каждой кнопки свой. Таких звуков много на диске по адресу Windows\Media. Там они записаны в файлах, имеющих расширение wav. Указание: Установите свойство AutoStart в True.
