Благодарности 3 страница

Позже мы рассмотрим этот исходный текст подробнее, а сейчас расскажем об одной важной особенности редактора исходного текста программ системы Microsoft Visual Studio.NET. Этот редактор позволяет при просмотре временно скрывать фрагменты исходного текста, которые представляются несущественными.

Обратите внимание на вертикальные линии, расположенные в левой части окна редактирования (рис. 2-13). Эти линии, снабженные флажками в виде прямоугольников, ограничивают фрагменты текста. Щелкая эти флажки, можно свертывать или разворачивать соответствующие фрагменты текста.

Когда фрагмент текста свернут, соответствующий флажок отмечен знаком плюс, а когда развернут — знаком минус.

На рис. 2-14 мы свернули список пространств имен, включаемых оператором using, все комментарии, исходный текст конструктора класса Form1, а также исходный текст метода Dispose. Кроме того, мы оставили свернутым блок кода, созданный мастером форм и обозначенный на этом рисунке как Windows Form Designer generated code.

Рис. 2-14. Сокрытие фрагментов исходного текста

Возможность сворачивать и разворачивать фрагменты редактируемого теста Вы оцените, когда перейдете к работе над крупными проектами. Она позволит Вам быстрее находить нужные фрагменты текста, избавив от необходимости последовательного просмотра листинга.

Окно просмотра и редактирования свойств объектов

Практически каждый компонент создаваемого приложения, такой как форма или элемент управления, имеет свой набор свойств. Для формы, например, можно задавать такие свойства, как цвет фона, заголовок, наличие фонового графического изображения, внешний вид рамки и т.д. Кнопка обладает таким свойством, как цвет, текст надписи и др.

В правой нижней части главного окна Microsoft Visual Studio.NET (рис. 2-7) находится окно просмотра и редактирования свойств объектов. Это окно мы показали на рис. 2-15.

Рис. 2-15. Окно просмотра и редактирования свойств объектов

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

Создавая приложения, мы будем постоянно ссылаться на это окно, т.к. настройка свойств объектов выполняется очень часто. Заметьте, что некоторые числовые и строчные значения можно вводить в полях редактирования, а некоторые нужно выбирать из списков. Для выбора цвета на экран выводятся специальные палитры.

Вкладка Dynamic Help (рис. 2-14) поможет получить контекстно-чувствительную справку. Содержимое этой вкладки определяется исходя из того, какие окна Microsoft Visual Studio.NET открыты, и какие над ними выполняются действия.

Закрытие и повторное открытие решений и файлов

После того как Вы закончили работу с решением, его нужно закрыть. Решение закрывается автоматически при завершении работы Microsoft Visual Studio.NET, но его можно закрыть и явным образом. Для этого нужно выбрать строку Close Solution из меню File.

Для того чтобы открыть созданное ранее решение, выберите из меню File строку Open Solution. На экране появится стандартное диалоговое окно выбора файла, озаглавленное Open Solution. Найдите с его помощью на дисках компьютера каталог решения и выберите нужный файл с расширением имени *.sln. Этот файл содержит полное определение решения.

В предыдущих разделах этой главы мы создавали приложение Hello. Для него мастер проектов создает файл Hello.sln с описанием решения. Именно его и нужно выбрать, если Вы вначале закрыли решение, а потом решили продолжить работу над приложением.

Для того чтобы вернуться к работе с тем или иным решением, предназначена строка Recent Projects меню File. Выбрав эту строку, Вы увидите меню второго уровня из названий нескольких решений, с которыми недавно работали на этом компьютере.

Заметим, что помимо решений и проектов, Вы можете открывать и закрывать обычные файлы. Для этого в меню File предусмотрены строки Open и Close. Новый файл можно создать при помощи строки New, а вернуться к работе над закрытым ранее файлом — с помощью строки Recent Files меню File.

Исходный текст приложения Hello

Прежде чем вносить какие-либо изменения в приложение Hello, созданное для нас мастером проектов, мы проведем полное исследование созданного им исходного текста программы. Это позволит лучше разобраться в структуре программы. Мы сопоставим эту программу с той, что была написана на языке C и приведена в предыдущей главе.

