1. Добро пожаловать в C#
Прочитав эту главу, вы научитесь:
• пользоваться средой программирования Microsoft Visual Studio 2015;
• создавать консольные приложения на C#;
• объяснять назначение пространств имен;
• создавать простые графические приложения на C#.
В этой главе излагается введение в Visual Studio 2015, рассматриваются среда программирования и набор инструментальных средств, которые были разработаны для создания приложений под Microsoft Windows. Visual Studio 2015 — идеальное средство написания кода на C#, которое предоставляет множество функциональных возможностей, доступных для изучения в процессе чтения книги. В этой главе среда Visual Studio 2015 будет использоваться для создания простых приложений на C#, позволяющих встать на путь создания полноценных решений для Windows.
Начало программирования в среде Visual Studio 2015
Visual Studio 2015 является богатой инструментальными средствами средой программирования, предоставляющей функциональные возможности, необходимые для создания больших или малых C#-проектов, запускаемых под управлением Windows. В этой среде можно даже создавать проекты, которые незаметно для пользователя объединяют модули, написанные на различных языках программирования, таких как C++, Visual Basic и F#. В первом упражнении вы откроете среду программирования Visual Studio 2015 и узнаете, как создавать консольные приложения.
ПРИМЕЧАНИЕ Консольное приложение не предоставляет графический интерфейс пользователя (graphical user interface (GUI)) и запускается в окне командной строки.
Создание консольного приложения в Visual Studio 2015
Щелкните на панели задач Windows на кнопке Пуск (Start), наберите Visual Studio 2015, а затем нажмите Ввод. Будет запущена среда Visual Studio 2015, которая выведет на экран стартовую страницу, похожую на ту, что показана на рис. 1.1. (В зависимости от используемого вами варианта Visual Studio 2015 у вашей стартовой страницы может быть несколько иной внешний вид.)
Рис. 1.1
ПРИМЕЧАНИЕ При первом запуске Visual Studio 2015 может выводиться диалоговое окно, приглашающее выбрать исходные установки среды разработки. Visual Studio 2015 способна перенастраиваться в соответствии с предпочитаемым вами языком программирования. Для выбранного языка будут сделаны настройки по умолчанию для различных диалоговых окон и инструментов в интегрированной среде разработки (integrated development environment (IDE)). В перечне настроек разработки (Development Settings) нужно выбрать Visual C#, а затем щелкнуть на пункте Start Visual Studio. После небольшой паузы появится IDE-среда Visual Studio 2015.
Выберите в меню Файл (File) пункт Создать (New), а затем щелкните на пункте Проект (Project). Откроется диалоговое окно Создание проекта (New Project). В нем показан перечень шаблонов, которыми можно будет воспользоваться, приступая к созданию приложения. В диалоговом окне перечисляются категории шаблонов, соответствующие используемому языку программирования, а также типы приложений.
Раскройте на левой панели узел Установленные (Installed), затем узел Шаблоны (Templates) и щелкните на пункте Visual C#. На средней панели в поле со списком выберите .NET Framework 4.6 и щелкните на пункте Консольное приложение (Console Application) (рис. 1.2).
Рис. 1.2
В поле Размещение (Location) наберите строку C:\Users\YourName\Documents\Microsoft Press\VCSBS\Chapter 1. Замените текст YourName в набранном пути своим именем пользователя, зарегистрированным в Windows.
ПРИМЕЧАНИЕ Чтобы не повторяться и сэкономить место, далее в книге ссылка на путь C:\Users\YourName\Documents будет сокращаться до принадлежащей вам папки Documents.
СОВЕТ Если указанной вами папки не существует, Visual Studio 2015 создаст ее.
В поле Имя (Name) наберите TestHello (вместо предлагаемого имени ConsoleApplication1). Установите флажок Создать каталог для решения (Create Directory For Solution) и снимите флажок Добавить в систему управления версиями (Add To Source Control), после чего щелкните на кнопке OK.
Visual Studio создает проект, используя шаблон Консольное приложение. Если будет выведено диалоговое окно (рис. 1.3) с вопросом о том, какую систему управления версиями следует выбрать, значит, вы забыли снять флажок Добавить в систему управления версиями. В этом случае просто щелкните на кнопке Отмена (Cancel), и проект будет создан без использования системы управления версиями.
Рис. 1.3
Visual Studio выведет начальный код проекта (рис. 1.4).
Рис. 1.4
Панель меню в верхней части экрана предоставляет доступ к функциональным возможностям, используемым в среде программирования. Для доступа к пунктам меню и командам можно использовать клавиатуру или мышь точно так же, как это делается во всех программах, работающих под управлением Windows. Сразу под панелью меню располагается панель инструментов. Она обеспечивает кнопочный способ запуска наиболее часто используемых команд.
Окно кода и текстового редактора, занимающее основную часть экрана, отображает содержимое исходных файлов. Если проект состоит из нескольких файлов, то при редактировании более чем одного файла у каждого исходного файла имеется собственная вкладка, подписанная его именем. Чтобы вывести файл на первый план в окне кода и текстового редактора, нужно щелкнуть на вкладке с его именем.
В правой части экрана интегрированной среды разработки находится панель Обозреватель решений (Solution Explorer), примыкающая к окну кода и текстового редактора (рис. 1.5).
Рис. 1.5
В панели обозревателя решений среди прочего выводятся имена файлов, связанных с проектом. Чтобы исходный файл вышел на первый план в окне кода и текстового редактора, можно также дважды щелкнуть на его имени в обозревателе решений.
Перед написанием какого-либо кода изучите перечисленные в обозревателе решений файлы, созданные средой Visual Studio 2015 в качестве части вашего проекта.
• Решение TestHello. Это файл решения верхнего уровня. В каждом приложении имеется единственный файл решения. В решении может содержаться один или несколько проектов, и Visual Studio 2015 создает файл решения, чтобы помочь организовать эти проекты. Если в Проводнике просмотреть содержимое папки Documents\Microsoft Press\VCSBS\Chapter 1\TestHello, вы увидите, что этот файл назван TestHello.sln.
• TestHello. Это файл проекта C#. Каждый файл проекта ссылается на один или несколько файлов, содержащих исходный код, а также на другие артефакты проекта, например графические изображения. Весь исходный код одного и того же проекта должен быть написан на одном и том же языке программирования. В проводнике этот файл носит название TestHello.csproj и хранится в папке \Microsoft Press\VCSBS\Chapter 1\TestHello\TestHello вашей папки документов.
• Properties. Это папка в проекте TestHello. Если ее открыть (щелкнув на стрелке перед Properties), можно увидеть, что в ней содержится файл AssemblyInfo.cs. Это специальный файл, который можно использовать для добавления к программе таких атрибутов, как имя автора, дата написания программы и т.д. Для изменения способа запуска программы можно указать дополнительные атрибуты. Их использование в данной книге не рассматривается.
• Ссылки (References). Эта папка содержит ссылки на библиотеки скомпилированного кода, используемого вашим приложением. При компиляции код C# преобразуется в библиотеку и получает уникальное имя. В Microsoft .NET Framework такие библиотеки называются сборками. Разработчики используют сборки для создания написанных ими пакетов полезных функций, чтобы их можно было распространять среди других разработчиков, которые могут выразить желание воспользоваться этими функциями в собственных приложениях. Если открыть папку Ссылки (Referenses), станет виден исходный набор сборок, добавляемый Visual Studio 2015 в ваш проект. Эти сборки обеспечивают доступ ко многим часто используемым функциям .NET Framework и предоставляются компанией Microsoft вместе с Visual Studio 2015. О многих таких сборках вы узнаете по мере выполнения упражнений, приводимых в данной книге.
• App.config. Это файл конфигурации приложения. В силу своей необязательности он может и отсутствовать. В нем можно задать настройки, используемые вашим приложением во время его выполнения, для изменения его поведения, например версию .NET Framework, применяемую для запуска приложения. Более подробно этот файл будет рассматриваться в следующих главах.
• Program.cs. Это исходный файл C#, который отображается в окне кода и текстового редактора сразу после создания проекта. В этот файл будет записан ваш код для консольного приложения. В нем также содержится автоматически предоставляемый Visual Studio 2015 код, который мы вскоре рассмотрим.
Написание вашей первой программы
В файле Program.cs определяется класс Program, содержащий метод Main. В C# весь исполняемый код должен быть определен внутри метода, а все методы должны принадлежать классу или структуре. Более подробно классы рассматриваются в главе 7 «Создание классов и объектов и управление ими», а структуры — в главе 9 «Создание типов значений с использованием перечислений и структур».
Метод Main определяет точку входа программы. Этот метод должен быть определен в порядке, указанном в классе Program, иначе .NET Framework может не распознать его в качестве стартовой точки при запуске вашего приложения. (Более подробно методы будут рассматриваться в главе 3 «Создание методов и применение областей видимости», а в главе 7 содержится больше информации о статических методах.)
ВНИМАНИЕ Язык C# чувствителен к регистру символов. Main нужно писать с большой буквы «M».
В следующих упражнениях вы напишете код, выводящий в окно консоли сообщение «Hello World!», создадите и запустите консольное приложение Hello World и узнаете, как для разделения элементов кода используется пространство имен.
Написание кода с использованием Microsoft IntelliSense
Найдите в окне кода и текстового редактора, где отображается содержимое файла Program.cs, метод Main и поместите курсор сразу же после принадлежащей ему открывающей фигурной скобки ( { ), затем для создания новой строки нажмите Ввод.
Наберите в новой строке слово Console, которое будет именем еще одного класса, предоставляемого сборками, на которые имеются ссылки из вашего приложения. Этот класс предоставляет методы для вывода сообщений в окно консоли и чтения ввода с клавиатуры.
Как только в начале слова Console будет набрана буква «C», появится список IntelliSense. В этом списке будут содержаться все ключевые слова C# и типы данных, подходящие к данному контексту. Можно либо продолжить набор, либо прокрутить список и дважды щелкнуть кнопкой мыши на элементе Console. Или же после того, как будет набран фрагмент Cons, список IntelliSense автоматически выделит элемент Console (рис. 1.6), для выбора которого можно будет нажать клавишу табуляции или клавишу Ввод.
Рис. 1.6
Метод Main должен приобрести следующий вид:
static void Main(string[] args)
{
Console
}
ПРИМЕЧАНИЕ Console является встроенным классом.
Наберите сразу же после слова Console символ точки. Появится еще один список IntelliSense, показывающий методы, свойства и поля класса Console.
Прокрутите список вниз, выберите элемент WriteLine и нажмите Ввод. Можно также продолжить набор и вводить символы W, r, i, t, e, L, пока не будет выбран элемент WriteLine, а затем нажать Ввод.
Список IntelliSense закроется, и к исходному файлу будет добавлено слово WriteLine. Теперь Main должен приобрести следующий вид:
static void Main(string[] args)
{
Console.WriteLine
}
Наберите открывающую скобку, (. Появится еще одна подсказка IntelliSense. В этой подсказке будут выведены параметры, воспринимаемые методом WriteLine, который относится к так называемым перегружаемым методам, а это означает, что в классе Console имеется более одного метода по имени WriteLine, фактически же им предоставляются 19 различных версий этого метода. Каждую версию метода WriteLine можно использовать для вывода различных типов данных. (Более подробно перегружаемые методы рассматриваются в главе 3.) Теперь Main должен иметь следующий вид:
static void Main(string[] args)
{
Console.WriteLine(
}
СОВЕТ Чтобы прокручивать различные варианты перегружаемого метода WriteLine, можно воспользоваться клавишами вертикальных стрелок.
Наберите закрывающую круглую скобку, ), а после нее поставьте точку с запятой, ;. Теперь Main должен выглядеть следующим образом:
static void Main(string[] args)
{
Console.WriteLine();
}
Переместите курсор и наберите строку "Hello World!", включая кавычки, между левой и правой круглыми скобками, которые следуют за именем метода WriteLine. Теперь Main должен приобрести следующий вид:
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
}
СОВЕТ Возьмите в привычку набирать соответствующие друг другу пары символов, например круглые скобки, ( и ), и фигурные скобки, { и }, до заполнения пространства между ними нужным содержимым. Если откладывать набор закрывающего символа на потом, то после ввода содержимого о нем легко забыть.
Значки IntelliSense
При наборе точки после имени класса IntelliSense показывает имя каждого элемента класса. Слева от каждого имени элемента располагается значок с изображением типа элемента. К числу стандартных значков и их типов относятся следующие.
| Значок | Значение |
|
| Метод (рассматривается в главе 3) |
|
| Свойство (рассматривается в главе 15 «Реализация свойств для доступа к полям») |
|
| Класс (рассматривается в главе 7) |
|
| Структура (рассматривается в главе 9) |
|
| Перечисление (рассматривается в главе 9) |
|
| Метод расширения (рассматривается в главе 12 «Работа с наследованием») |
|
| Интерфейс (рассматривается в главе 13 «Создание интерфейсов и определение абстрактных классов») |
|
| Делегирование (рассматривается в главе 17 «Введение в обобщения») |
|
| Событие (рассматривается в главе 17) |
|
| Пространство имен (рассматривается в следующем разделе данной главы) |
При наборе кода в различных контекстах будут попадаться и другие значки IntelliSense.
Вам будут часто встречаться строки кода, содержащие два прямых слеша (//), за которыми следует обычный текст. Это комментарии, игнорируемые компилятором, но приносящие большую пользу разработчикам, поскольку они помогают документировать текущие действия программы. Возьмем, к примеру, следующий фрагмент кода:
Console.ReadLine(); // Ожидание, пока пользователь не нажмет Ввод
Компилятор пропускает весь текст, начиная с двух слешей и заканчивая концом строки. Можно также добавлять многострочные комментарии, начинающиеся с прямого слеша со звездочкой (/*). Компилятор пропустит все, пока не встретит звездочку с прямым слешем (*/), которые могут находиться несколькими строчками ниже. Настоятельно рекомендуется документировать код в необходимых объемах предметными комментариями.
Сборка и запуск консольного приложения
Щелкните в меню Сборка (Build) на пункте Собрать решение (Build Solution). Код C# будет откомпилирован, в результате чего появится программа, которую можно будет запустить. Под окном редактора появится окно Вывод (Output).
СОВЕТ Если окно вывода не появится, щелкните для его отображения на пункте Вывод меню Вид (View).
В окне вывода должно появиться следующее сообщение, показывающее результаты компилирования программы:
1>------ Сборка начата: проект: TestHello, Конфигурация: Debug Any CPU ------
1> TestHello -> C:\Users\Николай\Documents\Microsoft Press\VCSBS\Chapter 1\TestHello\TestHello\bin\Debug\TestHello.exe
========== Сборка: успешно: 1, с ошибками: 0, без изменений: 0, пропущен
Если допущены какие-либо ошибки, отчет о них будет помещен в окне Список ошибок (Error List). На рис. 1.7 показано, что получится, если забыть набрать закрывающие кавычки после текста Hello World в инструкции WriteLine. Обратите внимание на то, что одна допущенная ошибка может стать причиной сразу нескольких ошибок компиляции.
Рис. 1.7
СОВЕТ Чтобы попасть точно на ту строку, где находится ошибка, можно дважды щелкнуть на записи в окне списка ошибок. Обратите внимание на то, что Visual Studio выводит красную волнистую линию под всеми строками кода, не прошедшими компиляцию после их ввода.
Если вы точно следовали предыдущим инструкциям, никаких ошибок и предупреждений быть не должно и сборка программы должна завершиться успешно.
СОВЕТ Сохранять файл непосредственно перед сборкой нет никакого смысла, поскольку команда Собрать решение автоматически выполнит его сохранение.
Символ звездочки, стоящий после имени файла во вкладке над окном редактора, показывает, что файл со времени последнего сохранения был изменен.
Щелкните в меню Отладка (Debug) на пункте Запуск без отладки (Start Without Debugging). Откроется окно командной строки, и программа запустится. Появится сообщение «Hello World!». Как показано на рис. 1.8, теперь программа ждет от вас нажатия клавиши.
Рис. 1.8
ПРИМЕЧАНИЕ Приглашение «Для продолжения нажмите любую клавишу…» («Press any key to continue») генерируется Visual Studio, вы для этого не написали ни строчки кода. Если программа запущена с использованием команды Начать отладку (Start Debugging) в меню Отладка, приложение запускается, но окно командной строки закрывается сразу же, не ожидая нажатия клавиши.
Убедитесь в том, что окно командной строки, показывающее вывод программы, имеет фокус (то есть находится в активном состоянии), а затем нажмите Ввод. Окно закроется, и вы вернетесь в среду программирования Visual Studio 2015.
Щелкните на панели Обозреватель решений (Solution Explorer) на проекте (но не на решении) TestHello, а затем на панели задач этого обозревателя щелкните на кнопке Показать все файлы (Show All Files). Чтобы эта кнопка появилась, может понадобиться щелкнуть на кнопке с двумя стрелками, находящейся на правом краю той же панели инструментов (рис. 1.9).
Рис. 1.9
Над именем файла Program.cs появятся записи bin и obj. Они напрямую связаны с одноименными папками, находящимися в папке проекта (Microsoft Press\VCSBS\Chapter 1\ TestHello\TestHello). Visual Studio создает эти папки при сборке приложения. В них содержится исполняемая версия программы, а также некоторые другие файлы, используемые для сборки и отладки приложения.
Откройте в обозревателе решений папку bin. Появится еще одна папка с именем Debug (отладка).
ПРИМЕЧАНИЕ Можно также увидеть папку Release.
Откройте папку Debug. Появятся еще несколько элементов, включая файл TestHello.exe. Это скомпилированная программа в виде файла, запускаемого при щелчке на пункте Запуск без отладки в меню Отладка. В остальных файлах содержится информация, используемая Visual Studio 2015 при запуске программы в режиме отладки при щелчке на пункте Начать отладку (Start Debugging).
Использование пространств имен
Рассмотренный пример представляет собой очень маленькую программу. Но небольшие программы могут вскоре разрастись и приобрести весьма солидный объем. При увеличении размеров программы возникают две проблемы. Во-первых, по сравнению с небольшими программами, в больших труднее разобраться и их сложнее сопровождать. Во-вторых, обычно чем больше кода, тем больше классов, в которых больше методов, что требует отслеживания все большего количества имен. По мере роста количества имен растет и вероятность сбоя при сборке проекта из-за конфликта двух и более имен. Как, например, при попытке создания двух классов с одинаковыми именами. Ситуация еще больше усложняется, когда программа ссылается на сборки, написанные другими разработчиками, которые также использовали разнообразные имена.
В прошлом программисты пытались решить проблему конфликта имен, ставя перед именами префиксы с каким-либо классификатором (или набором классификаторов). Но это решение нельзя назвать удачным, поскольку оно не позволяет проводить масштабирование. Имена становятся длиннее, и написанию программы уделяется меньше времени, а на набор текста (там, где нужна разница в именах) и чтение, а также перечитывание слишком длинных имен его уходит гораздо больше.
Данная проблема решается с помощью пространств имен (namespaces) путем создания контейнеров для таких элементов, как классы. Два класса с одинаковыми именами не приведут к возникновению путаницы, если они находятся в разных пространствах имен. Используя ключевое слово namespace, можно внутри пространства имен под названием TestHello создать класс по имени Greeting:
namespace TestHello
{
class Greeting
{
...
}
}
После этого в вашей программе можно обращаться к классу Greeting с помощью ссылки TestHello.Greeting. Если другой разработчик также создаст класс Greeting, но уже в другом пространстве имен, например NewNamespace, и вы установите сборку, содержащую этот класс, на свой компьютер, ваши программы не изменят своего поведения, поскольку в них используется ваш класс TestHello.Greeting. Если понадобится обратиться к классу Greeting другого разработчика, нужно будет указать на него как на NewNamespace.Greeting.
Определение всех классов в пространствах имен является рекомендуемой нормой, и среда Visual Studio 2015 следует этой рекомендации, используя в качестве пространства имен верхнего уровня название вашего проекта. В библиотеке классов .NET Framework также соблюдается эта норма, поэтому каждый класс в этой библиотеке находится в своем пространстве имен. Например, класс Console находится в пространстве имен System. Следовательно, его полным именем будет System.Console.
Конечно, если вам придется каждый раз писать полное имя класса, то это будет ничем не лучше использования префиксных классификаторов или глобальных имен вроде System.Console. К счастью, эту проблему можно решить с помощью директивы использования using. Если вернуться к программе TestHello в Visual Studio 2015 и посмотреть на содержимое файла Program.cs, то в самом начале этого файла можно заметить следующие строки:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
Это директивы using. С их помощью пространство имен вводится в область видимости. В последующем коде этого же файла уже не нужно конкретно указывать объектам то пространство имен, которому они принадлежат. Показанные пять пространств имен содержат классы, используемые настолько часто, что Visual Studio 2015 автоматически добавляет эти директивы using при каждом создании нового проекта. Если нужны ссылки на другие пространства имен, то в начало файла исходного кода можно добавлять дополнительные директивы using.
Более подробно концепция пространства имен иллюстрируется на следующих примерах.
Попытка работы с простым написанием имен
Закомментируйте в окне с содержимым файла Program.cs первую директиву using:
//using System;
Щелкните в меню Сборка на пункте Собрать решение. Сборка даст сбой, а в окно списка ошибок будет выведено сообщение
Имя "Console" не существует в текущем контексте.
Щелкните дважды на сообщении об ошибке. Идентификатор, вызвавший ошибку, будет подчеркнут в тексте исходного кода в Program.cs красной волнистой линией.
Отредактируйте метод Main под использование полностью классифицированного имени System.Console. Метод Main должен приобрести следующий вид:
static void Main(string[] args)
{
System.Console.WriteLine("Hello World!");
}
ПРИМЕЧАНИЕ При наборе точки после System модуль IntelliSense выводит имена всех элементов, имеющихся в пространстве имен System.
Щелкните в меню Сборка на пункте Собрать решение. На этот раз сборка должна пройти успешно. Если этого не произошло, убедитесь, что у метода Main точно такой же код, как показан ранее, и проведите сборку повторно.
Запустите приложение, чтобы убедиться в его работоспособности, щелкнув на пункте Запуск без отладки (Start Without Debugging) меню Отладка. После запуска программы и вывода в окне консоли приветствия «Hello World!» нажмите Ввод, чтобы вернуться в Visual Studio 2015.
Пространства имен и сборки
Директива using просто помещает элементы пространства имен в область видимости и освобождает вас от необходимости использования в именах кода полной классификации. Классы компилируются в сборки.
Сборка представляет собой файл, для имени которого обычно используется расширение .dll, хотя, строго говоря, исполняемые программы в файлах с расширением .exe также являются сборками.
В сборке может содержаться множество классов. Классы, включенные в библиотеку классов .NET Framework, например System.Console, предоставляются в сборках, устанавливаемых на ваш компьютер вместе с Visual Studio. Вы увидите, что библиотека классов .NET Framework содержит тысячи классов. Если бы все они содержались в одной сборке, она была бы слишком большой и сложной в сопровождении. (Если бы компании Microsoft понадобилось обновить всего лишь один метод в одном из классов, то ей пришлось бы распространить всю библиотеку классов среди всех разработчиков!)
Поэтому библиотека классов .NET Framework разбита на целый ряд сборок, разделенных функциональными областями, к которым относятся содержащиеся в них классы. Например, основная сборка (mscorlib.dll) содержит все классы общего назначения, такие как System.Console, а другие сборки содержат классы для работы с базами данных, обращения к веб-службам, создания GUI-интерфейсов и т.д. Если нужно воспользоваться классом в сборке, в проект следует добавить ссылку на эту сборку. Затем к коду можно добавить директиву using, помещающую элементы в пространстве имен этой сборки в область видимости.
Следует заметить, что сборка и пространство имен необязательно должны соотноситься друг с другом по принципу один к одному: в одной сборке могут содержаться классы, определенные во многих пространствах имен, а одно пространство имен может распространяться на несколько сборок. Например, классы и элементы в пространстве имен System реализуются несколькими сборками, включая, кроме всего прочего, mscorlib.dll, System.dll и System.Core.dll. Поначалу все это кажется немного странным, но вскоре вы к этому привыкнете.
Когда Visual Studio используется для создания приложения, выбранный вами шаблон автоматически включает ссылки на соответствующие сборки. К примеру, откройте в обозревателе решений папку Ссылки проекта TestHello. Там вы увидите, что в консольное приложение автоматически включены ссылки на сборки с названиями Microsoft.CSharp, System, System.Core, System.Data, System.Data.DataSetExtensions, System.Net.Http, System.Xml и System.Xml.Linq. Возможно, вы удивитесь отсутствию в этом перечне библиотеки mscorlib.dll. Дело в том, что все приложения .NET Framework должны использовать эту сборку, поскольку в ней содержатся основные функции времени выполнения. В папке Ссылки перечислены только дополнительные сборки, и при необходимости их перечень можно расширить или сократить.
Чтобы добавить к проекту ссылки на дополнительные сборки, нужно щелкнуть правой кнопкой мыши на папке Ссылки, после чего щелкнуть на пункте Добавить ссылку (Add Reference). Этим вам придется заниматься при выполнении следующих упражнений. Удалить сборку можно из того же контекстного меню, щелкнув правой кнопкой на сборке и выбрав пункт Удалить (Remove).
Создание графического приложения
Итак, вы уже воспользовались средой Visual Studio 2015 для создания и запуска простого консольного приложения. Но в этой среде программирования есть все необходимое и для создания графических приложений для Windows 10. Ссылки на соответствующие шаблоны выглядят как универсальное приложение Windows (приложение Universal Windows Platform, или UWP-приложение), поскольку они позволяют создавать приложения, работающие на любых устройствах под управлением Windows: настольных компьютерах, планшетах и телефонах. Разработать пользовательский интерфейс (UI) Windows-приложения можно в интерактивном режиме. После этого Visual Studio 2015 создаст программные инструкции для реализации разработанного вами пользовательского интерфейса.
Visual Studio 2015 предоставляет графическое приложение в двух видах: в виде конструктора и в виде кода. Окно редактора используется для изменения и обслуживания кода и программной логики графического приложения, а окно конструктора (Design View) — для разметки вашего пользовательского интерфейса (UI). Переключаться между этими двумя видами можно будет по мере надобности.
В следующем наборе упражнений вы научитесь создавать графическое приложение с использованием Visual Studio 2015. Создаваемая программа показывает простую форму, содержащую текстовое поле, в которое можно ввести ваше имя, и кнопку, после щелчка на которой в окне сообщений выводится персональное приветствие.
Если вам нужна более полная информация о специфике написания UWP-приложений, то соответствующее руководство и подробности вы найдете в последних нескольких главах части IV этой книги.
Создание графического приложения в Visual Studio 2015
Откройте диалоговое окно Создание проекта, щелкнув в меню Файл на пункте Создать, а затем на пункте Проект. Раскройте в левой панели узел Установленные и последовательно раскройте пункты Шаблоны, Visual C#, Windows, а затем щелкните на пункте Универсальные. Щелкните в средней панели на значке Пустое приложение… (Blank App…).
ПРИМЕЧАНИЕ XAML означает расширяемый язык разметки для приложений — Extensible Application Markup Language. Этот язык используется приложениями универсальной платформы Windows — Universal Windows Platform для определения разметки графического пользовательского интерфейса (GUI) приложения. Более полные сведения о XAML вы получите по мере выполнения представленных в книге упражнений.
В поле Расположение (Location) должна быть ссылка на папку \Microsoft Press\VCSBS\ Chapter 1, которая находится в вашей папке Документы.
Наберите в поле Имя название проекта Hello. Установите флажок Создать каталог для решения и щелкните на кнопке OK.
Когда UWP-приложение создается в первый раз, может появиться предложение включить режим разработчика для Windows 10 (рис. 1.10). В зависимости от устройства, на котором вы работаете, и от версии Windows 10 у вас может быть возможность включить режим разработчика через интерфейс пользователя, но ее может и не быть. Дополнительное руководство по включению режима разработчика можно найти в статье «Enable your device for development» по адресу .
Рис. 1.10
ПРИМЕЧАНИЕ Это диалоговое окно может появиться при создании нового UWP-приложения или при первой попытке запуска UWP-приложения из Visual Studio.
После создания приложения обратите внимание на панель обозревателя решений. Пусть вас не смущает слово «пустое» в названии шаблона приложения — этот шаблон предоставляет целый ряд файлов и содержит программный код. К примеру, если открыть папку MainPage.xaml, то в ней окажется файл с кодом C# по имени MainPage.xaml.cs. Потом в этот файл нужно будет добавить код, запускаемый при отображении на экране пользовательского интерфейса, определенного в файле MainPage.xaml.
Дважды щелкните в обозревателе решений на имени файла MainPage.xaml. В этом файле содержится разметка пользовательского интерфейса. В окне конструктора будут показаны два представления данного файла (рис. 1.11).
В верхней части будет находиться графическое представление, по умолчанию изображающее 5-дюймовый экран телефона, а в нижней панели — описание содержимого этого экрана на XML-подобном языке XAML, который используется UWP-приложениями для определения разметки формы и ее содержимого. Тем, кто имеет опыт работы с XML, язык XAML должен показаться знакомым.
В следующем упражнении окно конструктора будет использоваться для разметки пользовательского интерфейса приложения и изучения XAML-кода, создаваемого на основе этой разметки.
СОВЕТ Чтобы получить больше места для отображения окна конструктора, закройте окна вывода и списка ошибок.
Рис. 1.11
ПРИМЕЧАНИЕ Перед тем как продолжить выполнение упражнения, нужно разобраться в некоторых терминологических тонкостях. В традиционных Windows-приложениях пользовательский интерфейс состоит из одного или нескольких окон, но в приложении, относящемся к Universal Windows Platform, соответствующие понятия фигурируют как страницы. Для большей ясности я просто буду ссылаться на оба понятия, используя общий термин «форма», но при этом продолжу использовать слово «окно» для ссылок на такие элементы интегрированной среды разработки Visual Studio 2015, как, к примеру, окно конструктора.
В следующих примерах окно конструктора будет использоваться для добавления к форме, выводимой вашим приложением, трех элементов управления. Кроме того, будет проанализирован код C#, автоматически создаваемый Visual Studio 2015 для реализации этих элементов управления.
Создание пользовательского интерфейса
Раскройте вкладку Панель элементов (Toolbox), появившуюся слева от формы в окне конструктора, где отобразятся различные компоненты и элементы управления, которые можно помещать в форму. Раскройте раздел Типовые элементы управления XAML (Common XAML Controls), где вы увидите перечень элементов управления, используемых большинством графических приложений.
СОВЕТ Расширенный перечень элементов управления приведен в разделе Все элементы управления XAML (All XAML Controls).
Щелкните в этом разделе на пункте TextBlock и перетащите представляемый им элемент управления в форму, отображаемую в окне конструктора.
СОВЕТ Не перепутайте TextBlock и TextBox. Если случайно в форму будет помещен не тот элемент управления, его можно будет удалить, щелкнув на его изображении в форме и нажав клавишу Del.
К форме будет добавлен элемент управления TextBlock, обозначающий надпись (который вскоре будет перемещен на предназначенное ему место), и панель элементов скроется из виду.
СОВЕТ Если нужно, чтобы панель элементов оставалась видимой, но не заслоняла собой часть формы, найдите на правой границе заголовка этой панели кнопку Автоматически скрывать (Auto Hide), на которой изображен значок закрепления. Панель элементов зафиксируется в левой части окна Visual Studio 2015, и окно конструктора сожмется, приспосабливаясь к новым условиям. (Если экран имеет низкое разрешение, то будет потеряна существенная часть рабочего пространства.) Повторный щелчок на кнопке автоматического сокрытия приведет к тому, что панель элементов будет удалена с экрана.
Скорее всего, TextBlock не будет сразу помещен в форме именно туда, куда вам нужно. Добавленные к форме элементы можно перетаскивать, изменяя их местоположение. Переместите TextBlock в верхний левый угол формы. (Его точное местоположение для этого приложения не важно.) Учтите, что перед перемещением элемента в окне конструктора может сначала понадобиться щелкнуть где-нибудь за его пределами, а затем еще раз щелкнуть, но уже на самом элементе.
Теперь XAML-описание формы в нижней панели будет включать элемент управления TextBlock вместе с такими свойствами, как его местоположение в форме, регулируемое свойством Margin, исходный текст, отображаемый этим элементом управления и задаваемый значением свойства Text, настройка выравнивания текста, который выводится этим элементом управления, регулируемая свойствами HorizontalAlignment и VerticalAlignment, и настройка необходимости переноса текста на новые строки, если он шире элемента.
XAML-код для TextBlock будет иметь приблизительно следующий вид (в зависимости от конкретного размещения TextBlock в форме значения свойства Margin могут быть несколько иными):
<TextBlock x:Name="textBlock" HorizontalAlignment="Left" Margin="10,10,0,0"
TextWrapping="Wrap"
Text="TextBlock" VerticalAlignment="Top"/>
Панель XAML и окно конструктора имеют двунаправленные взаимоотношения друг с другом. Можно отредактировать значения в панели XAML, и изменения будут отображены в окне конструктора. Например, можно изменить местоположение TextBlock, отредактировав значения в свойстве Margin.
Щелкните в меню Вид (View) на пункте Окно свойств (Properties Window). Если этого окна еще не было на экране, то оно появится в его правом нижнем углу под панелью обозревателя решений. Свойства элементов управления можно указать с помощью панели XAML под окном конструктора, но окно свойств предоставляет более удобный способ изменения свойств элементов формы и других элементов проекта.
Содержимое окна свойств зависит от контекста и показывает свойства текущего выбранного элемента. Если щелкнуть на форме, отображаемой в окне конструктора (за пределами элемента TextBlock), в окне свойств будут выведены свойства элемента Grid. Если посмотреть на панель XAML, станет понятно, что элемент TextBlock находится внутри элемента Grid. Этот элемент содержится во всех формах и управляет разметкой отображаемых элементов. Можно, к примеру, определить табличные макеты, добавив к Grid строки и столбцы.
Щелкните в окне конструктора на элементе TextBlock, и в окне свойств опять появятся свойства этого элемента.
Раскройте в окне свойств свойство Text. Измените свойство FontSize, установив для него значение 20 pt, и нажмите Ввод. Это свойство следует сразу же за раскрывающимся списком с названиями шрифтов, в котором показан шрифт Segoe UI (рис. 1.12).
Рис. 1.12
ПРИМЕЧАНИЕ Суффикс pt показывает, что размер шрифта измеряется в пунктах, где 1 пункт равен 1/72 дюйма.
Посмотрите на текст с определением элемента управления TextBlock в панели XAML, расположенной ниже окна конструктора. Если добраться до конца строки, то станет виден текст FontSize= "26.667 ". Это значение, полученное путем приблизительного преобразования размера шрифта из пунктов в пикселы (считается, что 3 пункта приблизительно равны 4 пикселам, хотя точное преобразование будет зависеть от размера и разрешения вашего экрана). Любые изменения, внесенные в окне свойств, автоматически отображаются в XAML-определении, и наоборот.
Поменяйте значение атрибута FontSize в панели XAML на 24. Размеры шрифта текста для элемента TextBlock в окне конструктора и в окне свойств тут же изменятся.
Изучите в окне свойств другие свойства элемента TextBlock. Поэкспериментируйте с ними, изменяя их значения и наблюдая за производимыми эффектами.
Обратите внимание на то, что в ходе изменения значений свойств эти свойства добавляются в определение элемента TextBlock на панели XAML. Каждый добавляемый к форме элемент имеет исходный набор значений свойств, и эти значения не отображаются в панели XAML, пока в них не вносятся изменения.
Измените значение свойства Text элемента TextBlock с TextBlock на Пожалуйста, введите свое имя. Это можно сделать либо редактированием элемента Text в панели XAML, либо изменением значения в окне свойств, где это свойство находится в разделе Общие (Common). Обратите внимание на изменение текста, показанного в элементе TextBlock в окне конструктора.
Щелкните еще раз на форме в окне конструктора, а затем снова выведите на экран панель элементов. Перетащите из этой панели на форму элемент управления TextBox, обозначающий текстовое поле. Разместите этот элемент непосредственно под элементом управления TextBlock.
СОВЕТ Когда при перетаскивании элемента в форму он выходит на уровни вертикальных или горизонтальных границ других элементов, автоматически появляются индикаторы выравнивания. Это позволяет быстро оценить точность выравнивания элементов управления друг относительно друга.
Поместите указатель мыши в окне конструктора над правым краем элемента TextBox. Указатель должен принять вид двунаправленной стрелки, указывающей на возможность изменения размера элемента. Перетащите правый край элемента TextBox на уровень правого края расположенного выше элемента TextBlock, и когда края элементов будут на одном уровне, появится индикатор выравнивания.
Выберите элемент TextBox и в верхней части окна свойств измените значение свойства Name с textBox на userName (рис. 1.13).
Рис. 1.13
ПРИМЕЧАНИЕ Более подробно соглашение об именах элементов управления и переменных будет рассматриваться в главе 2 «Работа с переменными, операторами и выражениями».
Еще раз выведите на экран панель элементов и перетащите с нее на форму элемент управления Button, обозначающий кнопку. Поместите кнопку справа от элемента TextBox, выровняв ее по горизонтали с нижним краем текстового поля.
Используя окно свойств, измените свойство Name элемента Button на ok и измените значение свойства Content в разделе Общие с Button на OK, после чего нажмите Ввод. Убедитесь, что надпись в элементе Button на форме изменилась и показывает текст OK.
Теперь форма должна приобрести приблизительно следующий вид (рис. 1.14).
ПРИМЕЧАНИЕ Раскрывающееся меню в левом верхнем углу окна конструктора позволяет посмотреть, как форма будет выводиться на экраны разных размеров и разрешений. В данном примере исходным выбором является просмотр на экране пятидюймового телефона с разрешением 1920×1080. Справа от раскрывающегося меню расположены две кнопки, позволяющие переключаться между книжной и альбомной ориентацией экрана. Проекты следующих глав будут использовать в качестве рабочей области конструирования экран настольного компьютера с диагональю 13,3 дюйма, но для этого упражнения можно оставить форм-фактор пятидюймового телефона.
Щелкните в меню Сборка на пункте Собрать решение, после чего убедитесь в успешной сборке проекта.
Рис. 1.14
Убедитесь, что в показанном на рис. 1.15 раскрывающемся списке цели отладчика выбран пункт Локальный компьютер (Local Machine). (Изначально целью отладчика может быть Device, и среда попытается подключиться к устройству Windows phone, в результате чего сборка пройдет неудачно.) Затем щелкните в меню Отладка на пункте Начать отладку.
Рис. 1.15
Приложение должно запуститься и вывести на экран вашу форму, которая будет иметь следующий вид (рис. 1.16).
В текстовом поле поверх имеющегося текста можно набрать свое имя, а затем щелкнуть на кнопке OK, но пока что это ни к чему не приведет. Чтобы показать, что должно произойти при щелчке пользователя на кнопке OK, нужно добавить программный код, чем мы далее и займемся.
Рис. 1.16
ПРИМЕЧАНИЕ При запуске UWP-приложения в режиме отладки в левом верхнем углу формы появляются два числа. Эти числа являются результатом трассировки частоты кадров, и разработчики могут воспользоваться этой информацией для определения момента, когда приложение начинает откликаться медленнее положенного (возможно, выявляя при этом проблемы производительности). Эти числа появляются только тогда, когда приложение запускается в режиме отладки. Их полное описание не входит в круг вопросов, рассматриваемых в данной книге, поэтому сейчас вы можете их проигнорировать.
Вернитесь в Visual Studio 2015. Щелкните в меню Отладка на пункте Остановить отладку (Stop Debugging).
ПРИМЕЧАНИЕ Чтобы закрыть форму, остановить отладку и вернуться в Visual Studio, можно также щелкнуть на кнопке закрытия (которая имеет значок X и находится в правом верхнем углу формы).
Вам удалось справиться с созданием графического приложения, не написав ни одной строчки кода C#. Это приложение пока что ни к чему не пригодно (поэтому вскоре вам придется заняться написанием дополнительного кода), но среда Visual Studio 2015 фактически уже создала для вас немалый объем кода, справляющийся с рутинными задачами, выполняемыми всеми графическими приложениями, в числе которых запуск и отображение окна. Перед добавлением к приложению собственного кода полезно будет разобраться в том, что именно среда Visual Studio создала для вас. Автоматически созданные ею артефакты рассматриваются в следующем разделе.
Изучение UWP-приложения
Раскройте в обозревателе решений узел MainPage.xaml, после чего дважды щелкните на появившемся имени файла MainPage.xaml.cs. В окне кода и текстового редактора появится следующий предназначенный для формы код:
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;
// Документацию по шаблону элемента "Пустая страница" см. по адресу
//
namespace Hello
{
/// <summary>
/// Пустая страница, которую можно использовать саму по себе или для перехода
/// внутри фрейма.
/// </summary>
public sealed partial class MainPage : Page
{
public MainPage()
{
this.InitializeComponent();
}
}
}
Кроме солидного количества директив using, вводящих в область видимости ряд пространств имен, используемых большинством UWP-приложений, в файле содержится лишь определение класса MainPage. В этом определении имеется небольшой фрагмент кода для класса MainPage, известный как конструктор, вызывающий метод InitializeComponent. Конструктором называется специальный метод, имя которого совпадает с именем класса. Он запускается при создании экземпляра класса и может содержать код для инициализации экземпляра. Конструкторы будут рассматриваться в главе 7.
Обычно в классе содержится намного больше кода, чем те несколько строк, что показаны в файле MainPage.xaml.cs, но существенная часть этого кода генерируется автоматически на основе XAML-описания формы и скрыта от просмотра. Этот скрытый код выполняет такие операции, как создание и вывод формы и создание и позиционирование в форме различных элементов управления.
СОВЕТ Файл кода C# для страницы в UWP-приложении можно также вывести на экран при отображении окна конструктора, щелкнув в меню Вид на пункте Код.
Вы можете спросить: а где же метод Main и как форма отображается при запуске приложения? Вспомним, что в консольном приложении метод Main определяет точку старта программы. Графическое приложение немного отличается от консольного.
В обозревателе решений нужно обратить внимание на другой исходный файл по имени App.xaml. Если раскрыть узел, показанный для этого файла, то станет виден еще один файл по имени App.xaml.cs. В UWP-приложении файл App.xaml предоставляет точку входа, с которой начинается запуск приложения. Если в обозревателе решений дважды щелкнуть на имени файла App.xaml.cs, станет виден код, имеющий следующий вид:
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.ApplicationModel;
using Windows.ApplicationModel.Activation;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;
namespace Hello
{
/// <summary>
/// Обеспечивает зависящее от конкретного приложения поведение, дополняющее
/// класс Application по умолчанию.
/// </summary>
sealed partial class App : Application
{
/// <summary>
/// Инициализирует одноэлементный объект приложения. Это первая
/// выполняемая строка разрабатываемого
/// кода, поэтому она является логическим эквивалентом main() или
/// WinMain().
/// </summary>
public App()
{
Microsoft.ApplicationInsights.WindowsAppInitializer.InitializeAsync(
Microsoft.ApplicationInsights.WindowsCollectors.Metadata |
Microsoft.ApplicationInsights.WindowsCollectors.Session);
this.InitializeComponent();
this.Suspending += OnSuspending;
}
/// <summary>
/// Вызывается при обычном запуске приложения пользователем. Будут
/// использоваться другие точки входа,
/// например, если приложение запускается для открытия конкретного файла.
/// </summary>
/// <param name="e">Сведения о запросе и обработке запуска.</param>
protected override void OnLaunched(LaunchActivatedEventArgs e)
{
#if DEBUG
if (System.Diagnostics.Debugger.IsAttached)
{
this.DebugSettings.EnableFrameRateCounter = true;
}
#endif
Frame rootFrame = Window.Current.Content as Frame;
// Не повторяйте инициализацию приложения, если в окне уже имеется
// содержимое, только обеспечьте активность окна
if (rootFrame == null)
{
// Создание фрейма, который станет контекстом навигации, и переход
// к первой странице
rootFrame = new Frame();
rootFrame.NavigationFailed += OnNavigationFailed;
if (e.PreviousExecutionState ==
ApplicationExecutionState.Terminated)
{
//TODO: Загрузить состояние из ранее приостановленного
// приложения
}
// Размещение фрейма в текущем окне
Window.Current.Content = rootFrame;
}
if (rootFrame.Content == null)
{
// Если стек навигации не восстанавливается для перехода к первой
// странице, настройка новой страницы осуществляется путем передачи
// необходимой информации в качестве параметра навигации
rootFrame.Navigate(typeof(MainPage), e.Arguments);
}
// Обеспечение активности текущего окна
Window.Current.Activate();
}
/// <summary>
/// Вызывается в случае сбоя навигации на определенную страницу
/// </summary>
/// <param name="sender">Фрейм, для которого произошел сбой
/// навигации</param>
/// <param name="e">Сведения о сбое навигации</param>
void OnNavigationFailed(object sender, NavigationFailedEventArgs e)
{
throw new Exception("Failed to load Page " +
e.SourcePageType.FullName);
}
/// <summary>
/// Вызывается при приостановке выполнения приложения. Состояние
/// приложения сохраняется без учета информации о том, будет оно
/// завершено или возобновлено с неизменным содержимым памяти.
/// </summary>
/// <param name="sender">Источник запроса приостановки.</param>
/// <param name="e">Сведения о запросе приостановки.</param>
private void OnSuspending(object sender, SuspendingEventArgs e)
{
var deferral = e.SuspendingOperation.GetDeferral();
//TODO: Сохранить состояние приложения и остановить все фоновые
// операции
deferral.Complete();
}
}
}
Значительная часть этого кода состоит из комментариев (строк, начинающихся с ///) и других инструкций, в которых вам пока не нужно разбираться, а ключевые элементы находятся в методе OnLaunched, код которого выделен полужирным шрифтом. Этот метод запускается в начале работы приложения, а его код заставляет приложение создать новый объект фрейма — Frame, вывести в этом фрейме форму MainPage, а затем активировать эту форму. На данном этапе нам не нужно полностью разбираться в принципе работы этого кода или понимать синтаксис любой из этих инструкций, достаточно просто понять, что этот код предоставляет способ отображения формы при запуске приложения.
Добавление кода к графическому приложению
Немного разобравшись в структуре графического приложения, следует перейти к написанию кода, позволяющего приложению выполнять какую-либо реальную работу.
Давайте напишем код для кнопки OK. Откройте в окне конструктора файл MainPage.xaml, дважды щелкнув на его имени в обозревателе решений. Выберите в форме окна конструктора кнопку OK, дважды щелкнув на ее изображении. Щелкните в окне свойств на кнопке Обработчик событий для выбранного элемента (Event Handlers button for the selected element). Значок на этой кнопке похож на вспышку молнии (рис. 1.17).
В окне свойств появится перечень событий для кнопки. Событие указывает на значимое действие, требующее, как правило, ответной реакции, для которой можно написать собственный код.
Наберите в поле, относящемся к событию Click, текст okClick и нажмите Ввод. В окне редактора появится содержимое файла MainPage.xaml.cs с новым,
Рис. 1.17
добавленным к классу MainPage методом под названием okClick, у которого будет следующий внешний вид:
private void okClick(object sender, RoutedEventArgs e)
{
}
Синтаксис этого кода нас пока не интересует, поскольку подробнее методы будут рассмотрены в главе 3. Добавьте к перечню в начале файла директиву using (выделена жирным шрифтом, символ многоточия … заменяет пропущенные для краткости инструкции):
using System;
...
using Windows.UI.Xaml.Navigation;
using Windows.UI.Popups;
Добавьте к методу okClick код, выделенный жирным шрифтом:
private void okClick(object sender, RoutedEventArgs e)
{
MessageDialog msg = new MessageDialog("Привет, " + userName.Text);
msg.ShowAsync();
}
Это код запустится, когда пользователь щелкнет на кнопке OK. Здесь мы также пока оставим синтаксис без внимания, от вас требуется лишь точно скопировать показанный код, а смысл инструкций станет понятен при изучении нескольких следующих глав. Главное — уяснить, что первая инструкция создает объект MessageDialog с сообщением «Привет, <ВашеИмя>», где вместо вставки <ВашеИмя> появится то имя, которое вы ввели в текстовое поле TextBox формы. Вторая инструкция отобразит диалоговое окно сообщения MessageDialog, что приведет к его появлению на экране. Класс MessageDialog определен в пространстве имен Windows.UI.Popups, поэтому данное пространство и было ранее добавлено в программу.
ПРИМЕЧАНИЕ Под последней строкой введенного кода можно будет заметить зеленую волнистую линию, добавленную Visual Studio 2015. Если навести на нее указатель мыши, Visual Studio выведет следующее предупреждение: «Поскольку этот вызов не ожидается, выполнение текущего метода продолжается до завершения вызова. Попробуйте применить оператор await к результату вызова». По существу, это предупреждение означает, что вы не воспользовались всеми преимуществами асинхронных функциональных возможностей, предоставляемых библиотекой .NET Framework. Это предупреждение можно проигнорировать.
Чтобы снова отобразить форму в окне конструктора, щелкните на вкладке MainPage.xaml, которая находится над окном редактора.
Посмотрите на XAML-описание формы, находящееся на нижней панели, и найдите в нем элемент Button, но ничего в нем не меняйте. Обратите внимание на то, что теперь он включает атрибут по имени Click, который ссылается на метод okClick:
<Button x:Name="ok" ... Click="okClick" />
Щелкните в меню Отладка на пункте Начать отладку. При появлении формы введите в текстовое поле поверх имеющегося текста свое имя и щелкните на кнопке OK. Появится диалоговое окно сообщения, отображающее следующее приветствие (рис. 1.18).
Рис. 1.18
В окне сообщения щелкните на кнопке Закрыть. Вернитесь в Visual Studio 2015 и щелкните в меню Отладка на пункте Остановить отладку.
Выводы
В этой главе было показано, как с помощью Visual Studio 2015 создавать, собирать и запускать приложения. Было создано консольное приложение, отображающее свой вывод в окне консоли, и UWP-приложение с простым графическим интерфейсом (GUI).
Если хотите перейти к работе с главой 2, оставьте среду Visual Studio 2015 в рабочем состоянии и приступайте.
Если сейчас вам нужно выйти из Visual Studio 2015, щелкните в меню Файл на пункте Выход. Если увидите диалоговое окно с предложением сохранить проект, ответьте согласием.
Краткий справочник
| Чтобы | Сделайте следующее |
| Создать с помощью Visual Studio 2015 новое консольное приложение | Откройте диалоговое окно нового проекта: Файл |
| Создать с помощью Visual Studio 2015 новое пустое UWP-приложение | Откройте диалоговое окно нового проекта: Файл |
| Собрать приложение | Щелкните в меню Сборка на пункте Собрать решение |
| Запустить приложение в режиме отладки | Щелкните в меню Отладка на пункте Начать отладку |
| Запустить приложение без отладки | Щелкните в меню Отладка на пункте Запуск без отладки |
