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

Обычно для разработки серверной части веб-приложений (по-простому — бэка) с помощью ASP.NET Core имеет смысл использовать базирующиеся на нем фреймворки высокого уровня: MVC Core, Razor Pages и т.д.: они позволяют с минимумом усилий решать типовые задачи. Но встречаются задачи нетиповые, которые требуют для своего решения перейти на более низкий уровень (или, по крайней мере, понимать, что на этом уровне происходит) — на уровень базовых возможностей ASP.NET Core. И в этой статье как раз рассказывается об использовании одной из этих базовых возможностей — компонентов middleware, из которых создается конвейер обработки запросов к веб-серверу. Далее в статье я буду называть их компонентами-обработчиками, потому что официальный перевод из документации от MS — "ПО промежуточного слоя" — он некрасив и не описывает их функции. Конкретно в статье рассматривается, какие средства предоставляет фреймворк ASP.NET Core для создания самописных компонентов-обработчиков. И особое внимание уделено тому, как эти компоненты могут получить доступ к другой базовой возможности ASP.NET Core — сервисам, которые зарегистрированы в контейнере сервисов (он же — "DI-контейнер"), как к стандартным для ASP.NET Core, так и к самописным.

Эта статья является продолжением двух предыдущих занудных статей под общим заголовком "О классах Program и Startup — инициализация ASP.NET приложения": "Program и IHostBuilder"[1] и "IWebHostBuilder и Startup"[2] — в которых подробно написано о том, что происходит в процессе инициализации приложения ASP.NET, сделанного по шаблону Generic Host. В тех двух статьях я рассказывал, как производится настройка и выполняется создание объектов конфигурации (она доступна через интерфейс IConfiguration), контейнера сервисов (он же DI-контейнер, его интерфейс — IServiceProvider) и размещения (интерфейс IHost). А в этой статье я собираюсь подробно рассказать, что происходит сразу после того, как приложение запускается на выполнение в объекте размещения.
Написав третью статью на примерно одну и ту же тему, я подумал, что и первые две, и эта должны стать частью одной серии, которую я для себя озаглавил "Под капотом" (см. КДПВ)

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

Да, это еще одна статья, вызванная к жизни все тем же тестовым заданием, про решение которого я уже писал. И которое, вообще-то, объективно не заслуживает такого внимания, но так получилось, что меня оно зацепило. Еще когда я разбирался с крутым решением этого задания во второй посвященной ему статье, меня никак не оставляла в покое мысль — а как решить его, чтобы, с одной стороны, не "на отвали" (как в исходной статье), а с другой — без монад и goto, как в крутом решении во второй статье. И тогда я вспомнил про старое доброе объектно-ориентированное программирование (ООП), про те далекие времена, когда я писал сервисы для Windows на Delphi и подумал: а не написать ли мне решение именно в духе того старого доброго ООП. Я подумал — и я написал. И как ненастоящий программист, не обязанный писать код по долгу службы, но пишущий код исключительно ради своего удовольствия, я решил поделиться и кодом, и удовольствием (если получится) с читателями.

Я не обещаю в этом решении сократить объем кода, используя крутые сторонние библиотеки, или увеличить его производительность крутой оптимизацией под JIT. Я просто хочу продемонстрировать, как можно решить эту задачу, используя старую добрую объектно-ориентированную парадигму, без монад и без goto, руководствуясь здравым смыслом (ну, и небольшим объемом знаний). И как при этом можно написать код — легко* читаемый (* — если вы привыкли использовать ООП) и легко расширяемый, без сторонних библиотек, и оптимизировать его чисто на алгоритмическом уровне, без помощи тонких настроек JIT.

Итак, кому интересно решение этого неинтересного тестового задания в духе старого доброго ООП, и кто не забыл ещё (но уже осилил), что означает ключевое слово virtual — добро пожаловать под кат.

Не все тестовые задания удостаиваются внимания на Хабре. Почему — примерно, понятно. Однако бывают исключения. Так, некоторое время тому назад одно, в общем-то, ничем не примечательное тестовое задание на Хабре породило аж целых две статьи про него.

Первая из них — "История одного фееричного провала тестового задания на C#" — была написана в жанре пространной жалобы соискателя на невежливый ответ (дословно: "отвратительно, халтурно") нанимателя на решение тестового задания, которое автору дали при попытке устройства на работу. В принципе, у меня эта статья особого интереса не вызвала: там было вполне рабочее решение — но без всякого блеска и с явными следами торопливости (похоже, именно они не понравились нанимателю) — не слишком интересной задачи — сделать класс, разбирающий строку расписания в cron-подобном формате и реализующий методы поиска в этом расписании.

Однако через некоторое время на Хабре появилась вторая посвященная этому тестовому заданию статья. Его решение в той статье было с монадами и goto, и оно произвело на меня сильное впечатление. Первая мысль после прочтения у меня была "Круто!" (или, как выразился автор первого же комментария "Шикарно"). В частности, одна из примечательных особенностей решения — использование для разбора строки не своего "велосипеда", а хорошей сторонней библиотеки.