Полный исходный текст первого варианта программы Hello Вы найдете в листинге 2-1. Далее мы будем исследовать его по частям.

Листинг 2-1. Файл ch02\hello\Form1.cs

using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;

namespace Hello
{
/// < summary>
/// Summary description for Form1.
/// < /summary>
public class Form1: System.Windows.Forms.Form
{
/// < summary>
/// Required designer variable.
/// < /summary>
private System.ComponentModel.Container components = null;

public Form1()
{
//
// Required for Windows Form Designer support
//
InitializeComponent();

//
// TODO: Add any constructor code
// after InitializeComponent call
//
}

/// < summary>
/// Clean up any resources being used.
/// < /summary>
protected override void Dispose(bool disposing)
{
if(disposing)
{
if (components! = null)
{
components.Dispose();
}
}
base.Dispose(disposing);
}

#region Windows Form Designer generated code
/// < summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// < /summary>
private void InitializeComponent()
{
this.components = new System.ComponentModel.Container();
this.Size = new System.Drawing.Size(300, 300);
this.Text = " Form1";
}
#endregion

/// < summary>
/// The main entry point for the application.
/// < /summary>
[STAThread]
static void Main()
{
Application.Run(new Form1());
}
}
}

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

В самое начало фала исходного текста приложения мастер проектов вставил строки, подключающие несколько пространств имен (name space) с помощью ключевого слова using:

using System;
using System.Drawing;
using System.Collections;
using System.ComponentModel;
using System.Windows.Forms;
using System.Data;

Пространство имен System содержит определение фундаментальных и базовых классов, определяющих типы данных, события, обработчики событий и другие, необходимые в каждом приложении компоненты.

Пространство имен System.Drawing необходимо для доступа к интерфейсу графических устройств (Graphics Device Interface, GDI), а точнее, к его расширенной версии GDI+. Классы, определенные в этом пространстве имен, необходимы для рисования в окнах приложений текста, линий, двухмерных фигур, изображений и других графических объектов.

В пространстве имен System.Collections определены классы, реализующие функциональность таких контейнеров, как массивы, списки, словари, хэши и т.п.

Классы пространства System.ComponentModel используются для реализации необходимого поведения компонентов и элементов управления приложения на этапе его разработки и выполнения.

Пространство имен System.Windows.Forms мы уже упоминали — в нем определены классы, реализующие поведение оконных форм, составляющих базу оконных приложений Microsoft windows на платформе Microsoft.NET Frameworks.

Класс System.Data необходим приложениям, работающим с базами данных посредством интерфейса ADO.NET. Этот интерфейс мы рассмотрим позже в 8 и 9 главах, посвященных интеграции приложений с базами данных.

Наше приложение также определяет собственное пространство имен Hello:

namespace Hello
{
…
}

В этом пространстве располагается определение класса Form1 приложения Hello.

Класс Form1

Наше приложение содержим в пространстве имен Hello определение только одного класса Form1:

/// < summary>
/// Summary description for Form1.
/// < /summary>
public class Form1: System.Windows.Forms.Form
{
…
}

Этот класс создается мастером проектов на базе класса System.Windows.Forms.Form, о котором мы уже говорили ранее. Обратите внимание, что мастер проектов добавил перед определением класса комментарий специального вида, включающий в себя тег < summary> XML-описания класса. Это описание Вы можете отредактировать по своему усмотрению, отразив в нем какую-либо осмысленную информацию о назначении класса. При необходимости подробное описание языка XML Вы найдете в [9].

Наличие подобных комментариев упрощает документирование проекта.

Рассмотрим поля и методы, определенные в классе Form1.

Поле components

В классе Form1 мастер проекта создал одно поле components типа private и класса System.ComponentModel.Container:

/// < summary>
/// Required designer variable.
/// < /summary>
private System.ComponentModel.Container components = null;

Оно представляет собой контейнер, предназначенный для хранения компонентов, размещаемых в форме. Как Вы увидите дальше, с этим полем работает мастер форм.

