Приступаем к работе
Пользователи
прежних версий VB обычно
предпочитают, чтобы среда IDE по
внешнему виду и поведению была как
можно ближе к традиционной среде VB6.
Для этого откройте на начальной
странице VS ссылку My Profile и выберите
строку Visual Basic Developer в списке Profile, как показано на рис. 2.1.
Рис. 2.1. Начальная
страница Visual Studio
Вы можете
настроить клавиатуру и раскладку
окон и сохранить разные комбинации
параметров в разных профилях. Чтобы
сменить профиль, выполните команду
Help > Start Page и откройте ссылку My
Profile.
В VB .NET каждый
проект является частью того, что
Microsoft называет решением (solution).
Любой код, созданный в VB .NET IDE,
относится к некоторому решению.
Решение можно рассматривать как
хранилище всей информации,
необходимой для компиляции
программы и ее перевода в форму,
пригодную для исполнения. Таким
образом, решение состоит из одного
или нескольких проектов; различных
вспомогательных файлов (графических
изображений, ресурсных файлов, метаданных,
то есть данных, описывающих
другие данные, и т. д.); документации
в формате XML и практически всего,
что приходит В голову. Программисты
с опытом работы на VB5 или 6 могут
рассматривать решение как аналог
программной группы. На первых порах
решения кажутся неудобными;
откровенно говоря, при написании
мелких программ они действительно
слишком громоздки. Но постепенно вы
привыкнете к решениям и убедитесь,
что они заметно упрощают работу над
крупными коммерческими проектами.
Дело в том, что решение позволяет
легко выбрать файлы,
задействованные в решении
конкретной проблемы.
Создание нового решения
Новое решение
создается командой File > New. Вам
предлагается выбрать один из двух
вариантов: создать новый проект (New
Project) или пустое решение (Blank Solution).
Даже при выборе первого варианта IDE
все равно создает решение. Различие
между этими вариантами заключается
в том, что при выборе определенного
типа проекта VS .NET IDE создает
несколько служебных файлов и
включает их в решение (тип файлов
зависит от выбранного типа проекта).
Как правило,
работа над новой программой
начинается с команды New Project. На
экране появляется диалоговое окно (рис.
2.2; список проектов прокручен
примерно до середины). В окне
перечислены типы проектов,
автоматически создаваемых в VB .NET, —
на момент написания книги их было
десять. Шаблоны проектов VB .NET
работают практически .так же, как в
VB6. В частности, они почти всегда
содержат «скелет» программы, и в
них обязательно присутствует
служебная информация о файлах,
входящих в решение.
Рис. 2.2 Диалоговое окно New Project
После прокрутки
списка в диалоговом окне New Project
появляется значок Console Application (Консольное
приложение), показанный на рис. 2.2.
Обратите внимание: при выборе
любого значка, кроме последнего —
New Project in Existing Solution (Новый проект в
существующем решении), — вам не
придется подтверждать создание
нового решения. Дело в том, что при
создании нового проекта за
пределами существующего решения IDE
создает базовую структуру решения
за вас. Большинство программистов .NET
предпочитают создавать решения в
отдельных каталогах, имена которых
совпадают с именами решений. По
умолчанию IDE поступает с новыми
решениями именно таким образом.
В нашем примере
решение было названо vb_ide_01, но вы
можете использовать любое
допустимое имя файла. При желании в
него можно включить прописные
буквы или пробелы. Регистр символов
в файловой системе Windows
игнорируется при выполнении
операций, но сохраняется для
удобства пользователя. При
установке флажка Create Directory for Solution (Создать
каталог для решения) IDE
автоматически создает в заданном
основном каталоге подкаталог, имя
которого совпадает с именем
решения. В нашем примере это
привело к созданию каталога C:\vb net
book\Chater 2\vb_ide_01. Примерный вид IDE
показан на рис. 2.3.
Рис. 2.3. Visual
Studio IDE в начале работы
При помощи
команды View в главном меню всегда
можн9 вызвать нужное окно на
передний план (и передать ему фокус).
Все окна IDE свободно
перетаскиваются мышью. Кстати
говоря, они не являются дочерними
окнами многодокументного
интерфейса MDI (Multiple Document Interface),
которые должны находиться в
границах родительского окна —
любое окно можно переместить за
пределы главного окна IDE.
Рис. 2.4. Контекстная
справка
Бросается в
глаза другая эффектная особенность
IDE — если пристыкованное (docked) окно
полностью перекрывает другое окно,
это вызовет меньше проблем, чем в VB6,
поскольку скрытые окна
автоматически отображаются в виде
корешков (tabs). Пример показан на рис.
2.6 — обратите внимание на корешки в
позиции курсора. Чтобы вызвать
скрытое окно, достаточно щелкнуть
на корешке и перетащить его мышью.
Чтобы изменить порядок окон (например,
для экономии места), просто
перетащите один корешок поверх
другого. Подобное использование
корешков выгодно отличает VS .NET от VB6
IDE, где в результате неосторожной
стыковки окон становилось
совершенно невозможно работать и
для возвращения к нормальному
состоянию приходилось править
системный реестр. Также обратите
внимание на корешок Start Page главного
окна, предназначенный для вызова
начальной страницы IDE.
Рис. 2.5. Динамическая
справка
Рис. 2.6. Пристыкованные
окна с корешками
В этом разделе
описаны основные окна IDE.
Специализированные окна (например,
предназначенные для отладки)
рассматриваются позже в этой или в
одной из последующих глав. Но
сначала напомним, что в VS .NET IDE, как и
в большинстве современных
приложений Windows, контекстные меню
вызываются правой кнопкой мыши.
Поэкспериментируйте и освойтесь с
разными вариантами контекстных
меню. Например, контекстное меню
редактора показано на рис. 2.7.
Рис. 2.7. Контекстное
меню редактора
Как видите, в
этом контекстном меню объединяются
команды редактирования и отладки.
Кнопки панелей
инструментов снабжены подсказками
[ Предусмотрена даже
автоматическая нумерация строк
программы! Режим нумерации
включается в диалоговом окне,
вызываемом командой Tools > Option > Text
Editor. ]. На некоторых кнопках
имеются стрелки, показывающие, что
при нажатии кнопки открывается
меню. Например, вторая кнопка слева
(Add New Item) открывает список элементов,
которые можно включить в решение (рис.
2.8).
Панель
элементов (toolbox) используется
преимущественно при
программировании приложений GUI (см.
главу 8), но на ней также расположен
многоэлементный буфер обмена (clipboard
ring), описанный в следующем разделе.
Необходимо упомянуть и о такой
экзотической возможности, как
сохранение фрагментов кода прямо
на панели элементов. Эта тема тоже
рассматривается в следующем
разделе.
Как ни странно,
само наличие подсказок убеждает в
том, что графический интерфейс не
всемогущ. Кто знает, что нас ждет в
будущем — может, в каком-нибудь
прогрессивном варианте
пользовательского интерфейса на
кнопках вместо рисунков будет
размещаться текст?
Рис. 2.8. Вызов
меню с панелей инструментов
Редактор
Редактор
обладает полным набором
стандартных возможностей,
поддерживаемых в редакторах такого
рода (вырезание, вставка, поиск/замена
и т. д.). Для работы с ними можно
использовать стандартные
комбинации клавиш Windows (Ctrl+X —
вырезать, Ctrl+V — вставить и т. д.).
Если вы предпочитаете работать с
командами меню, к вашим услугам
меню Edit и контекстное меню окна
программы. Полный список сочетаний
клавиш вызывается из меню Edit; кроме
того, он приведен в разделе «Editing,
shortcut keys» справочной системы.
Например, комбинация Ctrl+I включает
режим поиска с приращением.
В вашем
распоряжении и очень удобное
средство IntelliSense, выдающее
информацию о методах заданного
объекта или параметрах,
передаваемых при вызове функции (рис.
2.9). Обычно IntelliSense автоматически
вызывается при вводе символа «.».
Настройка
большинства глобальных параметров
редактора выполняется в диалоговом
окне — выполните команду Tools > Options
и выберите в списке строку Text Editor,
как показано на рис. 2.10. По
сравнению с VB6 диалоговое окно Options
основательно изменилось, поэтому
мы рекомендуем внимательно изучить
его содержимое. Например, чтобы
выбрать размер позиций табуляции,
щелкните в строке Text Editor (см. рис. 2.10)
и выберите нужное значение для всех
языков или только для VB. Здесь же
выбирается режим создания отступов:
None (отступы отсутствуют), Block (курсор
выравнивается по началу предыдущей
строки) или Smart (автоматическое
создание отступов в теле цикла, как
того требует хороший стиль
программирования). Кстати говоря,
устанавливать размер позиций
табуляции и форматировать отступы
можно в готовом тексте, для чего
используются комбинации клавиш Ctrl+K,
Ctrl+F или- команда Edit > Advanced >
Format Selection. Если в режиме Smart выделить
фрагмент программы и нажать
клавиши Shift+Tab, этот фрагмент будет
переформатирован.
Module Modulel
Sub Main()
System.Console.
End Sub
Рис. 2.9. Подсказка
IntelliSense
Рис. 2.10. Диалоговое
окно Options
Новый редактор
поддерживает и такую удобную
возможность, как свертка
фрагментов программы и отображение
на их месте заголовков. Обратите
внимание на значки «+» рядом с
некоторыми строками на рис. 2.11. Если
щелкнуть на таком значке, в
листинге открывается
соответствующая область (region).
Если задержать указатель мыши над
многоточием (...), на экране будет
показан свернутый код. Для
управления сверткой используется
подменю Edit > Outlining.
Рис. 2.11. Свернутые
области в редакторе
Редактор VS .NET
обладает и другими интересными
возможностями, незнакомыми даже
опытным программистам VB. Мы
познакомимся с ними в следующем
разделе.
Буфер обмена
рассчитан не на один элемент, а на
несколько сразу (аналогичные
возможности существуют в Office 2000 и
Office XP). Весь вырезанный или
скопированный текст передается в
многоэлементный буфер обмена, к
которому можно обратиться с панели
элементов. Чтобы просмотреть
текущее содержимое буфера,
щелкните на корешке Clipboard Ring на
панели элементов. В буфере хранятся
15 последних скопированных или
вырезанных фрагментов текста.
Комбинация
клавиш Ctrl+Shift+V вставляет очередной
элемент буфера в текущий документ.
Многократно
нажимая клавиши Ctrl+Shift+V, вы
перебираете содержимое буфера. При
каждом нажатии Ctrl+Shift+V предыдущий
вставленный фрагмент заменяется
текущим элементом буфера.
Любой фрагмент
программного кода можно сохранить
для последующего использования на
панели элементов (многие
программисты используют для этой
цели вкладку General, но вы можете
создать новую вкладку — щелкните
на панели правой кнопкой мыши и
выберите команду Add Tab из
контекстного меню). Данная
возможность очень удобна,
поскольку в программах часто
встречаются повторяющиеся
фрагаенты, а вводить их каждый раз
заново слишком долго. Чтобы
сохранить фрагмент программы,
выделитеего и перетащите мышью на
панель элементов (рис. 2.12).
Фрагменты остаются на панели до тех
пор, пока не будут удалены при
помощи контекстного меню. Чтобы
воспользоваться сохраненным
фрагментом, перетащите его мышью в
нужную позицию окна программы.
Существует и другой способ —
выделите позицию вставки и дважды
щелкните на сохраненном фрагменте.
Рис. 2.12. Фрагменты
программы на панели элементов
Список задач и комментарии TODO, HACK и UNDONE
В Visual Studio теперь
поддерживается список задач (task list),
унаследованный из Visual InterDev и Visual J++.
Идея состоит в том, что в программу
включаются комментарии с описанием
действий, которые предполагается
выполнить в будущем; тип задачи
определяется специальным ключевым
словом, следующим после знака
комментария. В настоящее время
определены три встроенные
категории задач — TODO, HACK и UNDONE.
Комментарии с задачами выводятся в
окне, вызываемом командой View > Other
Windows > Task List (или комбинацией
клавиш Ctrl+Alt+K). Пример показан на рис.
2.13.
Для списка
задач можно определять
пользовательские ключевые слова.
Предположим, вы хотите помечать
ключевым словом FOR_KEN те фрагменты
кода, которыми должен заняться ваш
коллега Кен. Определение
пользовательских ключевых слов для
списка задач происходит следующим
образом:
- Выполните
команду Tools > Options > Environment >
Task List.
- Введите
текст FOR_KEN (при этом становится
доступной кнопка Add).
- Выберите
приоритет.
- Нажмите
кнопку Add и кнопку ОК.
Работа с решением
Вернемся к
решению vb_ide_01, о котором говорилось
выше. Хотя мы еще не ввели ни одной
строки программного кода, VB .NET
автоматически создает в каталоге
решения несколько файлов и
подкаталогов (в этом нетрудно
убедиться при помощи Проводника
Windows). Ниже приведен полный список
содержимого каталога; в вашем
случае данные будут похожими, хотя
и не совпадающими полностью.
943 Assemblylnfo.vb
<DIR> bin
79 Modulel.vb
<DIR>
obj
1,354 vb_ide_01.sln
7,168 vb_ide_01.suo
3,008 vb_ide_01.vbproj
1.643 vb_ide_01.vbproj.user
6 File(s) 14,195
bytes
Прдкаталоги bin и
obj используются при компиляции, а
четыре файла образуют решение. В
каталоге bin хранится
откомпилированный код. В каталоге
obj находится подкаталог,
задействованный в процессе отладки.
Исходный текст программы хранится
в файле Modulel.vb. При просмотре файла в
текстовом редакторе вы увидите
следующий код:
Module Modulel
SubMain()
End Sub
End Module
Файл vb_ide_01.sln
аналогичен .vbp-файлу проекта в VB6. В
этом файле хранится вся служебная
информация, необходимая для
компиляции решения, в том числе
описание всех проектов и файлов
решения. Примерное содержимое
этого файла приведено ниже:
Microsoft Visual
Studio Solution File. Format Version 7.00
Project("{F184B08F-C81C-45F6-A57F-5ABD9991F28F}")
= "vbjdejl", _
"vbjide_01\vb_ide_01.vbproj".
"{F40E94D3-09CA-4E17-90EA-7A514E991F93}"
EndProject
Project("{F184B08F-C81C-45F6-A57F-5ABD9991F28F}")
= "vb_ide_02". _
"vb_ide_02\vbjde_02.vbproj",
"{926DC073-167F-49DO-8A30-AF27E27BA2B4}"
EndProject
Global
GlobalSection(SolutionConfiguration)
= preSolution ConfigName.0 = Debug ConfigName.l = Release
EndGlobalSection
GlobalSection(ProjectDependencies)
= postSolution EndGlobalSection GlobalSection(ProjectConfiguration)
= postSolution
{F40E9403-09CA-4E17-90EA-7A514E991F93}.Debug.ActiveCfg
= Debug|.NET {F40E94D3-09CA-4E17-9DEA-7A514E991F93}.Debug.Bui 1 d.0
= Debug|.NET {F40E94D3-09CA-4E17-9DEA-7A514E991F93}.Release.ActiveCfg
= Release].NET {F40E94D3-09CA-4E17-9DEA-7A514E991F93}.Release.Build.0
= Release].NET {926DC073-167F-49В0-8A30-AF27E27BA2B4}.Debug.ActiveCfg
= Debug|.NET {926DC073-167F-49D0-8A30-AF27E27BA2B4}.Debug.Build.0
= Debug|.NET {926DC073-167F-49D0-8A30-AF27E27BA2B4}.Release.ActiveCfg
= Release!.NET {926DC073-167F-49D0-8A30-AF27E27BA2B4}.Release.Build.0
= Release].NET EndGlobalSection
GlobalSection(ExtensibilityGlobals)
= postSolution EndGlobalSection
GlobalSection(ExtensibilityAddlns) = postSolution EndGlobalSection
EndGlobal
Файл vb_ide_01.vbproj
написан на языке XML В нем хранится
информация о проекте, в том числе
значения различных свойств. Для
изменения свойств проекта обычно
используется команда Properties меню
Project или контекстного меню,
вызванного щелчком правой кнопщй
мыши в окне решения.
Ниже приведено
содержимое файла проекта в
текстовой форме. Обратите внимание
на частое повторение ключевого
слова Assembly — это ключевое слово
вместе с другими важными ключевыми
словами Imports и Namespaces
рассматривается в главе 4:
<VisualStudioProject>
<VisualBasic
ProjectType = "Local"
ProductVersion =
"7.0.9254"
SchemaVersion =
"1.0"
ProjectGuid = "{E24CC2EA-3E48-4C6E-8F92-ODE603B335D6}"
>
<Build>
<Sett1ngs
Applicationlcon =
""
AssemblyKeyContainerName
= ""
AssemblyName =
"vb_ide_01"
AssemblyOhginatorKeyFile
= ""
AssemblyOriginatorKeyMode
= "None"
DefaultClientScript
= "JScript"
DefaultHTMLPageLayout
= "Grid"
DefaultTargetSchema
= "IE50"
DelaySlgn = "false"
OutputType = "Exe"
OptionCompare =
"Binary"
OptionExplicit =
"On"
OptionStrlct =
"Off"
RootNamespace =
"vb_ide_01"
StartupObject = "vb_ide_01.Modulel"
>
<Config
Name = "Debug"
BaseAddress = "285212672"
ConfigurationOverrideFile=
""
DeflneConstants =
""
DefineDebug = "true"
DefineTrace = "true"
DebugSymbols =
"true"
IncrementalBuild =
"true"
Optimize = "false"
OutputPath = "bin\"
RegisterForComlnterop
= "false"
RemovelntegerChecks
= "false"
TreatWarningsAsErrors
= "false"
WarningLevel =
"1" /> <Config
Name = "Release"
BaseAddress - "285212672"
ConfigurationOverrideFile
= ""
DefineConstants =
""
DeflneDebug - "false"
DefineTrace = "true"
DebugSymbols =
"false"
IncrementalBuild
="false"
Optimize = "false"
OutputPath = "bin\"
RegisterForComlnterop
= "false"
RemovelntegerChecks
= "false"
TreatWarningsAsErrors
= "false"
WarningLevel = "1"
/>
</Settings>
<References> <Reference
AssemblyName = "System"
/>
Reference
Name = "System.
Data"
AssemblyName = "System. Data"
/>
<Reference
Name = "System.
XML"
AssemblyName =
"System. Xml"
/>
</References>
<Imports>
<Import Namespace = "Microsoft. VisualBasic" />
<Import Namespace = "System" />
<Import Namespace = "System. Col lections" />
<Import Namespace = "System. Data" />
<Import Namespace = "System. Diagnostics" />
</Imports> -</Build>
<Files>
<Include>
<File
RelPath = "Assemblylnfo.vb"
SubType = "Code" . BuildAction = "Compile" />
<File
RelPath = "Modulel.vb"
SubType = "Code" BuildAction = "Compile"
/>
</Include> </Files>
</VisualBasic>
</Vi sualStudi
oProject>
Двоичный файл
vb_ide_01.suo содержит пользовательскую
инфьрмацию уровня решения — в
частности, сведения об
установленных точках прерывания и
открытых документах. Если удалить
этот файл, все пользовательские
настройки будут потеряны, но
решение останется работоспособным.
В файле vbproj.user хранятся аналогичные
параметры уровня проекта (как и
когда проект запускается, следует
ли при компиляции создавать
отладочную версию и т. д.). Этот файл
тоже написан на языке XML:
<VisualStudioProject> <VisualBasic>
<Build>
<Settings ReferencePath = "" >
<Config
Name = "Debug"
EnableASPDebugging = "false"
EnableASPXDebugging = "false"
EnableUnmanagedDebugging = "false"
EnableSQLServerDebugging = "false"
StartAction = "Project"
StartArguments = ""
StartPage = ""
StartProgram = ""
StartURL =
""
StartWorkingDirectory = ""
StartWithIE = "false"
/>
<Config
Name = "Release"
EnableASPDebugging ="false"
EnableASPXDebugging = "false"
EnableUnmanagedDebugging = "false"
EnableSQLServerDebugging = "false"
StartAction = "Project"
StartArguments = ""
StartPage = ""
StartProgram = ""
StartURL =
""
StartWorkingDirectory = ""
StartWithlE = "false"
/>
</Settings>
</Build>
<OtherProjectSetti
ngs
CopyProjectDestinationFolder = ""
CopyProjectUncPath = ""
CopyProjectOption = "0"
ProjectView = "ProjectFiles"
/>
</VisualBasic>
</VisualStudioProject>
Включение новых проектов
В существующее
решение можно легко добавить новый
проект — откройте решение и
выполните команду File > New > Project.
На экране появляется знакомое
диалоговое окно New Project (рис. 2.17), но
если внимательно присмотреться к
нему, вы заметите два новых
переключателя. При установке
переключателя Close Solution, как и прежде,
новый проект создается в новом
решении. Но если установить
переключатель Add To Solution, IDE включает
новый проект в открытое решение.
Рис. 2.17. Включение
проекта в существующее решение
Допустим, вы
установили переключатель Add to Solution
и выбрали, как и прежде, консольное
приложение (Console Application). Как видно
из рис. 2.18, в решение yb_ide_01
включается новый проект с именем
vb_ide_02. Таким образом, полученное
решение vb_ide_01 состоит из двух
проектов: vb_ide_01 и vb_ide_02, и его можно
рассматривать как аналог группы
проектов VB6. Входящие в решение
проекты могут взаимодействовать
друг с другом и использоваться для
тестирования компонентов (например,
в IDE).
Рис. 2.18. Объединение
нескольких проектов в одном
решении
Как упоминалось
в главе 1, программа .NET в процессе компиляции
сначала переводится на
промежуточный язык IL, а затем
компилируется в машинный код.
Допустим, вы решили построить
исполняемый файл на базе решения
vb_ide_01.
В рассмотренном
примере задействованы две единицы
компиляции — наши два проекта.
Исполняемый файл может строиться
на основе любого проекта, входящего
в решение, а проекты компилируются
независимо друг от друга. Чтобы
откомпилировать проект, проще
всего щелкнуть правой кнопкой мыши
на одном из проектов в окне решения
и выбрать команду Build или Rebuild в
контекстном меню. При выборе
команды Build компилятор
ограничивается построением частей
проекта, изменившихся с момента
последнего построения, а команда
Rebuild строит заново весь проект.
Команда Build используется чаще,
поскольку она работает быстрее (при
запуске проекта клавишей F5
выполняется команда Build, а не Rebuild).
Результаты
компиляции и построения проекта
отображаются в окне вывода. На рис. 2.19
приведены выходные данные для
проекта vb_ide_01.
Рис. 2.19. Окно
вывода при успешном построении
На этот раз
компиляция прошла успешно, но
бывает и иначе. На рис. 2.20 показано
сообщение об ошибке, полученное при
вызове несуществующей функции.
Рис. 2.20. Окно
вывода при обнаружении ошибок
В режиме
фоновой компиляции VB .NET строка
программы, содержащая ошибку,
подчеркивается волнистой линией.
Подробную информацию —
значительно более полную, чем в VB6,
— можно получить в окне вывода и в
списке задач (рис. 2.21).
Рис. 2.21. Получение
информации об ошибках в списке
задач
Иногда бывает
удобнее откомпилировать сразу
несколько проектов решения вместо
того, чтобы компилировать их по
отдельности. В таких ситуациях
применяются средства пакетной
компиляции VB .NET. Команда Build > Build
Solution компилирует все проекты,
входящие в решение. Она часто
используется в конце работы над
приложением, когда все готово к
формированию окончательного
пакета для распространения (эта
тема рассматривается в главе 13).
Команда Batch Build
позволяет выбрать проекты для
компиляции. Она особенно удобна при
работе над несколькими проектами,
если вы не хотите подолгу ожидать
выполнения команды Build All или
компилировать каждый проект по
отдельности. На рис. 2.22 показано,
как выглядит окно вывода при
использовании команды Build Solution для
решения vb_ide_01.
Рис. 2.22. Информация
о результатах пакетной компиляции
Из рисунка
видно, что оба проекта нашего
решения были удИешно построены.
Если бы в процессе построения
возникли какие-либо ошибки, их
описания появились бы в окне вывода.
При выполнении
команды Build > Batch Build появляется
диалоговое окно, показанное на рис.
2.23. Если решение состоит из
нескольких проектов и в одном-двух
из них возникают ошибки, вы по
достоинству оцените эту команду.
Рис. 2.23. Выбор
проектов для пакетной компиляции
Многие
параметры проектов задаются в
диалоговом окне — щелкните на
имени проекта в окне решения правой
кнопкой мыши и выберите команду
Properties (также можно воспользоваться
командой Project > Properties). На
экране появляется диалоговое окно,
изображенное на рис. 2.24. В этом
разделе рассматриваются важнейшие
параметры компиляции, но мы
рекомендуем самостоятельно
исследовать остальные параметры,
находящиеся на вкладках Common Properties и
Configuration Properties. В частности, они
позволяют:
- Задать
значок приложения (Common Properties >
Build).
- Просмотреть
или изменить список
автоматически импортируемых
библиотек (Common Properties > Imports).
- Задать
различные параметры сборки и
пространства имен, к которым
относится ваш проект (Commpn Properties
> General). Эти два важных
понятия рассматриваются в
главах 4 и 13.
Параметры компиляции
Познакомившись
с разными способами компиляции
проектов и решений, мы переходим к
описанию параметров компиляции
отдельных проектов. Щелкните
правой кнопкой мыши на имени
проекта в окне решения и выберите
команду Properties > Configuration Properties >
Build — на экране появляется окно для
настройки параметров компиляции.
Например, параметр Debugging позволяет
задать аргументы командной строки.
Рис. 2.24. Диалоговое
окно свойств проекта
По сравнению с VB6
параметров совсем немного. Впрочем,
жалеть об этом не нужно: многое из
того, чем в VB6 приходилось
заниматься вам, в CLR делается
автоматически. В частности, в
параметрах компиляции можно
указать, нужно ли создавать
отладочную информацию (см.
следующий раздел), определять
константы DEBUG и TRACE и выдавать
предупреждения [ Очень трудно
представить ситуацию, в которой
отключение предупреждений было бы
оправдано. ]. Константы DEBUG и TRACE
выполняют те же функции, что и в VB6:
они позволяют использовать в
программе команды условной
компиляции:
#If DEBUG Then
Debug.WriteLine("In
debug mode")
#End If
#If TRACE Then Trace.
WhteLirie( "Tracing")
#End If
Если константа
DEBUG не определена, то проверка в
первой строке не проходит и команда
Debug.WriteLine не выполняется. То же самое
происходит и при проверке
константы TRACE.
В категории
Optimizations списка Configuration Properties можно
отключить проверку целочисленного
переполнения — впрочем, делать это
нежелательно. Вероятно, Microsoft
добавит новые способы оптимизации
в окончательной версии VB .NET или в
дополнениях.
Отладочная и окончательная версии
В верхней части
диалогового окна Project Properties >
Configuration Properties > Build находится
раскрывающийся список Configuration,
состоящий из трех пунктов: Release (Окончательная
версия), Debug (Отладочная версия) и All
Configurations (Все конфигурации). При
помощи этого списка можно задавать
разные наборы параметров для
разных типов компиляции. Например,
когда работа над приложением
близится к концу, в окончательной
версии можно изменить некоторые из
параметров, установленных ранее в
отладочной версии. Для этого
следует выбрать в списке пункт Release
и произвести дополнительную
настройку. Кнопка Configuration Manager
позволяет задать параметры
компиляции сразу для нескольких
проектов.
Что же
получается в результате компиляции
проекта? На рис. 2.25 показана
структура каталогов,
сгенерированных IDE для решения vb_ide_01.
Рис. 2.25. Дерево
каталогов после компиляции
Как упоминалось
выше, исходные файлы хранятся на
верхнем уровне иерархии, в каталоге
vb_ide_01. В каталог bin помещаются
двоичные файлы, полученные при
компиляции, — в нашем примере
создаются файлы с расширениями .ехе
и .pdb. Файл с расширением .pdb содержит
отладочную информацию и создается
только в том случае, если
отладочная информация была
затребована в диалоговом окне
параметров компиляции (Project > Configuration
Properties > Build).
В этом разделе
приводится краткий обзор изменений
в средствах отладки VB .NET. Мы
вернемся к этой важной теме позже,
когда у нас появится
содержательный код для отладки. К
сожалению, начинать приходится с
печального известия. Если раньше VB
позволял прервать работу программы,
отредактировать ее и продолжить
выполнение с учетом внесенных
изменений, то начиная с бета-версии
2 эта возможность не
поддерживается. Программу можно
редактировать в процессе отладки,
однако изменения вступают в силу
лишь после повторной компиляции.
Впрочем, различные средства
пошагового выполнения и прерывания
программ (такие как условные точки
прерывания) работают так же, как и
прежде.
И все же можно с
уверенностью сказать, что
существование общего отладчика
уровня VS .NET, по своим возможностям
сравнимого с отладчиком VC++,
является одним из самых заметных
усовершенствований VB .NET на фоне
предыдущих версий VB. Значительно
расширились возможности работы со
всеми составляющими приложения,
вплоть до отладки на уровне
загруженных модулей и программных
потоков.
Отладчик VB .NET
обладает некоторыми новыми
возможностями, отсутствовавшими в
VB6. Краткая сводка этих
возможностей приведена ниже.
Окно памяти
предназначено для просмотра
фактического содержимого заданной
области памяти. Ни в одной из
прежних версий VB не поддерживалась
эта возможность, чрезвычайно
полезная в некоторых ситуациях —
например, если вы хотите проследить
за выполнением низкоуровневого
кода и выяснить, что же именно происходит
при работе вашей программы. Окно
памяти вызывается в IDE командой Debug >
Windows > Memory > Memory1 (или 2-4).
Примерный вид окна памяти показан
на рис. 2.26. Если щелкнуть в окне
памяти правой кнопкой мыши,
появится контекстное меню, в
котором выбирается представление
выходных данных.
С технической
точки зрения в любом сеансе отладки
всегда задействован некоторый
процесс (о процессах рассказано в
главе 10). В предыдущих версиях VB
отладчик не позволял подключаться
к работающим процеЪсам — такая
возможность была предусмотрена
только в отладчике Visual C++. В VB .NET
команда Debug > Processes выводит
диалоговое окно, показанное на рис.
2!27.
Рис. 2.26. Окно
памяти
Рис. 2.27. Выбор
процесса для отладки
Чтобы начать
отладку, выделите процесс в списке
и щелкните на кнопке Attach. После
подключения к процессу кнопка Break
выводит информацию о текущем
состоянии приложения. Если
отладочная информация отсутствует,
выводится листинг на языке
ассемблера. После нажатия кнопки
Attach на экране появляется
диалоговое окно, в котором вам
предлагается выбрать, что же вы
собираетесь отлаживать — машинный
код, код CLR, сценарий и т. д. В
большинстве случаев отлаживается
либо машинный код, либо код CLR. Длл
примера мы запустили экземпляр
приложения Notepad.exe и подключились к
нему в отладчике VB .NET. Результат
показан на рис. 2.28.
Рис. 2.28. Отладка
процесса Notepad.exe
Листинг
выглядит устрашающе, поскольку мы
не располагаем отладочной
символической информацией для
программы Notepad.exe. При наличии этих
данных в окне появился бы фрагмент
исходного текста функции,
выполнявшейся в момент передачи
управления отладчику.
В отладчике VB .NET
предусмотрено еще одно важное
средство — просмотр всех
выполняемых потоков (threads)
приложения. Переключение потоков в
отладчике играет очень важную роль
в отладке многопоточных приложений.
Мы вернемся к этой теме в главе 10
при знакомстве с многопоточным
программированием.
На первый
взгляд управление исключениями
кажется экзотикой, не связанной с
практической работой. Чтобы
оценить эту возможность по
достоинству, достаточно оказаться
в ситуации, когда на стадии
тестирования возникают
многочисленные исключения (см.
главу 7) и возникает необходимость в
тонкой настройке действий,
выполняемых при возникновении
исключений. Это делается в
диалоговом окне, вызываемом
командой Debug > Windows > Exceptions. В
этом окне вы указываете, как должен
действовать отладчик при
обнаружении исключений
определенного типа. Допустим, вы
хотите, чтобы при возникновении
ошибок доступа управление
передавалось отладчику.
- Выберите
исключение Win32Exceptions >0xc0000005.
- Установите
в группе When the exception is thrown
переключатель Break into the debugger.
В результате
отладчик будет автоматически
вызываться при возникновении
ошибок доступа (0xc0000005), и вы сможете
точно определить, в какой строке
программы это произошло.
Отладка управляемого и неуправляемого кодов
Управляемым (managed)
в .NET называется код, выполняемый
при участии CLR. В управляемом коде
нельзя использовать указатели, а
выделением/освобождением памяти
занимается CLR. Неуправляемый код не
подчиняется этим ограничениям. Он
может создаваться в C++ и С#, но в VB .NET
такая возможность не
поддерживается.
Управляемый код
усложняет работу некоторых средств
отладки. Дело в том, что
исполнительная среда CLR
прикладывает значительные усилия к
оптимизации выполняемого кода, что
затрудняет получение правильных
кадров стека (то есть адресов всех
вызванных функций). Кроме того, в
зависимости от специфики программы
оптимизация может достичь такой
степени, что отображаемый в
отладчике код плохо ассоциируется
с исходным текстом. Впрочем, по
сравнению с преимуществами новой
среды отладки VB .NET эти проблемы
уходят на второй план.
