Разработка веб-приложений с помощью ASP.Net Core MVC

Евгений Умрихин

Санкт-Петербург
«БХВ-Петербург»

2023

УДК 004.43
ББК 32.973.26-018.1

У55

Умрихин Е. Д.
У55 Разработка веб-приложений с помощью ASP.Net Core MVC. — СПб.:

БХВ-Петербург, 2023. — 416 с.: ил. — (Профессиональное программирование)

ISBN 978-5-9775-1206-0

Книга посвящена фреймворку ASP.NET Core MVC. Представлены особенности
MVC-архитектуры (Model-View-Controller), основные принципы проектирования
веб-приложений и организации корректной работы с различными типами веб-
запросов. Показано, как взаимодействовать с базами данных посредством попу-
лярных ORM (объектно-реляционное отображение). В книге рассматриваются
методы определения пользовательского интерфейса с помощью среды Razor и от-
крытых клиентских библиотек, описаны способы построения Web API и исполь-
зование его в клиентских приложениях. Подробно описаны различные варианты
публикации приложений. Электронный архив на сайте издательства содержит
результаты выполнения всех рассмотренных в книге проектов.

Для веб-программистов

УДК 004.43
ББК 32.973.26-018.1

Группа подготовки издания:

Руководитель проекта Павел Шалин
Зав. редакцией Людмила Гауль
Компьютерная верстка Ольги Сергиенко
Дизайн серии Марины Дамбиевой
Оформление обложки Зои Канторович

Подписано в печать 02.12.22.
Формат 70×1001/16. Печать офсетная. Усл. печ. л. 33,54.

Тираж 1000 экз. Заказ №
"БХВ-Петербург", 191036, Санкт-Петербург, Гончарная ул., 20.

Отпечатано с готового оригинал-макета
ООО "Принт-М", 142300, М.О., г. Чехов, ул. Полиграфистов, д. 1

ISBN 978-5-9775-1206-0 © Умрихин Е. Д., 2023
© Оформление. ООО «БХВ-Петербург», ООО «БХВ», 2023

Оглавление

Введение ............................................................................................................................ 7

Что вы узнаете из этой книги..........................................................................................................9
Что нужно знать.............................................................................................................................11
Основные термины и понятия ......................................................................................................11
Об авторе ........................................................................................................................................12
Благодарности ................................................................................................................................12

Глава 1. Основные сведения ....................................................................................... 13

Создание первого приложения .....................................................................................................15
Структура проекта и файловая система.......................................................................................18
Точка входа в приложение............................................................................................................20
Конфигурация приложения...........................................................................................................23
Создание сервисов и внедрение зависимостей ...........................................................................27
Компоненты Middleware ...............................................................................................................35
Использование статического контента ........................................................................................42
Добавление инфраструктуры MVC..............................................................................................43

Глава 2. Контроллеры MVC ....................................................................................... 46

Маршрутизация..............................................................................................................................47
Понятие контроллера ....................................................................................................................53
Результаты действий контроллера ...............................................................................................54
Общие сведения о представлениях ..............................................................................................57
Представление списков данных ...................................................................................................59
Создание службы данных .............................................................................................................61
Атрибуты контроллера..................................................................................................................64
Ограничение типов запросов ........................................................................................................65
Контекст контроллера ...................................................................................................................65
Отправка файлов с сервера ...........................................................................................................68

Глава 3. Модели............................................................................................................. 72

Понятие модели .............................................................................................................................72
Передача моделей в представление .............................................................................................75
Использование ViewModel ...........................................................................................................83
Передача моделей в контроллеры ................................................................................................91

4 Оглавление

Создание элементов коллекции данных ......................................................................................97
Аннотации ....................................................................................................................................101
Проверка модели на сервере.......................................................................................................103

Глава 4. Представления Razor.................................................................................. 108

Синтаксис Razor...........................................................................................................................108
Внедрение зависимостей в представление ................................................................................115
Компиляция среды выполнения Razor.......................................................................................117
Передача данных в представление .............................................................................................120
Компоновки..................................................................................................................................122
Файл _ViewStart ...........................................................................................................................126
Файл _ViewImports ......................................................................................................................128
HTML-хелперы ............................................................................................................................129
Тег-хелперы..................................................................................................................................137
Частичные представления...........................................................................................................148
Компоненты представлений .......................................................................................................150
Компоненты Blazor......................................................................................................................152

Глава 5. Использование баз данных........................................................................ 159

Обзор Entity Framework Core ......................................................................................................159
Добавление службы для работы с базой данных ......................................................................168
Применение Dapper .....................................................................................................................175

Глава 6. Введение в веб-API...................................................................................... 180

Определение контроллера веб-API ............................................................................................181
Тестирование методов контроллера веб-API ............................................................................187
Клиент службы веб-API ..............................................................................................................192
Валидация в веб-API....................................................................................................................203
Настройка форматов....................................................................................................................208
Создание чат-бота........................................................................................................................211

Глава 7. Фронтенд-фреймворки............................................................................... 218

Добавление клиентских библиотек ............................................................................................218
Стилизация с помощью Bootstrap ..............................................................................................223
Проверка данных на клиентской стороне..................................................................................226
Знакомство с jQuery UI ...............................................................................................................229

Глава 8. Технология AJAX ........................................................................................ 235

Основы AJAX...............................................................................................................................235
Обработка запросов.....................................................................................................................239
Основные методы AJAX-библиотеки jQuery ............................................................................245
Методы обработки событий .......................................................................................................252
Обработка данных перед отправкой ..........................................................................................257
Использование jQuery Unobtrusive AJAX..................................................................................259
CRUD-операции с использованием AJAX.................................................................................265

Глава 9. Основные сценарии, используемые при построении приложений...... 275

Сессии в ASP.NET Core ..............................................................................................................275
Использование cookie..................................................................................................................280

Оглавление 5

Использование фильтров ............................................................................................................284
Создание защищенных страниц .................................................................................................293
Комбинированный список с автоподстановкой........................................................................306
Динамический поиск по базе данных ........................................................................................312
Раскрывающиеся списки.............................................................................................................314
Реализация фоновых задач..........................................................................................................321
Сортировка данных в таблицах ..................................................................................................326
Группировка табличных данных ................................................................................................332
Постраничное представление в таблицах ..................................................................................338
Изменение данных в таблицах....................................................................................................344
Разработка файлообменника.......................................................................................................355
Создание формы обратной связи ...............................................................................................361
Добавление капчи ........................................................................................................................369
Использование переключателей.................................................................................................375

Глава 10. Публикация и развертывание приложений......................................... 380

Публикация приложений.............................................................................................................381
Развертывание приложения с помощью IIS ..............................................................................386
Запуск приложения в виде службы Windows ............................................................................390
Развертывание приложения в виде фонового сервиса под Linux ............................................393

Заключение................................................................................................................... 399

Приложение 1. Основные элементы HTML .......................................................... 401

Базовые теги.................................................................................................................................401
Форматирование текста ..............................................................................................................402
Элементы навигации ...................................................................................................................404
Встраивание элементов ...............................................................................................................404
Работа с таблицами......................................................................................................................405
Создание форм и кнопок.............................................................................................................405

Приложение 2. Содержимое электронного архива ............................................... 406

Предметный указатель .............................................................................................. 407

6 Оглавление

Введение

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

В настоящее время для разработки веб-приложений и веб-сервисов, работающих
под управлением самых разных операционных систем, применяется множество
технологий и языков программирования. Любое веб-приложение состоит из двух
частей: серверной (бэкенд), работающей на веб-сервере, и клиентской (фронтенд),
работающей в браузере. При этом для создания бэкенда широко применяют такие
фреймворки и языки, как PHP, Node.js, ASP.NET, C#, Java, Python, Ruby и многие
другие, а для реализации фронтенда используют HTML, CSS, JavaScript. Ес-
ли говорить о разработке клиентской части, то программистом, как правило, при-
меняется все из перечисленного и еще какой-нибудь JavaScript-фреймворк, к при-
меру jQuery. В случае с бэкендом дело обстоит сложнее. Перечисленные техноло-
гии имеют свои преимущества и недостатки. Наличие навыков программирования
на языке C# является одним из аргументов в пользу применения их для создания
веб-приложений с помощью фреймворка ASP.NET Core MVC. Рассмотрим эволю-
цию, особенности и преимущества этой платформы.

Самую первую версию технологии Active Server Pages (ASP) компания Microsoft
выпустила в 1996 году. На тот момент не было принято разделять веб-приложения
на клиентскую и серверную части. Многих технологий построения пользователь-
ского интерфейса, таких как CSS, еще не существовало, а некоторые, например
JavaScript, только были выпущены и не получили должного развития. Предпосыл-

8 Введение

кой появления данной технологии стало то, что возникла необходимость генериро-
вать веб-страницы динамически. Для этого было предложено добавлять в HTML-
разметку специальный ASP-тег, внутри которого на сервере выполнялся код, напи-
санный на Visual Basic. Как только сервер получал результат выполнения этого ко-
да, пользователю в браузере отображалась окончательная версия веб-страницы.

Далее, в 2002 году был выпущен фреймворк ASP.NET Web Forms. Он реализует
концепцию ASP, но уже на платформе .NET. Преимуществом данной технологии
является то, что код ASP.NET компилируется, а не интерпретируется. В этом слу-
чае веб-приложение становится более производительным. В нем принципы по-
строения пользовательского интерфейса имели схожие черты с фреймворком
Windows Forms и были основаны на серверных событиях. При этом использовались
те языки, которые поддерживает платформа .NET: VB.NET и C#. Была идея унифи-
цировать разработку. Предполагалось, что один и тот же разработчик сможет зани-
маться работой над различными по своей сути приложениями. При этом все то, что
было специфично для веб, предполагалось скрыть в виде абстракций. Появилось
понятие жизненного цикла страницы. Для того чтобы передавать состояние стра-
ницы между последовательными HTTP-запросами, стали использовать компонент
ViewState. Это серьезным образом утяжеляло страницы. Чуть позже эта технология
получила поддержу асинхронной обработки запросов AJAX, что позволило переда-
вать не все состояние страницы на сервер, а только некоторую ее часть и соответ-
ственно обновлять только фрагмент страницы. Появились такие элементы поль-
зовательского интерфейса, как обновляемая панель. Однако в целом экспертное
сообщество считало, что этот фреймворк имеет существенные недостатки, которые
ограничивают его развитие. В первую очередь — ресурсоемкость ViewState. Кроме
того, сложный жизненный цикл страницы, ограниченный контроль за HTML, про-
блема абстракции HTTP и низкая возможность автоматизации тестирования.
В связи с этим Microsoft была вынуждена сменить парадигму построения веб-
приложений с помощью ASP.NET и ввела шаблон MVC. В 2009 году появился но-
вый (на тот период) фреймворк ASP.NET MVC. В нем был внедрен иной подход
к построению веб-страниц, который давно применялся в других технологиях и бла-
годаря которому удалось решить обозначенные проблемы. При этом приложения
выполняются поверх существующей платформы ASP.NET. Несмотря на то что ре-
шения на базе этой технологии работают только под управлением Windows на сер-
вере IIS, эта платформа развивается и находит свое применение. Практически все
появившиеся функции этого фреймворка были унаследованы в следующем, кото-
рый вышел только в 2016 году.