Конструктор

Задача конструктора класса Form1, вызываемого при создании новой формы, заключается в инициализации всех компонентов, размещенных в форме. С этой целью конструктор вызывает метод InitializeComponent, определенный в классе Form1:

public Form1()
{
//
// Required for Windows Form Designer support
//
InitializeComponent();

//
// TODO: Add any constructor code
// after InitializeComponent call
//
}

Мастер проектов добавил в исходный текст конструктора комментарий, в котором говорится, что Вы можете добавить после вызова метода InitializeComponent другой необходимый инициализирующий код.

Метод Dispose

Деструктор класса Form1 в явном виде отсутствует. Однако для освобождения ресурсов приложения после закрытия формы в этом классе определен метод Dispose:

/// < summary>
/// Clean up any resources being used.
/// < /summary>
protected override void Dispose(bool disposing)
{
if(disposing)
{
if (components! = null)
{
components.Dispose();
}
}
base.Dispose(disposing);
}

В его задачу входит освобождение ресурсов всех компонентов, хранящихся в упомянутом выше контейнере components, при закрытии формы. Далее этот метод вызывает метод Dispose базового класса (т.е. класса System.Windows.Forms.Form) для выполнения действий по освобождению ресурсов, определенных в этом классе.

Метод InitializeComponent

Мы уже говорили, что конструктор класса Form1 вызывает для инициализации компонентов приложения метод InitializeComponent. Обратите внимание на то, что исходный текст этого метода заключен внутри блока, образованного ключевыми словами #region и #endregion:

#region Windows Form Designer generated code
/// < summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// < /summary>
private void InitializeComponent()
{
this.components = new System.ComponentModel.Container();
this.Size = new System.Drawing.Size(300, 300);
this.Text = " Form1";
}
#endregion

В автоматически созданном комментарии к методу InitializeComponent говорится о том, что этот метод используется мастером форм, и его не следует модифицировать вручную. В режиме просмотра исходного текста данный блок по умолчанию отображается в свернутом виде (рис. 2-14), но при необходимости его можно развернуть.

Что делает метод InitializeComponent?

Прежде всего, этот метод создает новый контейнер для хранения компонентов, и записывает его в описанное нами ранее поле components:

this.components = new System.ComponentModel.Container();

Далее метод InitializeComponent устанавливает два атрибута формы — ее размер Size и текст заголовка Text:

this.Size = new System.Drawing.Size(300, 300);
this.Text = " Form1";

Так как пока наша форма не содержит никаких элементов управления, на этом инициализация формы будет закончена.

Метод Main

В классе Form1 определен статический метод Main, получающий управление при запуске нашего приложения:

/// < summary>
/// The main entry point for the application.
/// < /summary>
[STAThread]
static void Main()
{
Application.Run(new Form1());
}

Этот метод играет роль точки входа приложения, с которой и начинается его работа.

Метод Main очень прост. Он состоит всего из одной строки, в которой вызывается метод Application.Run:

Application.Run(new Form1());

В качестве параметра методу Application.Run передается ссылка на новый, только что созданный объект класса Form1 (т.е. на нашу форму).

Как это работает?

Вначале конструктор создает объект класса Form1 — новую форму, выступающую в качестве главного окна нашего приложения. Метод Application.Run, получая при вызове ссылку на эту форму, инициализирует цикл обработки сообщений и запускает его.

При этом метод Application.Run берет на себя регистрацию функции окна и обработку сообщений, о которых мы рассказывали в 1 главе нашей книги. Поэтому программисту, создающему оконное приложение на языке C#, не надо об этом заботиться.

Когда пользователь закрывает главное окно приложения, метод Application.Run возвращает управление, и приложение завершает свою работу.

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

Приложение с обработкой событий

В исходном виде главное окно (форма) приложения Hello обладает весьма небольшой функциональностью. Наше первое усовершенствование приложения будет заключаться в добавлении кнопки. Если щелкнуть эту кнопку, которой на экране должно будет появиться простейшее диалоговое окно с сообщением.