Тем не менее, на второй взгляд все оказалось не так хорошо, на как на первый. Та часть решения, которая представляет собой программу-разборщик строки расписания, могла быть существенно улучшена, с сокращением объема и улучшением понятности, если для этого полнее использовать методы той же самой библиотеки для построения разборщиков (ну, и не забывать, что мы пишем на языке C#). Если вам интересно, как, почему и что может быть сделано — добро пожаловать под кат.

Это - продолжение статьи, первая часть которой была опубликована ранее. В той части был рассмотрен процесс инициализации, общий для любого приложения .NET Core на базе шаблона Generic Host. А в этой части будет рассмотрена инициализация, специфическая именно для веб-приложения. Именно в нее входят вызовы методов Startup-класса.

Если вы не читали первую часть, то рекомендую в нее заглянуть, по двум причинам. Во-первых, процесс инициализации, специфической именно для веб-приложения, существенно опирается на механизмы, рассмотренные в первой части: методы интерфейса построителя веб-приложения IWebHostBuilder в основном реализуются через вызовы методов интерфейса построителя IHostBuilder, и процесс инициализации проходит, в целом, через те же стадии, общие для любого базирующегося на Generic Host приложения .NET Core. А во-вторых, там объяснено, для чего часть информации убрана под спойлеры, и какую информацию под какими спойлером можно увидеть (и решить - а стоит ли ее смотреть).

И ещё пара слов про вторую часть. К моему сожалению, она получилась раза в два больше первой части, которая сама по себе была и так немалой. Но мне не удалось найти способа сократить ее без ущерба для содержания. Так что заранее прошу простить меня тех, кому большой объем статьи помешает с ней ознакомиться. Возможно, им сможет помочь краткое содержание этой статьи, которое находится сразу под катом.
А ещё, опыт публикации первой части показал, что стоит заранее предупредить потенциальных читателей, чтобы ненароком не ввести их в заблуждение: в этой статье содержится только описание "как оно работает", но нет никакой информации, как этим пользоваться практически, никаких рецептов и вообще - никакого кода. К сожалению, большой объем матераиала заставил чем-то пожертвовать. И я решил ради полноты описания принципов работы - информации, которую лично я нигде больше не видел - пожертвовать сведениями о практических приемах работы - той информацией, которая, в конце концов, уже опубликована в руководстве от изготовителя и в многочисленных статьях.

Итак, кому интересен предмет статьи - добро пожаловать под кат.

Не так давно на Хабре я увидел статью с многообещающим названием "Что из себя представляет класс Startup и Program.cs в ASP.NET Core". Меня всегда интересовало и интересует, что именно происходит под капотом той или иной библиотеки или фреймворка, с которыми мне доводится работать. И к веб-приложениям на ASP.NET Core это относится в полной мере. И я надеялся получить из этой статьи новую информацию о том, как работают упомянутые классы при запуске такого приложения. Та статья, к сожалению, меня разочаровала: в ней всего лишь в очередной раз был пересказан кусок руководства, никакой новой информации я оттуда не получил. И при чтении ее я подумал, что, наверное, есть и другие люди, которым, как и мне, интересно не просто знать, как применять тот или иной фреймворк (ASP.NET Core в данном случае), но и как он работает. А так как я по разным причинам последнее время довольно сильно углубился во внутреннее устройство ASP.NET Core, то я подумал, что теперь мне есть много что рассказать о нем из того, что выходит за рамки руководств. И вот потому я решил для начала написать статью про то, что действительно представляют из себя классы Startup и Program - так, чтобы рассказать не о том, как ими пользоваться, а о том, как работают эти классы, причем - в контексте работы всего веб-приложения на ASP.NET Core. Однако поскольку необъятное объять нельзя, то предмет этот статьи ограничен. Прежде всего, она ограничивается рассказом только про веб-приложения, созданные с использованием нового типа шаблона приложения - Generic Host. Во-вторых, статья будет посвящена только тому, как происходит инициализация веб-приложения, потому что основная роль рассматриваемых классов именно такова - инициализация и запуск размещенного приложения.

И ещё - предупреждение, судя по одному из комментариев - необходимое, чтобы не вводить в заблуждение потенциальных читателей: эта статья не предназначена служить руководством, она не содержит рецептов "как это использовать на практике". Такая информация есть в многочисленных уже написанных другими руководствах, и я не вижу для себя смысла писать еще одно. Да и объем статьи и без того велик.

Итак, кому рассматриваемая тема, даже в столь ограниченном объеме, интересна - добро пожаловать под кат.

Должен сразу признаться, что программист я не настоящий. То есть, когда-то я был и настоящим — в смысле, мне деньги платили именно за написание программ. Однако это было более пятнадцати лет назад, программы я писал, в соответствии с тогдашней модой, в основном, на Delphi (ну или чуть раньше — ещё и на C/C++) — короче, на том, что сейчас, ну, совсем не модно и спросом не пользуется. А последние лет пятнадцать я зарабатывал почти исключительно системным администрированием, преимущественно, администрированием решений Microsoft, в особенности Active Directory и MS Exchange. И единственное, что в этой деятельности касалось программирования — это написание скриптов на, если так можно выразиться, языке программирования под названием Powershell.

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