Новая платформа веб-разработки имеет общее название ASP.NET Core, в рамках
которой имеется поддержка MVC-шаблона. К настоящему времени она стала одной
из наиболее популярных технологий создания современных веб-приложений.
Этот фреймворк, созданный компанией Microsoft, работает на платформе .NET
Core. Необходимостью возникновения альтернативной реализации .NET-фрейм-
ворка стало отсутствие должной гибкости в виде модульности и кросс-платформен-
ности. Основные его особенности, заявленные компанией Microsoft, — это как раз
его кросс-платформенность, столь необходимая в современных реалиях, а также
открытые исходные коды, которые можно найти на https://github.com. Наряду

Введение 9

с этим, создавая платформу .NET Core, компания Microsoft достаточно серьезно
поработала над производительностью. При этом существующие в классической
платформе .NET функции были переписаны с учетом способности работать в раз-
личных операционных системах с максимальной эффективностью. Такой же под-
ход характерен и для фреймворка ASP.NET Core MVC, который частично повторя-
ет функционал своего предшественника ASP.NET MVC. Стоит отметить, что при-
ложения ASP.NET Core MVC поддерживаются следующими операционными
системами: Windows, Linux и macOS. Собственно, для них имеется поддержка .NET
Core. Созданные решения можно развернуть на различных веб-серверах: IIS,
Kestrel, HTTP.sys, nginx, Apache и Docker. Вместе с тем в ASP.NET Core MVC реа-
лизован ряд базовых функций. В первую очередь это архитектурный паттерн MVC
и Razor-представления. Этот функционал повторяет то, что существовало и
у предшественника ASP.NET MVC. В решениях на базе этого шаблона контроллер
отвечает за прием HTTP-сообщений, представление отвечает за генерацию HTML-
страниц на основе модели, которая, в свою очередь, описывает данные приложе-
ния. Вместе с тем в ASP.NET Core MVC имеется возможность построения веб-API.
По сути, это тоже повторяет аналогичную функциональность платформы ASP.NET
MVC. Кроме того, во фреймворке появилось новое средство конфигурации прило-
жения. Теперь можно создавать файлы конфигурации в формате JSON, что харак-
терно для всех приложений .NET Core. В новом фреймворке также имеются раз-
личные механизмы аутентификации приложений. В свою очередь, к абсолютно но-
вым функциям следует отнести инъекцию зависимостей, которая теперь доступна
по умолчанию и интегрирована во все компоненты, имеющиеся в составе ASP.NET
Core MVC. Также в нем имеется возможность расширения через платформу NuGet,
появилась поддержка gRPC и платформы Blazor, благодаря которой, используя C#,
можно разрабатывать клиентскую сторону (пользовательский интерфейс) веб-
приложения.

В настоящее время классическая платформа .NET и платформа .NET Core объеди-
нены. Первая такая платформа появилась в ноябре 2020 года и носила название
.NET 5. Спустя почти год вышла NET 6. Анонсирован ежегодный выпуск новых
версий в ноябре каждого года. Кроме того, начиная с версии .NET Core 2.0 сущест-
вует еще возможность создавать веб-приложения ASP.NET Core, используя Razor
Pages. Это альтернатива паттерну MVC. В некотором смысле эта функциональ-
ность похожа на работу Web Forms (только без использования ViewState). Она
в основном рекомендуется к применению для создания небольших приложений.

Цель данной книги — показать основные приемы разработки веб-приложений на
C# с использованием последней версии ASP.NET Core MVC. Комбинируя пред-
ставленные в ней простые примеры, вы научитесь создавать собственные полно-
ценные веб-приложения и разворачивать их на различных ресурсах в Cети.

Что вы узнаете из этой книги

Глава 1. Основные сведения. В этой главе мы рассмотрим основные инструменты
разработки веб-приложений ASP.NET Core, структуру проектов таких приложений,
напишем самую первую программу, изучим ее основные компоненты и методы их
настройки.

10 Введение

Глава 2. Контроллеры MVC. Данный раздел посвящен контроллерам. Это один из
важнейших элементов MVC-паттерна, отвечающий за интерпретацию действий
пользователя. Здесь также будет рассмотрена подсистема маршрутизации, благода-
ря которой происходят перенаправления HTTP-запросов на контроллер.

Глава 3. Модели. В данной главе мы познакомимся с моделями, являющимися еще
одним компонентом MVC. Изучим способы их определения и проверки достовер-
ности.

Глава 4. Представления Razor. В разделе рассказано, как создавать визуальное
представление данных для пользователя с помощью Razor-страниц — особых эле-
ментов приложения, в которых сочетается HTML-разметка и C#-код. Здесь будут
показаны варианты компоновки представлений, а также методы генерации HTML-
разметки с помощью хелперов и других компонентов.

Глава 5. Использование баз данных. Здесь пойдет речь о методах работы с СУБД
(системами управления базами данных). В частности, будут рассмотрены популяр-
ные современные ORM (Object-Relational Mapping), которые используются в веб-
приложениях для организации доступа к данным для СУБД Microsoft SQL Server.

Глава 6. Введение в веб-API. В разделе представлены методы определения веб-API
и организации через него доступа к данным в клиентских приложениях. Показан
пример создания чат-бота.

Глава 7. Фронтенд-фреймворки. В этой главе будут рассмотрены приемы разработ-
ки клиентской стороны веб-приложений с помощью открытых платформ, традици-
онно использующихся в веб-разработке, применительно к ASP.NET Core MVC.

Глава 8. Технология AJAX. Здесь рассмотрен современный подход к построению
интерактивных пользовательских веб-интерфейсов, заключающийся в «фоновом»
обмене данными браузера с веб-сервером, что позволяет веб-страницам не переза-
гружаться полностью при обновлении данных и благодаря чему веб-приложения
становятся более производительными и удобными.

Глава 9. Основные сценарии, используемые при построении приложений. Данный
раздел представляет собой практическую часть книги. В нем собраны простые ва-
рианты построения визуальных представлений, применяющиеся в большинстве
веб-приложений, а также один из способов создания защищенных страниц.

Глава 10. Публикация и развертывание приложений. В этой главе описывается не-
сколько популярных способов публикации своего созданного приложения на сер-
вере, чтобы начать с ним работать.

Рассмотрение отдельных тем сопровождается несложными примерами, благодаря
которым можно получить основные представления об ASP.NET Core MVC.
Их желательно воспроизводить в реальной среде разработки.

В книге в ряде случаев используются некоторые упрощения. К примеру, по тексту
для сокращения объема описательной части сигнатуры методов могут быть пред-
ставлены в сокращенном виде, без указания входных параметров. Для получения
полных сведений по применению тех или иных методов, в том числе для того, что-

Введение 11

бы отследить их аргументы, следует обращаться к листингам с примерами исполь-
зования этих процедур.

Примеры проектов, приведенных в данной книге, были реализованы и протестиро-
ваны в среде разработки Microsoft Visual Studio Community 2022 для проектов,
нацеленных на .NET 6. С ними можно ознакомиться, обратившись к электронному
архиву (см. приложение 2). Вместе с тем возможны отличия в работе представлен-
ного кода и в описанных методиках для других версий .NET-платформы и инстру-
ментов разработки. Для тестирования приложений на стороне клиента использо-
вался веб-браузер Google Chrome.

Курс, представленный в книге, предназначен для начинающих бэкенд-разработ-
чиков, знающих или только изучающих язык программирования C# и желающих
овладеть основами построения современных веб-приложений, а также для разра-
ботчиков других платформ, интересующихся особенностями разработки интернет-
приложений с использованием технологии ASP.NET Core MVC.

Что нужно знать

Фреймворк ASP.NET Core MVC является комплексной технологией, поэтому для
его освоения необходимо иметь некоторый базовый багаж знаний. В частности,
необходимо иметь некоторые представления об основных синтаксических конст-
рукциях языка C# и архитектуре .NET-платформы в целом (желательно уровня не
ниже среднего). Вам должен быть знаком интерфейс среды разработки Microsoft
Visual Studio, поскольку она является основной IDE (Integrated Development
Environment) для создания приложений с помощью рассматриваемой платформы.

Кроме того, нужно иметь основные понятия о HTML-верстке, CSS и JavaScript.
Также нам потребуются некоторые навыки использования самых простых операто-
ров SQL. Этот язык в ряде случаев используется бэкенд-разработчиками для орга-
низации доступа к базам данных.

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

Основные термины и понятия

Определим несколько основных терминов, чтобы избежать их неправильного тол-
кования.

Термин контроллер употребляется в книге в контексте MVC — архитектурного
шаблона проектирования. Он представляет собой компонент, обрабатывающий
действия пользователя, оповещая модель о необходимости изменений. В свою оче-
редь, модель представляет собой элемент, описывающий данные. При этом она реа-
гирует на команды контроллера, изменяя свое состояние. Кроме того, представле-

12 Введение

ние — это третий компонент MVC, отвечающий за отображение данных модели
пользователю, реагируя на изменения модели. В проекте приложения ASP.NET
Core MVC эти три элемента соответственно также представлены отдельными ком-
понентами.

Маршрутизация — процесс перенаправления HTTP-запроса на метод контроллера
с целью обработки данного запроса.

Хелпер — это вспомогательный класс, который используется для помощи в реали-
зации некоторой функциональности, причем этот функционал не является основ-
ной задачей приложения. В частности, при работе с ASP.NET Core MVC различают
HTML-хелперы и тег-хелперы. Они используются для генерации HTML-разметки.

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