Добавление кнопки в форму приложения

Откройте проект приложения Hello, если Вы его закрыли. Затем перетащите левой клавишей мыши значок кнопки с надписью Button на изображение нашей формы, открытой в режиме визуального проектирования (рис. 2-16).

Рис. 2-16. Добавление кнопки в форму

По умолчанию на кнопке появится надпись button1. Чтобы ее изменить, воспользуйтесь окном просмотра свойств, которое показано на рис. 2-17. Напомним, что это окно находится в левом нижнем углу главного окна Microsoft Visual Studio.NET.

Рис. 2-17. Изменение надписи на кнопке

Отыщите в списке свойство Text (оно выделено на рис. 2-17), и замените его значение — вместо button1 напишите там строку «Сообщение». Теперь если убрать текстовый курсор из поля Text, то надпись на кнопке изменится.

Добавив кнопку и отредактировав надпись, нажмите клавишу F5 для трансляции и запуска программы. Теперь в окне нашей программы появится кнопка, которую можно нажимать (рис. 2-18).

Рис. 2-18. Работающее приложение с кнопкой

Изменения в исходном тексте после добавления кнопки

Убедившись, что приложение работает должным образом и только что добавленная кнопка Сообщение нажимается, откройте форму в режиме просмотра исходного текста. Для этого в окне Solution Explorer щелкните имя файла Form1.cs правой кнопкой мыши и выберите из контекстного меню строку View Code.

После добавления кнопки в классе Form1 появилось новое поле button1, предназначенное для хранения ссылки на кнопку:

private System.Windows.Forms.Button button1;

Кнопка создается как объект класса System.Windows.Forms.Button.

Самые большие изменения затронули метод InitializeComponent, отвечающий за инициализацию формы. Теперь в нем появились строки, отвечающие за создание и размещение кнопки внутри формы:

#region Windows Form Designer generated code
private void InitializeComponent()
{
this.button1 = new System.Windows.Forms.Button();

this.SuspendLayout();

//
// button1
//
this.button1.Location = new System.Drawing.Point(200, 16);
this.button1.Name = " button1";
this.button1.TabIndex = 0;
this.button1.Text = " Сообщение";

//
// Form1
//
this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
this.ClientSize = new System.Drawing.Size(292, 273);
this.Controls.AddRange(new System.Windows.Forms.Control[] {
this.button1});
this.Name = " Form1";
this.Text = " Form1";

this.ResumeLayout(false);
}
#endregion

Прежде всего, метод InitializeComponent создает кнопку как объект класса System.Windows.Forms.Button, и сохраняет ссылку на этот объект в поле button1 для дальнейшего использования:

this.button1 = new System.Windows.Forms.Button();

После этого начинается процесс размещения кнопки на поверхности формы.

Этот процесс начинается с вызова метода SuspendLayout:

this.SuspendLayout();

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

После того как все необходимые компоненты будут размещены, механизм генерации упомянутых выше сообщений включается снова при помощи метода ResumeLayout:

this.ResumeLayout(false);

В промежутке между вызовами методов SuspendLayout и ResumeLayout программа добавляет и размещает элементы управления, а также настраивает их свойства.

Первым делом в форму добавляется наша кнопка:

this.button1.Location = new System.Drawing.Point(200, 16);

Для рисования кнопки внутри окна формы в определенной позиции программа вызывает метод System.Drawing.Point. Координаты места расположения кнопки по горизонтальной и вертикальной оси координат передаются методу через параметры.

Далее программа устанавливает свойства кнопки:

this.button1.Name = " button1";
this.button1.TabIndex = 0;
this.button1.Text = " Сообщение";

Свойство Name хранит идентификатор кнопки. При необходимости этот идентификатор можно отредактировать в окне, показанном на рис. 2-17.

В свойстве Text хранится надпись на кнопке. Что же касается свойства TabIndex, то оно приобретает значение, когда в форме имеется несколько элементов управления, таких как кнопки, поля редактирования, списки и т.д. Это свойство задает порядок выбора элементов в окне формы при использовании клавиши табуляции. Напомним, что с помощью клавиши табуляции можно перемещать фокус ввода между элементами управления обычных диалоговых окон Microsoft Windows.