Компоновки — это средство определения единообразных визуальных представле-
ний в пределах одного раздела сайта. Используя их, можно создать одинаковый для
всех страниц макет разметки в одном шаблоне. Этот шаблон может содержать сце-
нарии, разметку, стилизацию и другие элементы, являющиеся общими для всех
страниц, создаваемых из компоновки. Их еще называют мастер-страницами.

Об авторе

Инженер-программист с многолетним опытом работы в крупной региональной
страховой компании и некоторым опытом преподавательской работы в вузе. Автор
книг по мобильной разработке Android- и iOS-приложений на C#. Занимается соз-
данием и внедрением распределенных IT-решений с использованием веб-сервисов
и мобильных платформ в области медицинского страхования. Имеет ряд авторских
свидетельств об официальной регистрации программ для ЭВМ и ученую степень
кандидата технических наук.

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

Спасибо моей семье за их терпение и поддержку во время работы над книгой.

Выражаю признательность моему работодателю, благодаря которому я получил
опыт разработки веб-приложений с помощью ASP.NET Core MVC, которым де-
люсь с вами.

Особую благодарность приношу всем сотрудникам издательства «БХВ-Петербург»,
которые принимали участие в создании книги.

ГЛАВА 1

Основные сведения

Веб-приложения являются одним из вариантов клиент-серверных приложений,
поэтому следует в общих чертах представлять принципы их работы. Веб-сайты ра-
ботают с двумя группами устройств. Первая группа обеспечивает чтение и отобра-
жение всей запрашиваемой пользователем информации, хранящейся в виде HTML-,
CSS-файлов (для создания макета страницы) и JavaScript-файлов (для динамическо-
го изменения внешнего вида страницы). Такие устройства принято называть кли-
ентами. Вторая группа представляет собой серверы. Они обеспечивают хранение
этой информации и, задействовав определенное программное обеспечение, выдают
эту информацию пользователю по локальной компьютерной сети либо через Ин-
тернет.

Взаимодействие между клиентом и сервером осуществляется посредством переда-
чи информационных пакетов. Те пакеты, которые исходят от клиента, называются
запросами (англ. request). Они содержат спецификацию команды, которую должен
выполнить сервер, а также некоторую информацию для исполнения этой команды.
Сервер обрабатывает эту команду и возвращает результат ее выполнения в виде
ответа (англ. response), а также связанную с ним дополнительную информацию.
Например, клиент хочет загрузить определенную страницу, находящуюся на серве-
ре. Для этого он подает соответствующий запрос. Сервер обрабатывает этот запрос,
находит соответствующую ему HTML-страницу и оправляет ее в виде ответа, кото-
рый будет прочитан на стороне клиента и выведен на экран браузера. Для обмена
данными используется HTTP (HyperText Transfer Protocol — протокол передачи
гипертекста) — протокол прикладного уровня передачи данных.

HTTP-запрос имеет заголовки в виде «Имя: Значение», где хранится дополнитель-
ная информация, связанная с клиентом. В частности, Host (адрес, по которому бу-
дет отправлен пакет), User-Agent (тип используемого браузера), Accept (формат
принимаемых файлов в качестве ответа) и пр. Кроме того, задается спецификация
производимой на сервере операции. При этом указывается метод, конкретный путь,
определяющий, куда на сервер передается запрос пользователя, и протокол, по ко-
торому будет передан запрос. Спецификация HTTP определяет множество методов
запросов. Среди них наиболее распространенные:

14 Глава 1

GET — используются для загрузки HTML-содержимого указанного веб-ресурса;

HEAD — запрашивает ресурс так же, как и метод GET, но не содержит в себе тела
ответа;

POST — используется для отправки данных пользователя на определенный ре-
сурс;

PUT — применяется для замены всех текущих представлений ресурса данными
запроса;

DELETE — используется для удаления указанного ресурса.

В контексте ответа сервер отправляет специальный статус-код, имеющий опреде-
ленную смысловую нагрузку. Данные коды условно можно разделить на пять кате-
горий:

1xx — информационные коды. Отображают текущую работу сервера. К приме-
ру, 102 — длительная работа сервера;

2xx — успешное выполнение запроса. Отображают результаты обработки запро-
са пользователя и связанную с этим дополнительную информацию. Например,
200 — обработка завершена успешно, 204 — запрашиваемое содержимое не об-
наружено;

3xx — перенаправление запроса на другой ресурс. В этом случае для успешного
выполнения запроса требуется перейти по другому адресу;

4xx — указывают на ошибку со стороны клиента. К примеру, 404 означает, что
ресурс не найден;

5xx — указывают на ошибку со стороны сервера. Как правило, это связано
с ошибками, допущенными бэкенд-разработчиками.

Для того чтобы просматривать состояние пакетов, существует множество инстру-
ментов. Можно непосредственно воспользоваться любым браузером, к примеру
Google Chrome, вызвав инструменты отладки клавишей <F12>, либо его расши-
рением Advanced REST Client. Кроме того, существуют специализированные
программы, например Fiddler, который можно скачать по адресу https://www.
telerik.com/download/fiddler, или Postman. Последний можно загрузить здесь:
https://www.postman.com/downloads. Эти инструменты часто используются веб-
разработчиками для инспектирования трафика.

Получив некоторые представления о работе веб-сайтов, переходим к созданию пер-
вого приложения с помощью ASP.NET Core MVC. Рассмотрим, какие для этого
имеются инструменты. Традиционной IDE для создания приложений ASP.NET на
C# является Visual Studio. В настоящее время существуют различные редакции
этой среды для операционных систем Windows и macOS. В нашем случае наилуч-
шим выбором будет редакция Microsoft Visual Studio Community. Это полнофунк-
циональная, расширяемая и условно-бесплатная интегрированная среда разработки.
В частности, воспользоваться ею могут учебные заведения, индивидуальные разра-
ботчики и небольшие компании, у которых не более пяти разработчиков. Кроме

Основные сведения 15

того, ее можно использовать для создания программного обеспечения с открытым
исходным кодом. Наряду с данной IDE также можно использовать Visual Studio
Code. Это «облегченный» редактор исходного кода, разработанный Microsoft для
Windows, Linux и macOS. Однако многие его возможности недоступны через
графический интерфейс и зачастую используются через палитру команд, что не-
сколько неудобно.

Создание первого приложения

Установщик актуальной версии Visual Studio Community можно загрузить со стра-
ницы https://visualstudio.microsoft.com/ru/downloads. Скачаем версию для Win-
dows и запустим установщик. После того как он скачает все обновления и устано-
вит необходимые компоненты, в появившемся окне, в разделе рабочих нагрузок,
отметим ряд нужных нам опций. Поскольку мы собираемся работать с ASP.NET
Core, то в программе для установки следует выбрать пункт ASP.NET и разработка
веб-приложений.

ПРИМЕЧАНИЕ
В предыдущих версиях Visual Studio для работы с проектами ASP.NET Core требова-
лось еще указать пункт Кросс-платформенная разработка .NET Core, поэтому если
существует необходимость использовать старые версии IDE, то этот пункт нужно вы-
брать.

Нажав кнопку Установить в окне установщика, выполним инсталляцию среды
разработки на свой компьютер. Этот процесс может занять длительное время,
поскольку выбранные компоненты ресурсоемкие.

Завершив установку, можно создавать наше первое решение и проект. Для этого
запустим Visual Studio и в появившемся окне начнем работу с варианта Создание
проекта, перейдя к выбору шаблона. На следующей странице находим и отмечаем
Пустой ASP.NET Core (рис. 1.1). Он обеспечивает построение приложения с ми-
нимальной функциональностью и применяется для создания приложений с нуля.
Мы будем производить основную работу в рамках данной книги, используя именно
этот шаблон. Он имеет минимальное количество зависимостей и минимальную
смысловую нагрузку.

Наряду с выбранным вариантом для проектов ASP.NET Core доступны также неко-
торые другие шаблоны, часто используемые при создании веб-приложений:

Веб-API ASP.NET Core — шаблон проекта веб-приложения, в котором приме-
няется архитектура REST для создания веб-службы;

Веб-приложение ASP.NET Core — это шаблон проекта, который для обработки
запросов применяет Razor Pages;

Веб-приложение ASP.NET Core (модель-представление-контроллер) —
шаблон проекта, который реализует архитектурный паттерн MVC;

ASP.NET Core с Angular — это шаблон проекта, используемый для работы
с фреймворком Angular;

16 Глава 1

Рис. 1.1. Выбор шаблона проекта

ASP.NET Core с React.js — шаблон проекта, который предназначен специально
для работы с React.js;
ASP.NET Core с React.js и Redux — шаблон проекта, в котором применяются
React.js и Redux.
Нажав кнопку Далее, переходим к следующему шагу. Внесем какое-нибудь имя
проекта, к примеру HelloWorld, и укажем для него расположение на жестком диске
(рис. 1.2).
Снова нажмем кнопку Далее и в следующем окне укажем дополнительные
настройки проекта. К ним, в частности, относится целевая платформа. Если исполь-
зуется Visual Studio 2022, то система по умолчанию предлагает вариант .NET 6.0.
На момент написания книги это текущая версия .NET-платформы. Оставим этот
параметр по умолчанию. Кроме того, там имеется флаг Настроить для HTTPS.
В случае, когда этот флаг установлен, при запуске проекта на выполнение во время
тестирования и отладки приложения будет использоваться протокол HTTPS по
умолчанию. Не будем менять этот параметр. Впоследствии через окно свойств про-
екта эту настройку можно отменить или, наоборот, снова выбрать. В окне дополни-
тельных настроек также можно активировать поддержку Docker и выбрать для это-
го операционную систему. Оставим эту настройку по умолчанию и нажмем кнопку
Создать.

Основные сведения 17

Рис. 1.2. Настройка нового проекта

После создания проект будет содержать в определенной нами папке все необходи-

мые файлы. Нажмите <F5> (отладка), <Ctrl>+<F5> (запуск без отладки) на клавиа-

туре или нажмите кнопку на панели инструментов Стандартная

Visual Studio, чтобы запустить приложение в браузере. При запуске мы можем уви-

деть окно, в котором потребуется подтвердить доверие для сертификата SSL. Про-

изведите подтверждение и установку сертификата. Обратите внимание, что на дан-

ный момент наше простое приложение может делать только одно — отображать

текст Hello World! в окне браузера. Для его работы запускается Kestrel — кросс-

платформенный веб-сервер для ASP.NET Core. При его запуске должна появиться

консоль командной строки Windows. Тестировать приложение можно и с помощью

IIS Express. Это специальная, предназначенная для отладки, «облегченная» версия

веб-сервера IIS, которой комплектуется среда разработки. Для этого нужно в рас-

крывающемся списке рядом с кнопкой запуска приложения выбрать вариант

IIS Express (рис. 1.3). Если щелкнуть правой кнопкой мыши значок IIS Express,

появившийся на панели задач Windows после запуска приложения на отладку, то

можно увидеть, что он размещает наше приложение.

18 Глава 1

Рис. 1.3. Выбор вариантов запуска приложения для тестирования

Структура проекта и файловая система

Обратимся к Обозревателю решений (рис. 1.4), чтобы изучить, из каких элементов
состоит проект. В структуру созданного проекта входят следующие компоненты:

Connected Services — содержит все сервисы, подключенные из облачного хра-
нилища Azure;

Рис. 1.4. Обозреватель решений

Основные сведения 19

Properties — узел, содержащий ряд параметров проекта. Так, в файле
launchSettings.json описаны настройки конфигурации сервера, использующегося
для запуска проекта, например адреса и порты, по которым будет запускаться
приложение на сервере IIS Express и Kestrel;

Зависимости — содержит добавленные в проект ссылки на пакеты NuGet и до-
полнительные библиотеки;

appsettings.json — файл, в котором определена конфигурация приложения
в JSON-формате;

Program.cs — главный файл приложения, представляющий собой точку входа,
имеющий в своей структуре инструкции верхнего уровня, с которых и начина-
ется выполнение программы. С помощью этих операторов осуществляется
конфигурация и запуск веб-приложения. Кроме того, в нем определяется логика
обработки входящих на сервер HTTP-запросов.

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

В проектах .NET Core имеется прямая взаимосвязь между файлами в папке реше-
ния и тем, что отображается в Обозревателе решений в Visual Studio. Чтобы в этом
убедиться, добавим, к примеру, текстовый файл в файловую структуру в Провод-
нике Windows. При этом можно увидеть, что он отображается в Обозревателе ре-
шений в режиме реального времени.

Рассмотрим небольшой пример. Для чего последовательно выполним следующее:

1. Вызовите контекстное меню для узла решения HelloWorld в Обозревателе реше-
ний и выберите Открыть папку в Проводнике. При этом Проводник отобразит
нам каталог с файлом решения HelloWorld.sln. Там же окажется одноименная
папка проекта. Откройте ее двойным щелчком левой кнопки мыши.

2. В окне Проводника создайте новый текстовый документ с именем MyDoc.txt.

3. Вернитесь в Visual Studio и обратитесь к Обозревателю решений. Там должен
отобразиться созданный файл.

4. Дважды щелкните документ MyDoc.txt в Обозревателе решений, чтобы открыть
его в среде разработки.

5. Напишите в нем текст Hello World из Visual Studio и сохраните его.

6. Теперь вернитесь в Проводник и откройте этот файл. Он должен содержать до-
бавленный текст.

7. Измените текст на Здравствуй, Мир с помощью стандартного текстового редак-
тора Блокнот и сохраните файл.

8. Вернитесь в среду разработки. Измененный текст теперь должен отображаться
в Visual Studio.

9. Закройте текстовый документ в Visual Studio и в Блокноте. Вызовите для этого
файла контекстное меню в Обозревателе решений в Visual Studio и выберите
Удалить, чтобы удалить документ навсегда.

20 Глава 1

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

Рассмотрим еще один важный файл, входящий в созданное решение. Это файл про-
екта HelloWorld.csproj. Этот файл можно легко изменять в среде разработки, добав-
ляя в него различные зависимости, не используя для этих целей диспетчер пакетов
NuGet. Чтобы открыть файл *.csproj, просто щелкните правой кнопкой мыши узел
проекта в Обозревателе решений и выберите Изменить файл проекта. Добавьте
в открывшийся документ перед закрывающим тегом </Project> следующее содер-
жимое:

<ItemGroup>
<PackageReference Include="Newtonsoft.Json" Version="13.0.1" />

</ItemGroup>

Сохраните файл. Затем раскройте узел Пакеты внутри папки Зависимости Обо-
зревателя решений и убедитесь, что в проект была добавлена Newtonsoft.Json —
библиотека для работы с JSON. По мере работы над проектом и добавления в него
различного функционала потребуется добавлять различные пакеты NuGet.

Точка входа в приложение

Запуск приложений ASP.NET Core, начиная с версии .NET 6, производится с опе-
раторов, определенных в файле Program.cs. Их обозначают специальным терми-
ном — инструкции верхнего уровня. Это входная точка в приложение. Обратимся
(используя Обозреватель решений) к файлу Program.cs и подробно рассмотрим
представленный в нем код (рис. 1.5).

Рис. 1.5. Содержимое файла Program.cs в редакторе кода

Как видно, файл не содержит одноименный класс и метод Main, с которого тради-
ционно производится запуск приложений (к примеру, в более ранних версиях
фреймворка). В первой строке файла, используя класс WebApplication из про-
странства имен Microsoft.AspNetCore.Builder, вызывается его статический метод

ГЛАВА 2
Контроллеры MVC

MVC — это популярный шаблон проектирования, в котором используется схема
разделения данных и управляющей логики на три отдельных компонента:
M (означает модель), V (означает представление или вид) и C (означает контрол-
лер). Схематично взаимодействие данных компонентов показано на рис. 2.1.

Рис. 2.1. Взаимодействие компонентов MVC-паттерна

Контроллер отвечает за обработку любых HTTP-запросов, поступающих в прило-
жение. Это происходит, когда пользователь запрашивает URL-адрес приложения
(к примеру, /about). Назначение контроллера состоит в том, чтобы собрать и объ-
единить все необходимые данные, обработать и упаковать их в объекты модели,
которые являются хранилищем данных для представлений.

Контроллеры MVC 47

Модель отправляется в представление, которое использует данные при формирова-
нии HTML-верстки. Сгенерированный HTML-код затем отправляется обратно
в клиентский браузер в виде ответа HTML.

Шаблон MVC разделяет задачи между моделью, представлением и контроллером.
Единственная ответственность контроллера — обработать запрос и построить мо-
дель. Модель отвечает за передачу данных и логики между контроллером и пред-
ставлением, а представление отвечает за преобразование этих данных в HTML.

Чтобы такой подход работал, должен существовать способ отправки HTTP-за-
просов на нужный контроллер. Это достигается с помощью маршрутизации.

Маршрутизация

В приложениях ASP.NET Core MVC компоненты промежуточного слоя должны
иметь возможность маршрутизировать входящие HTTP-запросы к контроллеру.

ПРИМЕЧАНИЕ
Запросы, которые поступают к веб-приложению, могут обрабатываться не только кон-
троллерами, но и, например, компонентами промежуточного программного обеспече-
ния в конвейере обработки запросов (см. гл. 1).

Прежде всего, под маршрутом будем понимать указанный в строке браузера спе-
циальный системный «путь» (или, как его часто называют, адрес), по которому бу-
дет отправлен от клиента (браузера) на сторону сервера запрос. Если на сервере
имеется логика для обработки поступившего по этому пути запроса, то он будет
обработан. В структуру маршрута (рис. 2.2) входят следующие элементы: тип про-
токола (HTTP или его защищенный вариант HTTPS), доменное имя, по которому
можно обратиться к приложению через адресную строку браузера, а также разделы
и подразделы.

Рис. 2.2. Составные части маршрута

В свою очередь, программный механизм, согласно которому сервер будет произво-
дить сопоставление всех входящих запросов с определенными в системе маршру-
тами, которые указывают, какой контроллер и метод должны обработать данный
запрос, называется маршрутизацией URL-адресов. Различают маршрутизацию на
основе соглашений и маршрутизацию по атрибутам. В случае необходимости эти
подходы можно комбинировать. Как правило, вариант маршрутизации по атрибу-
там используют, когда возникают сложности с применением маршрутизации на
основе соглашений.

Один из вариантов определить конфигурацию маршрутизации — добавить мар-
шрутизацию на основе соглашений в конвейер обработки запросов в файл

48 Глава 2

Program.cs. Такого типа маршрутизацию нередко называют маршрутизацией на
основе конечных точек. С помощью такого типа конфигурации маршрутов для
ASP.NET указывается, как найти имя контроллера, имя действия и, возможно, зна-
чения параметров в URL-адресе. Контроллер представляет собой класс C#, а дейст-
вие — это открытый метод в классе контроллера. Его параметром может быть
любое значение, представленное в виде строки. Добавить конфигурацию можно
с помощью выражения:

app.MapControllerRoute(name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");

Встроенный метод MapControllerRoute задает произвольный маршрут к контролле-
ру. В данном случае одна из его наиболее распространенных перегруженных вер-
сий принимает следующие параметры: название маршрута и шаблон маршрута.
ASP.NET просматривает заданный шаблон маршрута, чтобы определить, как раз-
бить URL-адрес. В случае, когда в URL-адресе содержится /Home, он будет искать
класс HomeController по соглашению, поскольку имя начинается с Home, а все клас-
сы контроллеров должны заканчиваться постфиксом Controller. Если URL-адрес
содержит /Home/Index, ASP.NET найдет общедоступный метод действия с именем
Index внутри класса HomeController. Если URL-адрес содержит /Home/Index/1,
ASP.NET будет искать общедоступный метод действия под названием Index
с входным параметром id внутри класса HomeController. Параметр id не является
обязательным, если в шаблоне после его имени имеется вопросительный знак. В то
же время имена контроллера и действия также можно не указывать, поскольку они
имеют значения по умолчанию в шаблоне маршрута. Таким образом, если мар-
шрут, по которому пришел запрос, не содержит некоторых необходимых парамет-
ров, то с помощью подобной настройки на сервере в маршрут автоматически под-
ставятся заданные разработчиком значения сегментов вместо отсутствующих.
В ASP.NET имеется возможность использовать несколько маршрутов. Приложение
обращается к ним в порядке добавления.

Используя перегруженную версию метода MapControllerRoute, мы можем опреде-
лить ограничения для маршрутов. Они осуществляют фильтрацию поступающих на
сервер запросов в соответствии с заданными настройками, даже если сегментарная
структура маршрута совпадает с прописанным шаблоном на сервере. К примеру,
ограничение может быть указано таким образом:

app.MapControllerRoute(name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}", null, new

{

action = "Index"

});

В этом случае нам недостаточно, чтобы строка соответствовала указанному шабло-
ну. Нужно, чтобы значение имени действия было равным Index. Ограничения мож-
но определять, используя регулярные выражения. Для того чтобы указать, что не-
обязательный параметр id должен состоять из двух чисел, можно определить такое
ограничение:

Контроллеры MVC 49

app.MapControllerRoute(name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}", null, new
{

id = @"\d{2}"
});

Еще один способ задать маршрутизацию — использовать маршрутизацию атрибу-
тов. В этом случае потребуется назначить атрибуты классу контроллера и его мето-
дам действий. Метаданные в этих атрибутах сообщают ASP.NET, когда вызывать
конкретный контроллер и действие:

[Route("[controller]/[action]")]
public class HomeController
{

public string Index()
{

return "Привет из контроллера";
}
}

Для маршрутизации атрибутов потребуется подключить использование простран-
ства имен Microsoft.AspNetCore.Mvc.

Рассмотрим более подробно оба типа маршрутизации. Для этого создадим проект
HelloRouting на базе шаблона Пустой ASP.NET Core, нацеленный на последнюю
версию .NET с поддержкой HTTPS и без поддержки Docker. В предыдущей главе
(см. разд. «Добавление инфраструктуры MVC» гл. 1) мы уже создавали класс кон-
троллера с именем HomeController. В нем мы реализовали маршрутизацию с помо-
щью метода UseMvcWithDefaultRoute, который имеет встроенную поддержку мар-
шрутизации по умолчанию для HomeController. Однако при создании приложения
с несколькими контроллерами нужно использовать маршрутизацию на основе со-
глашений или маршрутизацию по атрибутам, чтобы ASP.NET знал, как обрабаты-
вать входящие HTTP-запросы. Давайте явно реализуем маршрут по умолчанию.
Прежде всего, создайте папку Controllers, а внутри нее класс HomeController, со-
держащий единственный метод:

public class HomeController
{

public string Index(string? id)
{

if (string.IsNullOrEmpty(id))
{

return $"Привет из контроллера.";
}
else
{

return $"Привет! Это {id}.";
}
}
}

ГЛАВА 3

Модели

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

Понятие модели

Модель — это связанная с веб-приложением сущность, которая описывает опреде-
ленные данные. Все модели представляют собой POCO-классы или обычные
C#-классы. К примеру, для веб-страницы, на которой представлены различные
автомобили, класс модели будет соответствовать модели автомобиля и содержать
соответствующие поля: название автопроизводителя, наименование модели, объем
двигателя и пр. Контроллеры, в свою очередь, являющиеся обработчиками запро-
сов по определенным маршрутам, подгружают требуемые данные, представленные
в виде моделей, а затем передают связанную с ними информацию в HTML-пред-
ставления. Таким образом, как только пользователь отправляет на сторону сервера
HTTP-запрос, контроллер обрабатывает его, в случае необходимости подгружает
связанные с ним модели (например, модели автомобилей) и отправляет их в пред-
ставление, отображая их пользователю.
Различают несколько разновидностей моделей. Прежде всего это анемичные (или
«тонкие») модели — классы или сущности, обладающие только набором характер-
ных для них полей (состояний) и не содержащие больше ничего другого. Они наи-
более часто используются при построении приложений с помощью ASP.NET Core.
Рассмотрим практический пример анемичной модели. Создайте проект приложения
AutoModel на базе пустого шаблона ASP.NET Core, нацеленный на последнюю
версию .NET с поддержкой HTTPS и без поддержки Docker.
Для того чтобы можно было использовать архитектуру MVC, определите в файле
Program.cs инструкции верхнего уровня согласно листингу 2.1. Добавьте в проект

Модели 73

две папки: Controllers для хранения классов контроллеров и Models для хранения
классов моделей. Щелкните правой кнопкой мыши по Models и выполните Доба-
вить → Класс. Назовите его Auto и поместите в добавленный файл содержимое,
представленное в листинге 3.1.

Листинг 3.1. Реализация класса Auto

public class Auto
{

//Наименование автопроизводителя
public string Brand { get; set; } = string.Empty;
//Название модели
public string ModelAuto { get; set; } = string.Empty;
//Объем двигателя
public int EngineCapacity { get; set; }
}

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

Для того чтобы проиллюстрировать, как именно должна производиться работа
с моделью в рамках метода контроллера, добавим в папку Controllers класс
контроллера по умолчанию. Вызовите для этого каталога в Обозревателе решений
контекстное меню и выполните Добавить → Класс. Назовите новый файл
HomeController.cs и определите для него метод Index (листинг 3.2).

Листинг 3.2. Класс HomeController проекта AutoModel

public class HomeController: Controller
{

public string Index()
{

Auto auto = new Auto()
{

Brand = "Audi",
ModelAuto = "A6",
EngineCapacity = 2393
};
string result = $"Наименование: {auto.Brand}, Модель: {auto.ModelAuto},

Объем двигателя, куб. см: {auto.EngineCapacity}";
return result;
}
}

Подключите пространства имен Microsoft.AspNetCore.Mvc и AutoModel.Models.
В рамках метода Index создается экземпляр модели Auto. Он содержит произвольно

74 Глава 3

заданные значения полей. В строковом представлении результата действия выво-
дится информация, связанная с созданным экземпляром модели Auto, которая воз-
вращается в браузер. Запустив приложение на отладку, мы должны увидеть строку:
Наименование: Audi, Модель: A6, Объем двигателя, куб. см: 2393.
В противовес анемичным моделям существуют так называемые полные (или «бога-
тые») модели. Они помимо характерного для них набора состояний могут содер-
жать еще и различные методы, конструкторы и другие члены класса. Использовать
подобные модели допустимо. Однако подобный подход нежелателен, поскольку
приводит к «засорению» сущности, появлению множества программных элементов,
требующих внимания со стороны разработчика.

Доработаем созданный проект. Добавим в папку Models еще один класс —
ThickAuto. Воспользуемся для этого контекстным меню для каталога Models и вы-
полним Добавить → Класс. Назовем файл ThickAuto.cs и определим в нем реали-
зацию одноименного класса согласно листингу 3.3.

Листинг 3.3. Класс ThickAuto

public class ThickAuto
{

public string Brand { get; set; } = string.Empty;
public string ModelAuto { get; set; } = string.Empty;
public int EngineCapacity { get; set; }
public ThickAuto(string brand, string modelAuto, int engineCapacity)
{

Brand = brand;
ModelAuto = modelAuto;
EngineCapacity = engineCapacity;
}
public string GetInfo()
{
return $"Наименование: {Brand}, Модель: {ModelAuto}, Объем двигателя,

куб. см: {EngineCapacity}";
}
}

Данная модель является полной. Она помимо свойств содержит конструктор и
метод GetInfo, который в виде строкового представления возвращает информацию
о модели (состояние ее полей).

Рассмотрим, как можно с ней работать. Обратимся к контроллеру HomeController
и добавим еще одно действие — Hello:

public string Hello()
{

ThickAuto audio = new ThickAuto("Audi", "A6", 2393);
return audio.GetInfo();
}

Модели 75

Данный открытый метод контроллера создает и возвращает строковое представле-
ние. Это осуществляется всего в две строки. Несмотря на такую простую реализа-
цию, в большинстве случаев использование анемичных моделей предпочтительнее,
т. к. они обеспечивают большее удобство при работе, поскольку не содержат
дополнительной информации. Запустив приложение и перейдя по URL-адресу
/Home/Hello, мы можем видеть тот же самый результат.

Передача моделей в представление

Существуют три разновидности передачи моделей в представление. Прежде всего,
это передача одиночной модели. Кроме того, передача гомогенной коллекции моде-
лей. Наконец, это передача в представление групп моделей разных типов, инкапсу-
лированных в одном классе.
Рассмотрим это более детально на примере. Создадим проект SiteMovies, представ-
ляющий собой приложение для отображения видеофайлов, выбрав шаблон Пустой
ASP.NET Core. Нацелим проект на последнюю версию .NET. Включим поддержку
HTTPS и откажемся от поддержки Docker. Определим в файле Program.cs реализа-
цию инструкций верхнего уровня в соответствии с листингом 2.1. Наконец, созда-
дим каталог Models и добавим в него класс Movie (листинг 3.4).

Листинг 3.4. Класс Movie проекта SiteMovies

public class Movie
{

//Заголовок
public string Title { get; set; } = string.Empty;
//Жанр
public string Genre { get; set; } = string.Empty;
//Длительность эпизода
public int Duration { get; set; }
}

После чего создадим каталог Views, а в нем подкаталог Home. Определим в нем
представление Index.cshtml (листинг 3.5).

Листинг 3.5. Представление Index.cshtml проекта SiteMovies

@using SiteMovies.Models
@model Movie
<html>
<head>

<title>@Model?.Title</title>
</head>
<body>

<h2>@Model?.Title</h2>

ГЛАВА 9

Основные сценарии, используемые
при построении приложений

В предыдущих главах мы уже достаточно подробно изучили основы создания при-
ложений с помощью фреймворка ASP.NET Core MVC. Осталось рассмотреть
несколько практик, которые часто применяют при построении реальных веб-
приложений. В частности, разберем, как организовать авторизацию доступа к за-
щищенным страницам сайта с помощью сессий и какие компоненты для этого
нужно использовать. Другим важным аспектом создания приложений является по-
строение пользовательского интерфейса. Посмотрим, как он строится в контексте
выполнения базовых сценариев работы с данными. Разберем устройство табличных
форм, создадим форму обратной связи, рассмотрим, как организовать поиск по базе
данных и многое другое.

Сессии в ASP.NET Core

Обычно под сессией (или сеансом) понимается последовательность запросов, сде-
ланных конечным клиентом (веб-браузером, приложением и др.) во время посеще-
ния определенного хоста в конкретный период времени. Она может быть использо-
вана для хранения временных данных, которые могут быть затребованы во время
работы пользователя с приложением и которые не нужно хранить постоянно.

Сессия создается при первом запросе к серверу. Ее состояние хранится на сервере.
При этом создается словарь, или хеш-таблица. Она хранится в кеше и существует
в течение некоторого отрезка времени, в пределах которого приложение может
определять все запросы от одного клиента. На стороне клиента в файлах cookie
хранится идентификатор сессии, который отправляется на сервер с каждым запро-
сом. Он используется сервером для извлечения требуемых данных из сеанса. Фай-
лы cookie удаляются после завершения сеанса. Если клиент обращается к хосту
с использованием неактивного идентификатора сессии, то создается новый сеанс.

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

276 Глава 9

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