После добавления кнопки и настройки ее свойств метод InitializeComponent задает свойства самой формы:

this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
this.ClientSize = new System.Drawing.Size(292, 273);
this.Controls.AddRange(
new System.Windows.Forms.Control[]
{
this.button1
}
);

Свойство AutoScaleBaseSize задает базовые размеры, которые используются формой для автоматического масштабирования. При этом за основу берется размер системного шрифта.

При помощи свойства ClientSize программа определяет размеры так называемой клиентской области окна (client area) нашей формы. Эта область не включает в себя заголовок окна, рамку и полосы прокрутки.

И, наконец, при помощи метода Controls.AddRange программа добавляет в форму контейнер с массивом System.Windows.Forms.Control[] элементов управления. В нашем случае этот массив состоит из одной кнопки с идентификатором button1.

Последнее, что делает метод InitializeComponent, это настройка свойств формы Name и Text:

this.Name = " Form1";
this.Text = " Form1";

Первое из них задает имя (идентификатор) формы, а второе — текстовую строку, отображаемую в заголовке формы.

Заметьте, что мы сделали лишь несколько движений мышью, добавив кнопку в окно формы. При этом мастер форм автоматически добавил весь код, необходимый для создания и размещения кнопки.

Обработка событий от кнопки

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

Чтобы обеспечить обработку событий от кнопки, дважды щелкните мышью ее изображение в окне дизайнера форм (рис. 2-16). Сразу после этого в рабочей области Microsoft Visual Studio.NET откроется окно редактирования исходного текста программы, в который будет добавлен метод button1_Click:

private void button1_Click(object sender, System.EventArgs e)
{

}

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

Метод button1_Click — это обработчик события, возникающего, когда пользователь щелкает кнопку. Чтобы этот метод заработал, его нужно подключить на этапе инициализации формы. Такое подключение обеспечивает следующая строка, добавленная дизайнером формы в метод InitializeComponent:

this.button1.Click += new System.EventHandler(this.button1_Click);

Чтобы в процессе обработки сообщения от кнопки вывести на экран сообщение, измените исходный текст метода button1_Click следующим образом:

private void button1_Click(object sender, System.EventArgs e)
{
MessageBox.Show(" Для Вас есть сообщение! ");
}

Мы вставили сюда вызов метода MessageBox.Show. Этот метод отображает на экране диалоговое окно с текстом сообщения, переданного в качестве параметра (рис. 2-19).

Рис. 2-19. Диалоговое окно с сообщением

Итак, мы в течение нескольких минут сделали вполне работоспособное приложение Microsoft Windows, добавив вручную только одну строку кода с вызовом метода MessageBox.Show. Всю остальную работу за нас провернул дизайнер форм.

Отладка приложений

Система разработки приложений Microsoft Visual Studio.NET содержит мощные средства отладки, необходимые при разработке сложных программ и программных комплексов. Мы расскажем только о некоторых возможностях, которые пригодятся Вам при отладке автономных приложений C#.

Пошаговое выполнение программ

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

Чтобы приступить к пошаговой отладке программы, откройте решение и затем выберите из меню Debug строку Step Into или Step Over. Вы также можете использовать вместо этих строк клавиши F11 и F10, соответственно.

Клавиша F11 предназначена для пошагового выполнения программ с входом в тело методов и функций. Что же касается клавиши F10, то она тоже нужна для пошагового выполнения программ, но при ее использовании вход в тело методов и функций не выполняется.

Таким образом, если нужно отладить функцию, то ее вызов следует выполнить клавишей F11, а если функция должна быть выполнена без отладки, — то клавишей F10.

Давайте попробуем выполнить по шагам наше приложение Hello. Для этого откройте решение в программе Microsoft Visual Studio.NET и нажмите клавишу F11. Через некоторое время в окне Microsoft Visual Studio.NET появится исходный текст программы, причем первая строка метода Main будет выделена желтым цветом. Кроме того, эта строка будет отмечена слева стрелкой (рис. 2-20).

Рис. 2-20. Запуск программы в режиме пошаговой отладки

Если теперь нажать клавишу F11, отладчик приступит к созданию объекта класса Form1. Вначале будет проинициализировано поле components, а затем, при последующих нажатиях клавиши F11, отладчик перейдет к пошаговому выполнению конструктора класса Form1. На рис. 2-21 показан как раз этот момент.

Рис. 2-21. Отладка конструктора Form1

Теперь если нажать кнопку F10, метод InitializeComponent будет выполнен без отладки. При помощи кнопки F11 Вы сумеете отладить строки метода InitializeComponent в пошаговом режиме.

Еще Вам может оказаться полезной клавиша Shift-F12, соответствующая строке Step Out меню Debug. При помощи этой строки можно перевести программу из пошагового режима в автоматический. Однако после выхода из тела текущего метода программа снова перейдет в пошаговый режим.

Для того чтобы продолжить выполнение с текущего места без отладки, нажмите клавишу F5 или выберите строку Continue меню Debug.

Точка останова

Отлаживая программу Hello, Вы можете столкнуться с одной проблемой. Выполняя программу по шагам, Вы не сможете отладить обработчик события, создаваемого в результате нажатия кнопки Сообщение. В самом деле, после прохода конструктора класса Form1 программа будет работать уже без отладки.

Чтобы отладить обработчик события, необходимо установить так называемую точку остановки (breakpoint). Для этого щелкните левой клавишей мыши в узкое вертикальное поле слева от той строки кода, на которой нужно установить точку останова. После этого строка будет выделена красно-кирпичным цветом, а слева напротив нее появится жирная точка (рис. 2‑ 22).

Рис. 2-22. Установка точки останова

Таким способом Вы можете установить в своей программе несколько точек останова.

Чтобы убрать точку останова, щелкните жирную точку, отмечающую строку программы, еще раз.

Установив точку останова напротив вызова метода MessageBox.Show, нажмите кнопку F5 для запуска программы без отладки. Теперь, когда на экране появится окно программы, щелкните расположенную в нем кнопку Сообщение. Когда в процессе своей работы программа дойдет до отмеченной строки, произойдет останов и переход в режим пошагового выполнения программы. Строка, выделенная на рис. 2-22, будет отмечена желтым цветом, а слева от нее в кружке появится стрелка.

Заметим, что при отладке Вы не сможете «войти» внутрь функций библиотеки Microsoft.NET Frameworks, так что ее исходные тексты будут Вам недоступны.

Точки останова удобно использовать и для отладки программ, содержащих циклы. Если в цикле делается много итераций, то его прохождение в пошаговом режиме может отнять слишком много времени. Выход простой — установите точку останова после цикла и продолжите работу программы без отладки.

Просмотр содержимого переменных и полей

В процессе пошагового выполнения программы или при достижении точки останова Вы можете просмотреть содержимое переменных и полей объектов отлаживаемой программы. В этом Вам поможет вкладка Locals окна просмотра Locals, отображаемое при отладке в левом нижнем углу главного окна приложения Microsoft Visual Studio.NET (рис. 2-23).

Рис. 2-23. Просмотр содержимого переменных и полей

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

Вкладка Autos (рис. 2-24) удобна для контроля текущих изменений значений в полях и переменных.

Рис. 2-24. Вкладка Autos

На этой вкладке автоматически появляются те поля и переменные, значения которых были изменены в результате выполнения текущей строки кода. При этом новые значения выделяются красным цветом.

Для отслеживания содержимого каких либо переменных или полей на протяжении отладки программы предназначена вкладка Watch. На ней отображается список отслеживаемых полей и соответствующие значения (рис. 2-25).

Рис. 2-25. Вкладка Watch

Чтобы добавить значение поля или переменной на вкладку Watch, необходимо выделить это значение левой клавишей мыши, а потом щелкнуть его правой клавишей мыши. На экране появится контекстное меню, из которого следует выбрать строку Add Watch.