В качестве примера работы с сессиями создадим проект SessionState на основе пус-
того шаблона ASP.NET Core, нацеленный на последнюю версию .NET с поддерж-
кой HTTPS и без поддержки Docker. Добавьте в проект три папки: Controllers для
хранения классов контроллеров, Models для классов моделей и Views для представ-
лений. В свою очередь, в каталоге Views создайте подкаталог Home, предназначен-
ный для размещения файлов представлений, которые будут задействованы в мето-
дах контроллера Home для визуализации данных. Добавим в папку Controllers класс
контроллера HomeController по умолчанию (листинг 9.1).

Листинг 9.1. Класс HomeController проекта SessionState

public class HomeController : Controller
{

const string SessionName = "_Name";
const string SessionAge = "_Age";
const string SessionPerson = "_Person";
public IActionResult Index()
{

HttpContext.Session.SetString(SessionName, "Stan");
HttpContext.Session.SetInt32(SessionAge, 50);
var person = new Person() { Name = "Stan", Age = 50 };
HttpContext.Session.SetString(SessionPerson,

JsonSerializer.Serialize<Person>(person));
return View();
}
public IActionResult About()
{
ViewBag.Name = HttpContext.Session.GetString(SessionName);
ViewBag.Age = HttpContext.Session.GetInt32(SessionAge);
ViewData["Message"] = "Обо мне";
return View();
}
public IActionResult Person()
{
var value = HttpContext.Session.GetString(SessionPerson);
var person = value == null ? default(Person) :

JsonSerializer.Deserialize<Person>(value);
ViewData["Message"] = "Субъект";
return View(person);
}
}

Основные сценарии, используемые при построении приложений 277

Подключите к классу следующие пространства имен:

using Microsoft.AspNetCore.Mvc;
using System.Text.Json;
using SessionState.Models;

Чтобы использовать сеансы, нужно выполнить конфигурацию их параметров
в файле Program.cs. Все сессии работают поверх объекта IDistributedCache,
и ASP.NET Core предоставляет встроенную реализацию IDistributedCache, кото-
рую можно применять. Для этого модифицируем Program.cs следующим образом:

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDistributedMemoryCache();
builder.Services.AddSession(options => {

options.IdleTimeout = TimeSpan.FromMinutes(1); //Установка времени сессии
});
builder.Services.AddMvc();
var app = builder.Build();
app.UseSession();
app.MapControllerRoute(name: "default", pattern:

"{controller=Home}/{action=Index}/{id?}");
app.Run();

В инструкциях верхнего уровня производится настройка служб. Самый первый
шаг, который нам нужно сделать, — это добавить службу сеанса в коллекцию сер-
висов, задействованных приложением. Для этого нужно вызвать метод AddSession.
В качестве опций для службы сеанса мы указали тайм-аут сеанса (1 мин).
Для встраивания механизма работы с сеансами в конвейер обработки запросов
используем метод app.UseSession().

Если обратиться к переменной сеанса до вызова метода UseSession, то будет сге-
нерировано исключение типа InvalidOperationException. Использование сессии
у объекта HttpContext (см. листинг 9.1) возможно только после его вызова.

Действия контроллера (в соответствии их с именами) покажут три представления.
В методе, отображающем Index.cshtml, происходит установка по ключам
SessionName, SessionAge и SessionPerson произвольных значений, которые пред-
ставляют строку (имя), целое число (возраст) и сложный объект типа Person соот-
ветственно. Определим этот класс в папке Models:

public class Person
{

public string Name { get; set; } = string.Empty;
public int Age { get; set; }
}

Пусть он описывает субъекта (клиента), который характеризуется двумя свойства-
ми: именем и возрастом.

Для управления сессией объект Session контекста запроса имеет ряд свойств и ме-
тодов:

278 Глава 9

Keys — свойство, представляющее список строк, в котором хранятся все доступ-
ные ключи;

Clear() — производит очистку сессии;

Get(string key) — возвращает по ключу key значение, представляющее собой
массив байтов;

GetInt32(string key) — возвращает по ключу key целочисленное значение;

GetString(string key) — возвращает по ключу key строковое значение;

Set(string key, byte[] value) — производит установку по ключу key значения,
представляющего собой массив байтов;

SetInt32(string key, int value) — производит установку по ключу key цело-
численного значения value;

SetString(string key, string value) — производит установку по ключу key
строкового значения value;

Remove(string key) — осуществляет удаление значения по ключу.

Методы, начинающиеся с префикса Get, производят чтение данных из сеанса, а те,
которые начинаются с Set, — сохранение данных в сессии.

В случае работы со сложным объектом его надо сериализовать в строку, а при
получении из сессии — обратно десериализовать. Для этого используем объект
JsonSerializer из пространства имен System.Text.Json.

ПРИМЕЧАНИЕ
Методы библиотеки Newtonsoft.Json также можно применить для работы с JSON.
Однако новый (де)сериализатор JSON — System.Text.Json, появившийся в версии
.NET Core 3, в большинстве случаев работает быстрее.

В методе, отображающем About.cshtml, происходит извлечение данных из сеанса
по ключам SessionName, SessionAge и их последующее сохранение в свойствах объ-
екта ViewBag. Данные, полученные из сессии по ключу SessionPerson в действии,
отображающем Person.cshtml, мы присваиваем объекту класса Person и передаем
этот экземпляр в представление.

Определим в папке \Views\Home представление Index.cshtml:

@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers
<!DOCTYPE html>
<html>

<head>
<title>Сессия</title>

</head>
<body>

<a asp-controller="Home" asp-action="About">Обо мне</a>
<a asp-controller="Home" asp-action="Person">Субъект</a>
</body>
</html>

Заключение

Целью данной книги являлось описание основных приемов работы с фреймворком
ASP.NET Core MVC. Надеюсь, она была достигнута. Мы рассмотрели имеющийся
арсенал средств разработки веб-приложений на C#, работу с проектами, изучили
такие темы, как настройка и конфигурация вашего приложения ASP.NET Core,
конвейер обработки запросов, а также расширили свои представления об MVC-
архитектуре. Изучили понятие модели, представления и контроллера. Рассмотрели
различные компоненты приложений. Также в рамках данного курса был представ-
лен материал по основам работы с EF Core и Dapper. Это наиболее популярные
сейчас ORM-технологии для взаимодействия с базой данных, которые применяют-
ся бэкенд-разработчиками. Помимо веб-сайтов платформа ASP.NET Core предлага-
ет инструменты для разработки сервисов веб-API. В ходе освоения этой темы нами
был разобран прикладной пример реализации и развертывания чат-бота для одного
из популярных голосовых ассистентов. В рамках изучения фронтенд-разработки
мы рассмотрели открытые клиентские библиотеки, которые можно использовать
для стилизации визуальных элементов на веб-страницах, создания динамического
контента и подключения виджетов. Кроме этого, в книге представлена глава, по-
священная технологии AJAX, без использования которой не может обойтись со-
временное веб-приложение. Наконец, мы научились публиковать и разворачивать
свои ASP.NET Core-приложения на сервере IIS и в качестве службы Windows.

Если вы выбрали C# своим основным языком разработки, но пока еще используете
старую платформу .NET Framework, то пришло время переходить на более совре-
менную — .NET Core. Новый фреймворк имеет ряд преимуществ перед своим
предшественником: является кросс-платформенным, открытым, более производи-
тельным, имеет мощную поддержку со стороны IT-сообщества и Microsoft —
крупнейшего производителя программного обеспечения. Вы получаете удобную и
высокопроизводительную среду разработки, которая своевременно обновляется.

Сейчас имеется много сторонних программных инструментов для разработки веб-
приложений ASP.NET Core. Так, ведущие IT-компании, ориентированные на инст-
рументы разработки .NET, предлагают компоненты пользовательского интерфейса,
которые можно использовать в любых сценариях. К примеру, с решениями компа-
нии Telerik можно ознакомиться здесь: https://www.telerik.com/aspnet-core-ui. По-

400 Заключение

добные элементы управления предлагают DevExpress и Infragistics. Однако боль-
шинство компонентов, разработанных инженерами Microsoft и сторонними специа-
листами, можно получить бесплатно через диспетчер NuGet-пакетов. Многие из
них были представлены в книге.

Если вы хотите сосредоточиться исключительно на бэкенд-разработке, а создание
пользовательского интерфейса вызывает у вас сложности, то в настоящее время
существует множество интернет-ресурсов, где можно скачать готовый шаблон
адаптивного сайта на базе Bootstrap. Останется только подключить к нему свои
бэкенд-сервисы, разработанные с помощью ASP.NET Core MVC, и наполнить его
своим содержимым. Немало таких шаблонов представлено здесь: https://
freehtmlthemes.ru.

Для размещения приложений ASP.NET Core имеется ряд сервисов, предлагающих
услуги в области хостинга. Наиболее популярными российскими хостинг-
провайдерами являются REG.RU и 1Gb.ru. Среди зарубежных можно отметить
SmarterASP.NET и Somee.com.

Сочетая полученные знания и имеющиеся в онлайн материалы, можно двигаться
дальше. Лучше всего найти для себя интересную задачу и попытаться ее реализо-
вать. При этом можно использовать официальную документацию на https://docs.
microsoft.com/ru-ru/aspnet/core или же информацию, размещенную различными
сообществами разработчиков, например на https://stackoverflow.com, https://
www.c-sharpcorner.com, https://github.com и других ресурсах.

Следует отметить, что средства разработки постоянно совершенствуются. Регуляр-
но выходят новые версии ASP.NET, а также обновления Visual Studio. Разработчи-
кам постоянно приходится изучать появляющиеся возможности, чтобы модернизи-
ровать свои решения, делать их более эффективными и производительными. Не-
смотря на то что это создает определенные сложности, базовые принципы,
о которых рассказано в книге, всегда остаются неизменными.

Удачи!

ПРИЛОЖЕНИЕ 2

Содержимое
электронного архива

Книгу сопровождает электронный архив, содержащий результаты выполнения всех
рассмотренных в ней проектов (табл. П2.1). Электронный архив выложен на сайте
издательства по адресу https://zip.bhv.ru/9785977512060.zip. Ссылка доступна и со
страницы книги на сайте www.bhv.ru.

Электронный архив также выложен в профиле автора на GitHub, в репозитории
book-asp-net-core, доступном по адресу https://github.com/Umrikhin/book-asp-net-
core.

Таблица П2.1. Описание электронного архива

Папки Описание Главы
\chapter 1 Результаты выполнения примеров, представленных в главе 1 1
\chapter 2 Результаты выполнения примеров, представленных в главе 2 2
\chapter 3 Результаты выполнения примеров, представленных в главе 3 3
\chapter 4 Результаты выполнения примеров, представленных в главе 4 4
\chapter 5 Результаты выполнения примеров, представленных в главе 5 5
\chapter 6 Результаты выполнения примеров, представленных в главе 6 6
\chapter 7 Результаты выполнения примеров, представленных в главе 7 7
\chapter 8 Результаты выполнения примеров, представленных в главе 8 8
\chapter 9 Результаты выполнения примеров, представленных в главе 9 9
\chapter 10 Результаты выполнения примеров, представленных в главе 10 10

Предметный указатель

A N

AJAX-форма 265 nginx, веб-сервер 397
NuGet-пакет
C ◊ Microsoft.Extensions.Hosting.

CAPTCHA 369 WindowsServices 390
CRUD-операция 139, 265 ◊ Newtonsoft.Json 193
◊ Yandex.Alice.Sdk 212
D
O
Dapper 175
Document Object Model 242 Object-Relational Mapping (ORM) 159
DOM См. Document Object Model
P
E
Postman 191
Entity Framework Core 159
R
H
RESTful
HTML-хелпер 129 ◊ веб-сервисы 211
◊ веб-службы См. Сервисы Web API
I
S
Internet Information Services 380
SignalR 153
K
U
Kestrel 380
URL-хелперы 137

V

View Component См. Компонент
представления

408 Предметный указатель

А ◊ привязки 186
◊ тег-хелперов 139, 144
Автозаполнение, источник 311 Аутентификация 294
Автоподстановка 306
Аннотация Б
◊ Compare 102
◊ DataType 102, 106 Библиотека
◊ Display 102, 105 ◊ Bootstrap 218, 222, 223, 302
◊ EmailAddress 363 ◊ bootstrap.min.js 268
◊ MaxLength 102, 105 ◊ jQuery 218, 222, 310, 338
◊ MinLength 102, 105 ◊ jQuery UI 229, 306
◊ Range 102, 105 ◊ jQuery Unobtrusive AJAX 259
◊ RegularExpression 102 ◊ SkiaSharp 371
◊ Required 102, 105
◊ StringLength 295 В
◊ данных 101
Атрибут Валидация
◊ @bind-value 156 ◊ данных в Web API 203
◊ [ApiController] 186 ◊ модели 103
◊ [FormatFilter] 210 ◊ на стороне клиента 226
◊ [FromBody] 186 Веб-сервер 380
◊ [FromForm] 249 Ветвление конвейера запросов 41
◊ [Parameter] 155 Виджет Autocomplete 306
◊ [Produces] 209 ◊ параметры 311
◊ [RequestSizeLimit] 359 Внедрение зависимостей 28, 61, 87, 99, 115
◊ [ServiceFilter] 292 Вспомогательные функции тегов
◊ [TypeFilter] 292
◊ [ValidateAntiForgeryToken] 300 См. Тег-хелпер
◊ asp-action 138, 358, 369
◊ asp-controller 138 Г
◊ asp-for 99, 144, 321
◊ asp-fragment 139 Голосовой ассистент «Алиса» 211
◊ asp-items 144, 320 Графические методы 371
◊ asp-route-[value] 139, 331, 344, 358 Группировка данных в таблицах 332
◊ asp-route-id 139
◊ asp-validation-for 102 Д
◊ asp-validation-summary 102
◊ data-ajax 265 Делегат RequestDelegate 40
◊ data-ajax-begin 265 Демон 395
◊ data-ajax-complete 265 Десериализация 278
◊ data-ajax-failure 265 ◊ объектов JSON 196
◊ data-ajax-method 265 Динамический поиск данных 312
◊ data-ajax-success 265 Директива
◊ HtmlAttributeName 147 ◊ @addTagHelper 99, 138
◊ HtmlTargetElement 146 ◊ @await 152
◊ Route 49, 52 ◊ @code 155
◊ type="password" 305 ◊ @inject 99, 117, 303
◊ контроллера 64 ◊ @model 59, 76, 358
◊ ограничения типов запросов 65 ◊ @section 126
Диспетчер пакетов Libman 218, 295
Добавление сайта 387

Предметный указатель 409

Доменная зона 381 ◊ ControllerBase 186
Доменное имя 381 ◊ DbContext 163, 169
◊ Directory 357
Ж ◊ File 357
◊ FileResult 55, 68, 357
Жизненный цикл компонентов Blazor 157 ◊ FileStream 71
◊ FileStreamResult 372
З ◊ FormTagHelper 144
◊ HtmlString 132
Замыкание конвейера ◊ HttpClient 194
◊ запросов 41 ◊ HttpContent 195
◊ фильтра 288 ◊ HttpContext 40
Защищенные страницы сайта 293 ◊ HttpRequest 40
◊ HttpResponse 40
И ◊ HttpResponseMessage 195
◊ MailMessage 364
Инструкции верхнего уровня 20 ◊ ObjectResult 54
Инструменты браузера для разработчиков ◊ SelectList 99, 319
◊ SelectListItem 319, 375, 377
279 ◊ SelectTagHelper 144
Интерфейс ◊ ServiceFilterAttribute 291
◊ IActionResult 54, 206 ◊ SKBitmap 371
◊ IConfiguration 23, 366 ◊ SmtpClient 364
◊ IDbConnection 178 ◊ Stream 372
◊ IDisposable 324 ◊ TagBuilder 132
◊ IDistributedCache 277 ◊ TagHelper 145
◊ IEnumerable 60 ◊ Timer 324
◊ IFormFile 359 ◊ TypeFilterAttribute 291
◊ IHostedService 321 ◊ ViewResult 57
◊ IHtmlHelper 131 ◊ WebApplication 20
◊ IHttpContextAccessor 303 ◊ WebApplicationBuilder 21
◊ IOrderedFilter 289 Клиентские библиотеки
◊ ITagHelper 145 ◊ минифицированные 219
◊ IViewComponentResult 151 ◊ неминифицированные 219
◊ IWebHostEnvironment 22, 29, 70, 357 Ключевое слово term См. Свойство term
Интерфейсы фильтров 285 Код-вставки 108
Коды состояния HTTP 14
К Коллекция
◊ Cookies 280
Капча См. CAPTCHA ◊ моделей 77
Каталог wwwroot 42 Команда
Класс ◊ Add-Migration 160
◊ AliceRequest 212, 213 ◊ Invoke-RestMethod 188
◊ AliceResponse 213 ◊ Update-Database 160
◊ AnchorTagHelper 139 Компиляция среды выполнения Razor 117
◊ Assembly 27 Компонент
◊ BackgroundService 321 ◊ Blazor 153
◊ ConfigurationBuilder 26 ◊ ViewModel См. Модель представления
◊ ContentResult 54 ◊ представления 150
◊ Controller 54

410 Предметный указатель

Компоненты ◊ AddScoped 35, 63, 117
◊ Middleware 21, 36 ◊ AddServerSideBlazor 157
◊ промежуточного программного ◊ AddSession 277
◊ AddSingleton 30, 101, 117
обеспечения См. Компоненты ◊ AddTransient 35, 116
Middleware ◊ AddXmlFile 25, 30
◊ промежуточного слоя См. Компоненты ◊ AddXmlSerializerFormatters 209
Middeleware ◊ Append 132
Компоновка 122 ◊ AppendHtml 132
Конвейер ◊ autocomplete 310
◊ обработки запросов 21, 36 ◊ BadRequest 205
◊ фильтров 285 ◊ Build 21
Консоль диспетчера пакетов 118, 188 ◊ Clear 132
Контекст ◊ Content 55
◊ данных 161 ◊ CreateBuilder 21
◊ контроллера 65 ◊ Database.EnsureCreated 169
Контроллер 46, 53 ◊ Database.EnsureDeleted 169
◊ Web API 184 ◊ DeleteAsync 195
Конфигурация приложения 23 ◊ DeserializeObject 196
Конфигурирование конечных точек Kestrel ◊ Execute 178
393 ◊ File 69
◊ Find 166
М ◊ GetAsync 196
◊ GetChildren 27
Маршрут 47 ◊ GetEnumSelectList 145
Маршрутизация 47 ◊ GetExecutingAssembly 27
Мастер-страница См. Компоновка ◊ GetFiles 357
Метод ◊ GetRequiredService 31
◊ $(document).ajaxComplete 257 ◊ GetSection 27, 151
◊ $(document).ajaxError 254 ◊ Html.BeginForm 136
◊ $(document).ajaxStart 256 ◊ Html.Raw 130
◊ $(document).ajaxStop 256 ◊ Invoke 152
◊ $(document).ajaxSuccess 253 ◊ InvokeAsync 152
◊ $.ajax 239, 245, 249, 270, 311 ◊ Json 250
◊ $.ajaxSetup 239, 242 ◊ load 238
◊ $.get 239, 249 ◊ MapBlazorHub 157
◊ $.map 312 ◊ MapControllerRoute 48
◊ $.param 257 ◊ MapControllers 184
◊ $.post 239, 249 ◊ MapGet 21, 22, 37
◊ Add 166 ◊ ModelState.AddModelError 205
◊ AddCommandLine 25 ◊ NotFound 206
◊ AddControllers 184 ◊ Ok 205
◊ AddCssClass 132 ◊ OnConfiguring 163
◊ AddDbContext 173 ◊ OnModelCreating 170
◊ AddEnvironmentVariables 25 ◊ OnResourceExecuted 284
◊ AddHostedService 324 ◊ OnResourceExecuting 284
◊ AddIniFile 25 ◊ open 237
◊ AddInMemoryCollection 23 ◊ PhysicalFile 70
◊ AddJsonFile 25, 26 ◊ PostAsync 197
◊ AddMvc 44
◊ AddRazorRuntimeCompilation 119

Предметный указатель 411

◊ Process 145 Модальное диалоговое окно Bootstrap 268
◊ ProcessAsync 145 Модель 47, 55, 72
◊ PutAsync 197 ◊ анемичная 72
◊ Query<T> 178 ◊ одиночная 75
◊ ReadAllBytes 357 ◊ полная 74
◊ ReadAsStringAsync 196 ◊ представления 80, 83
◊ RedirectToAction 89, 101, 122 ◊ привязка 97
◊ RedirectToRouteResult 297 ◊ размещения приложений 387
◊ Remove 167 ◊ сущности 83
◊ RenderBody 123, 302
◊ RenderSection 123 Н
◊ Run (для Middleware) 41
◊ Run (для приложения) 21 Навигационная панель Bootstrap 302
◊ SaveChanges 166 «Ненавязчивый AJAX» 235, 259
◊ send 237
◊ SerializeObject 198 О
◊ SetBasePath 26
◊ SetContent 132 Обозреватель решений 18, 19
◊ SetHtmlContent 132, 146 Объект
◊ Skip 342 ◊ HttpContext 66
◊ StartAsync 324 ◊ JsonSerializer 278
◊ StopAsync 324 ◊ Model 59, 76
◊ submit() 320 ◊ ModelState 104, 205, 373
◊ Take 342 ◊ RouteValueDictionary 297
◊ Update 167 ◊ Session 277
◊ UseAuthentication 37 ◊ TempData 121, 353
◊ UseConfiguration 24 ◊ ViewBag 120
◊ UseDeveloperExceptionPage 22 ◊ ViewData 120
◊ UseEndpoints 22, 37 ◊ XMLHttpRequest 235
◊ UseHttps 393 Объектная модель документа См. Document
◊ UseHttpsRedirection 184
◊ UseMiddleware 41 Object Model
◊ UseMvcWithDefaultRoute 44 Ограничения для маршрутов 48
◊ UseRouting 22, 37
◊ UseSession 277 П
◊ UseSqlServer 163, 173
◊ UseStaticFiles 42, 223, 361 Пагинация 338
◊ UseWindowsService 391 Параметр
◊ View 57 ◊ contentType 243, 249
◊ WriteAsync 24 ◊ context 242
◊ WriteTo 132 ◊ dataType 249
Методы ◊ error 242
◊ HTTP 13 ◊ ErrorMessage 227, 295
◊ действий 53 ◊ format 210
◊ работы с Cookies 280 ◊ method 248
◊ работы с сессией 277 ◊ success 242
Механизм слабой связи 28, 80, 116 ◊ TagHelperContext 145
Миграции 160 ◊ TegHelperOuter 145
Множественные параметры шаблонов ◊ url 247
Параметры
маршрутов 68 ◊ Сookie 282
◊ кодировщиков 233

412 Предметный указатель

Паттерн Сеанс См. Сессия
◊ MVC 44, 47 Сервисы Web API 180
◊ Репозиторий 63 Сериализация 278
Передача ◊ объектов C# 198
◊ моделей в контроллеры 91 Сессия 275
◊ моделей в представление 75, 120 Сеть CDN 219, 310
◊ файла с формой 360 Событие onreadystatechange 237
Переключатели См. Элемент:radio button Создание
Переопределение мастер-страниц 125 ◊ HTML-хелперов 131
Платформа «Яндекс.Диалоги» 213 ◊ службы Windows 391
Подключение служб IIS 386 ◊ тег-хелперов 145
Поставщики данных 173, 179 Сортировка данных в таблицах 326
Представление 47 Статические файлы 42
◊ Razor 57, 108 Стилизация элементов 223
Приложение ngrok 215 Строго типизированные хелперы 137
Провайдеры клиентских библиотек 219 Структура проекта 18
Промежуточное программное обеспечение Сущность 83, 160

См. Компоненты Middleware Т
Пространство имен
◊ Microsoft.AspNetCore.Mvc.Rendering 319 Тег-хелпер 99, 137
◊ System.Diagnostics 324 ◊ <component> 156
◊ System.Net 365 ◊ <environment> 221
◊ System.Net.Mail 364 ◊ <partial> 148
Публикация ◊ <select> 320
◊ автономная 383 ◊ валидации 102
◊ зависящая от платформы 383 Технология AJAX 235
◊ приложения 381 Тип DbSet<TEntity> 163, 170
◊ профиль 382 Типизированные модели 59
Пулы приложений 388 Точка входа в приложение 20

Р Ф

Размещение Файл
◊ в виде службы Windows 390 ◊ *.pfx 392
◊ приложения на IIS 386 ◊ _Layout.cshtml 122
Раскрывающийся список 314 ◊ _ViewImports.cshtml 128
Регистрация сервисов 30 ◊ _ViewStart.cshtml 126
Редактор nano 395 ◊ appsettings.json 25, 292, 365, 385, 392
◊ cookie 280
С ◊ launchSettings.json 186, 240
◊ libman.json 220
Свойство Файлообменник, создание 355
◊ Attributes 132 Фильтры 284
◊ Component 152 ◊ авторизации 284
◊ ContentRootPath 30, 70 ◊ асинхронные 286
◊ Credentials 365 ◊ глобальные 287
◊ InnerHtml 132 ◊ действий 285, 296
◊ readyState 237 ◊ исключений 285
◊ Request 283 ◊ результатов 285
◊ Response 280, 283
◊ term 311

Предметный указатель 413

◊ ресурсов 284 Ч
◊ синхронные 286
Фоновая задача 321 Частичные представления 148, 302
Форма обратной связи 361 Чат-бот 211
Функция
◊ alert 242, 265 Э
◊ JSON.stringify 249
◊ setTimeout 326 Элемент
◊ jQuery UI Datepicker 229
Х ◊ radio button 375

Хелпер
◊ Html.ActionLink 88, 91
Хостинг 381

Умрихин Е.

www.bhv.ru Разработка Android-приложений на С#
с использованием Xamarin с нуля

Отдел оптовых поставок:
e-mail: [email protected]

Создавай мобильные приложения с Xamarin!

Вы узнаете, как:

• использовать интегрированную среду
разработки IDE

• работать с Activity

• выбирать и использовать управляющие
элементы

• записывать и считывать данные

• взаимодействовать с веб-сервисами
и средствами коммуникаций

• собирать написанные на С# мобильные
приложения

• публиковать приложения в Google Play

Язык программирования C# — одно из самых популярных средств разработки.
Многие уже владеют приемами программирования на базе технологий Microsoft,
и эти навыки можно с успехом использовать при создании мобильных приложений
для платформы Android. Изучение платформы Xamarin.Android дает возможность
внедрять и развивать свои мобильные сервисы с использованием технологического
стека Microsoft.

Книга будет полезна всем, кто знаком с программированием на C# или только изу-
чает этот язык и интересуется мобильной разработкой, но пока еще не решается
приступить к написанию своей первой программы. Читатель получит опыт созда-
ния нативных приложений для самой популярной мобильной платформы. Каждая
тема сопровождается наглядными примерами, дающими необходимые представле-
ния об используемой технологии.

Умрихин Евгений Дмитриевич, кандидат технических наук, инженер-программист в круп-
ной региональной страховой компании. Имеет многолетний опыт разработки и внедрения
распределенных IT-решений с использованием веб-сервисов ASP.NET и мобильных плат-
форм Android и iOS. Обладатель ряда авторских свидетельств об официальной регистрации
программ для ЭВМ.

www.bhv.ru Гриффитс Д., Гриффитс Д.

Практические приемы работы с фреймворком React

Отдел оптовых поставок:
e-mail: [email protected]

Вы научитесь:

• Создавать одностраничные приложения в React,
использующие сложный пользовательский
интерфейс

• Создавать прогрессивные веб-приложения,
которые пользователи могут устанавливать на
своем устройстве и работать с ними
в автономном режиме

• Интегрировать разрабатываемые приложения
со службами бэкенда, такими как REST
и GraphQL

• Выполнять автоматическое тестирование для
обнаружения проблем с доступностью
в разрабатываемом приложении

• Обеспечивать безопасность приложений при
помощи цифровых отпечатков и ключей
безопасности с применением технологии
WebAuthn

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

Дэвид Гриффитс, автор и преподаватель, занимается разработкой кода в React на профессио-
нальном уровне в течение 5 лет. Создавал приложения для стартапов, магазинов розничной
торговли, производителей транспортных средств, национальных спортивных команд и круп-
ных поставщиков программного обеспечения.

Дон Гриффитс, автор и преподаватель с более чем 20-летним опытом разработки программ-
ного обеспечения для персональных компьютеров и Интернета.

www.bhv.ru Прохоренок Н., Дронов В.

Python 3 и PyQt 6. Разработка приложений

Отдел оптовых поставок:

e-mail: [email protected]

Быстрое создание программ с графическим интерфейсом

• Типы данных Python

• Объектно-ориентированное программирование

• Работа с файлами и каталогами

• Взаимодействие с Windows

• Создание оконных программ

• Работа с базами данных

• Мультимедиа

• Запись звука, видео и фото

• Печать и экспорт в формат PDF

• Работающий пример: приложение «Судоку»

Описан язык Python 3: типы данных, операторы,
условия ветвления и выбора, циклы, регулярные
выражения, функции, классы, работа с файлами
и каталогами, взаимодействие с механизмами
Windows, часто используемые модули стандартной
библиотеки. Особое внимание уделено библиотеке PyQt, позволяющей создавать
приложения с графическим интерфейсом. Описаны средства для создания и вывода
окон, основных компонентов (кнопок, полей, списков, таблиц, меню, панелей инст-
рументов и др.). Рассмотрены обработка событий и сигналов, разработка многопо-
точных программ, работа с базами данных, вывод графики, воспроизведение муль-
тимедиа, запись аудио, видео и фото, печать документов, экспорт их в формат
Adobe PDF и сохранение настроек программ. Дан пример полнофункционального
приложения для создания и решения головоломок судоку. На сайте издательства
размещен электронный архив со всеми примерами из книги.

Прохоренок Николай Анатольевич, профессиональный программист, имеющий большой
практический опыт создания приложений с использованием С, Java, Python, HTML, JavaScript,
PHP и MySQL. Автор более 20 книг, в том числе «HTML, JavaScript, PHP и MySQL. Джент-
льменский набор Web-мастера», «JavaScript и Node.js для веб-разработчиков», «Bootstrap
и CSS-препроцессор Sass. Самое необходимое», «Python 3. Самое необходимое», «Qt 6. Разра-
ботка оконных приложений на C++» и др.

Дронов Владимир Александрович, профессиональный программист, писатель и журналист,
работает с компьютерами с 1987 года. Автор около 50 популярных книг по информационным
технологиям, в том числе «Django 3.0. Практика создания веб-сайтов на Python», «Laravel 8.
Быстрая разработка веб-сайтов на PHP», «HTML и CSS. 25 уроков для начинающих»,
«JavaScript. 20 уроков для начинающих», «PHP и MySQL. 25 уроков для начинающих»,
«JavaScrip. Дополнительные уроки для начинающих» и «React 17. Разработка веб-приложений
на JavaScript».