Asp компонент status


Содержание

Лекция 1. Что такое ASP.NET. Инсталляция и тестовый проект.

Введение

Microsoft .NET Framework — это платформа для создания, развертывания и запуска Web-сервисов и приложений. Она предоставляет высокопроизводительную, основанную на стандартах, многоязыковую среду, которая позволяет интегрировать существующие приложения с приложениями и сервисами следующего поколения, а также решать задачи развертывания и использования интернет-приложений. .NET Framework состоит из трех основных частей — общеязыковой среды выполнения (common language runtime), иерархического множества унифицированных библиотек классов и компонентной версии ASP, называемую ASP.NET.

ASP.NET – это часть технологии .NET, используемая для написания мощных клиент-серверных интернет приложений. Она позволяет создавать динамические страницы HTML. ASP.NET возникла в результате объединения более старой технологии ASP (активные серверные страницы) и .NET Framework. Она содержит множество готовых элементов управления, используя которые можно быстро создавать интерактивные web-сайты. Вы также можете использовать сервисы, предоставляемые другими сайтами, прозрачно для пользователей вашего сайта. В общем, возможности ASP.NET ограничены только вашим воображением.

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

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

Но что, если мы хотим отобразить на странице текущий курс евро или прогноз погоды? Если мы написали страницу HTML вчера, сегодня она уже устареет. Следовательно, мы должны уметь создавать динамические страницы. Динамическое наполнение страницы – это информация, содержание которой определяется тем, кому она предназначена, и которая отличается от просмотра к просмотру. Оно позволяет обеспечить двусторонний обмен информацией – от клиента к серверу и обратно.

Динамическими принято называть web-страницы, которые перед отправкой клиенту проходят цикл обработки на сервере. В самом простом случае это может быть некоторая программа, которая модифицирует запрашиваемые клиентом статические страницы, используя параметры полученного запроса и некоторое хранилище данных. Даже при такой примитивной организации «неразрешимая» задача из предыдущего абзаца обретает очевидное решение: достаточно подготовить всего одну статическую страницу – шаблон – и перед отправкой страницы программно подставлять в него значение, полученное сегодня из банка или метеобюро.

Большинство страниц на ранних стадиях развития интернета были статическими. Последние 10 лет растет количество динамических страниц. И это понятно, пользователи интернет хотят не только читать готовую информацию, а быть активными действующими лицами. Например, они заказывают товары в интернет-магазине, пишут дневники, участвуют в конкурсах. Информационные порталы обновляют новости каждую минуту. Динамические страницы могут подстраиваться под конкретного пользователя, а также реагировать на его действия в браузере. Каким же образом? Для этого придумано множество технологий. Например, того, чтобы идентифицировать пользователя и сохранить его настройки для данного сайта, применяются файлы-cookies.

Существуют языки, способные динамически изменять содержимое веб-страницы. С одной стороны, это языки скриптов, выполняющиеся непосредственно у клиента. Примеры скриптовых языков — JavaScript и VBScript. Скрипты на этих языках встроены в код HTML, который сервер посылает браузеру. Сценарии, выполняемые на стороне клиента, выделяются тегами и . Браузер интерпретирует этот код и показывает пользователю результат. Сам код можно просмотреть через View Source браузера. Естественно, эти программы не могут быть большими. Например, если нужно выполнить поиск в базе данных, мы не может отправить пользователю все ее содержимое. Но скрипты могут проверить правильность запроса, введенного в форму, тогда не придется перезагружать сервер обработкой неправильных запросов. Некоторые программисты создают на JavaScript анимационные эффекты. Одна студентка intuit.ru желала найти скрипт, который бы отправлял SMS-сообщения. Увы, это невозможно. Выполняемых на стороне клиента сценариев недостаточно для создания полноценных динамических страниц. Даже если на странице используется JavaScript, анимированные картинки .gif, она называется статической.

Динамическая веб-странице должна быть создана «на лету» программой, исполняющейся на интернет-сервере. Широко применяются механизм шлюзов CGI(Common Gateway Interface). Вначале пользователь получает статическую страницу с формой. Вам известно, что в теге FORM существует атрибут ACTION. Именно он задает адрес (URL) исполняемого приложения. На сервере находятся исполняемые файлы программ, написанных, например на C/С++ или Дельфи, которые по протоколу HTTP принимают данные из входного потока или из переменных окружения и записывают в стандартный выходной поток готовую страницу.

Пользователю в ответ на запрос посылается HTML код, который был специально сгенерирован для него. Это может быть, например, результат поиска в поисковой системе. CGI -скрипты могут быть написаны на интерпретируемом языке (Perl) или даже скрипте командной строки. Входной и выходной потоки переназначаются. На вход интернет-сервер принимает данные, введенные пользователем. После обработки полученных данных, пользователю возвращается результирующая страница. При исполнении cgi-программа загружается в память сервера, а при завершении – удаляется. Когда 100 клиентов одновременно обращаются к серверу, в памяти создаются 100 процессов, для размещения кода каждого из которых нужна память. Это отрицательно сказывается на масштабируемости. Напомним, что масштабируемость — это возможность плавного роста времени ответа программной системы на запрос с ростом числа одновременно работающих пользователей.

Для решения это проблемы Microsoft была предложена альтернатива – ISAPI(Internet Server Application Programming Interface)-расширения и фильтры. Вместо исполняемых файлов используются DLL – библиотеки. Код DLL находится в памяти все время и для каждого запроса создает не процессы, а нити исполнения. Все нити используют один и тот же программный код. ISAPI –приложение выполняется в процессе IIS-сервера. Это позволяет повысить производительность и масштабируемость.

ISAPI-расширения можно создавать в Visual Studio C++ 6.0, пользуясь мастером.

У ISAPI тоже есть недостатки, относящиеся к разработке. Если мы меняем исходный код dll, мы должны его откомпилировать и поместить в исполняемую директорию сервера. Но так как предыдущий вариант dll находится в памяти, необходимо остановить сервер, чтобы получить доступ на изменение файла. В это время клиенты не смогут получить в сервера ни один документ, и, конечно, будут не удовлетворены.

Скриптовые языки, исполняющиеся на стороне сервера – php и asp. Технология asp была разработана Microsoft в 90-х годах.

Выполнение кода asp поддерживается ISAPI-расширением сервера. В диалоге конфигурации сервера IIS определяются способы обработки файлов с различными расширениями. Для обработки URL-адреса с расширением в установках сервера определен файл asp.dll. Файлы asp отправляются к нему на обработку. На вход поступает asp, а на выходе имеем поток HTML-кода.

Пример файла asp:

Тег сигнализирует asp, что в нем находится код, который он должен обрабатывать на сервере. Выполняется скрипт на языке, который указан в директиве Language. Оператор Response.Write записывает текст в выходной поток сервера, таким образом, он становится частью HTML-страницы, отправленной пользователю.

Технология asp была ограничена по своим возможностям. Он использовал скриптовые языки, которые имеют меньше возможностей, чем полнофункциональные языки программирования. Код asp был встроен в HTML в виде специальных тегов, что создавало путаницу. Кусочки asp были разбросаны по нему, как изюм в булке. Но HTML код обычно создают дизайнеры, которые умеют «делать красиво», а asp – программисты, которые заставляют все это работать. В ASP.NET вы можете держать код asp и HTML в разных файлах.

Скриптовые языки не поддерживают строгую типизацию. Что это значит? Вы можете не описывать переменную до ее использования и можете присваивать ей значения разных типов. Это удобно, но создает почву для ошибок. Например, у вас есть переменная x1, и вы присваиваете ей значение 1, но вы сделали опечатку и по ошибке написали x2=1. Будет создана новая переменная x2, а значение x1 не изменится. В языке со строгой типизацией компилятор заметит, что переменная x2 не описывалась, и выдаст ошибку.

В 2000 году на конференции разработчиков в качестве части новой технологии .NET Microsoft представила ASP+. С выходом .NET Framework 1.0 она стала называться ASP.NET.

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

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

Компиляция происходит на сервере в момент первого обращения пользователя к странице. Если программист изменил текст страницы, программа перекомпилируется автоматически. При написании кода можно использовать набор компонентов, поставляемых с .NET.

Платформа .NET Framework предоставляет приложениям среду выполнения, сама непосредственно взаимодействуя с операционной системой. Выше лежит интерфейс ASP.NET приложений, на котором в свою очередь базируются веб-формы (ASP.NET страницы) и веб-сервисы. Интерфейс .NET Framework позволяет стандартизировать обращение к системным вызовам и предоставляет среду для более быстрой и удобной разработки. CLR обеспечивает единый набор сервисов для всех языков.

ASP.NET использует технологию доступа к данным ADO.NET, которая обеспечивает единый интерфейс для доступа к базам данных SQL Server и файлам XML. Кроме того, усиленная модель безопасности позволяет обеспечивать защиту клиента и сервера от несанкционированного доступа.

В 2004 году появилась версия ASP.NET 2.0(бета-версия, окончательный выход – конец 2005-начало 2006). Как утверждается, эта версия позволяет сократить объем кодирования на 70%. Новые возможности версии 2.0 – например, использование шаблонов дизайна страниц(Master Page), упрощенная локализация Web-приложений, более 50 новых серверных элементов управления. Цели, которые преследовали разработчики новой версии – повысить скорость разработки сайтов, масштабируемость, легкость поддержки и администрирования сайтов, скорость работы сервера. Появилась панель остнастки MMC (консоль управления Microsoft), предоставляющая графический интерфейс для управления настройками ASP.NET. Изменять настройки проекта теперь можно и через web-интерфейс. ASP.NET 2.0 поддерживает работу на 64-битных процессорах. Сервис персонализации (personalization) предоставляет готовое решение для хранения персональных данных, непосредственно характеризующих пользователя сайта, так называемого профиля пользователя (Profile).

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

Предыдущие версии Visual Studio для проектов ASP.NET требовали наличия на машине разработчика сервера IIS. Теперь сервер встроен в среду разработки.

ASP.NET 2.0 и Visual Studio 2005 предоставляют инструменты для легкого построения локализируемых сайтов, которые определяют предпочитаемый язык пользователя и посылают ему страницы на его языке.

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

В ASP.NET 2.0 встроена технология автоматического обновления кэширования баз данных. Данные, полученные из базы, хранятся на сервере и он не обращается к базе для обработки повторного запроса. При изменении базы данных кэш обновляет свое содержимое.

ASP.NET — это технология, а не язык, и позволяет программировать на разных языках – С#, Visual Basic, J#. В платформе .NET все языки равны, но некоторые равнее(Дж. Оруэлл). Вот таким языком и является С#, потому что он был специально создан для этой платформы. Программирование C# позволяет в полной мере использовать концепции, методы и паттерны объектно-ориентированной разработки. Язык Visual Basic 8.0 наделен почти теми же возможностями. Чтобы научиться ASP.NET, вам нужно знать основы HTML, а знание asp не обязательно. Оно может даже помешать, так как придется менять образ мышления. Также для понимания многих желательно знать CSS и JavaScript.

Процесс инсталляции

ASP .NET 2.0 можно установить на компьютерах с ОС Windows 2000 с Service Pack 4, Windows XP с Service Pack 2 и более поздними версиями Windows. Готовые сайты предпочтительно устанавливать на Windows Server 2003.

Для разработки приложения можно использовать любую среду разработки или даже текстовый редактор, при условии, что у вас есть доступ к IIS. Если же вы хотите воспользоваться всей мощью Microsoft .NET Framework и ASP.NET и при этом, затратить как можно меньше усилий, то нужно воспользоваться средой разработки, специально разработанной для программирования ASP.NET 2.0.

Если вы приобретете Visual Studio .NET 2005, то для работы достаточно будет только его. .NET Framework содержится на дисках. В его состав входит Visual Web Developer, который позволяет создавать профессиональные веб-приложения, а также desktop-приложения на разных языках программирования. Продукты Microsoft выпускаются на DVD, но есть набор из двух CD от «Мегасофт». Visual Studio .NET 2005 требует около 2 Гигабайт дискового пространства. При этом инсталлируется ASP.NET 2.0, среда разработки, SQL Server Express, встроенный веб-сервер, Crystal Reports со специальными элементами управления для ASP.NET 2.0.
Бесплатно распространяемое программное обеспечение.

Visual Web Developer 2005 Express Edition – свободно распространяемая среда предназначенный для новичков и студентов, доступная по адресу http://msdn.microsoft.com/vstudio/express/vwd/. Список отличий VWD от Visual Studio.NET 2005 невелик и для начинающих несущественен, он приведен здесь: http://msdn.microsoft.com/vstudio/products/compare/default.aspx

Инсталлятор VWD имеет объем 2,8 Мб, но в процессе инсталляции он загрузит еще 40 Мб и 80 Мб, если захотите установить документацию. При этом также будет установлен .NET Framework с ASP.NET 2.0.

Системные требования – процессор с минимальной скоростью 600 МГц, 128 МБ памяти и 1.3 ГБ дискового пространства. После инсталляции нужно будет зарегистрировать свою установку, это совершенно бесплатно.

В качестве среды разработки вы можете выбрать WebMatrix. Эта программа совмещает в себе редактор и http-сервер. Ее можно загрузить на http://www.asp.net/WebMatrix.

У WebMatrix инсталлятор размером всего 1.2 Мб, но у него меньше возможностей, чем у VWD. Но, в общем, эти среды разработки похожи. У WebMatrix есть неприятная особенность – она дает запрос на сохранение во время закрытия файлов, которые не редактировались. VWD Express позволяет одним нажатием кнопки открыть Web-интерфейс конфигурирования проекта. В VWD работает технология IntelliSense, которая автоматически предлагает возможные в данном месте элементы кода.

Если вы решили работать с WebMatrix, вы должны установить на своей машине .NET Framework 2.0 и ASP.NET 2.0.

Если у вас операционная система Windows Server 2003, то .NET Framework уже предустановлен. Вы можете проверить, есть ли вас директория %WINSDIR%Microsoft.NETFramework. Если нет, вы можете ее загрузить на сайте Microsoft. Последние версии находятся по адресу http://msdn.microsoft.com/netframework/downloads/updates

На данный момент это .NET Framework 2.0, но к моменту, когда вы будете читать эту лекцию, могут появиться более новые версии. Вы можете скачать новую версию, даже если у вас уже есть другая. Они будут существовать на компьютере одновременно в поддиректориях %WINSDIR%Microsoft.NETFramework, с именем, соответствующим номеру версии. Можно сказать, что каждая версия представляет собой сборку. Система версий поддерживается для всех приложений, созданных с использованием .NET Framework.

Там вы увидите ссылки на .NET Framework для разных архитектур компьютера.

При желании загрузите .NET Framework Version 2.0 SDK, которая содержит наряду с .NET Framework Version 2.0 SDK документацию и примеры, которые могут оказаться полезными.

По адресу http://asp.net/default.aspx можно найти много полезных для разработчиков программных продуктов, примеров кода и статей.

IIS(Internet Information Server) находится на инсталляционном диске Windows 2000/XP, но предустановлен только на серверах. Его можно установить, зайдя в Control Panel->Add or Remove Programs->Add/Remove Windows Components. Компьютер попросит вас вставить инсталляционный диск.

IIS может понадобиться, если вам нужен полноценный сервер для работы в интернет, а не просто на своем компьютере или в локальной сети или вы решили набирать текст в обычном редакторе. Для работы на своем компьютере во все эти среды разработки встроен сервер Cassini, который первоначально появился как часть WebMatrix. Символ WebMatrix – планета Сатурн, а Кассини — известный исследователь Сатурна. Предыдущие версии Visual Studio требовали наличия IIS, но теперь Cassini встроен и в Visual Studio 2005, что позволяет работать даже в Windows XP Home Edition.

Примеры будут даваться как для WebMatrix, так и Visual Studio. Некоторые примеры требуют VWD Express или Visual Studio.
Сообщества разработчиков.

Через меню помощи Visual Web Developer Express можно зайти на сайты форума по ASP.NET. А вот адреса сайтов на русском языке:

* http://www.aspnetmania.com
* http://www.gotdotnet.ru/
* http://www.sql.ru/
* http://dotsite.ru/
* http://www.rsdn.ru/

Вы можете завести пробный хостинг на http://europe.webmatrixhosting.net/russia/default.aspx.

Первый проект

Вначале решите, в какой директории будете создавать страницы. Все файлы, находящиеся в одной директории, считаются единым проектом.Запустите выбранную вами среду разработки. Выберите пункт меню File-New-Website. Появится диалоговое окно. Назначьте в нем имя проекта и выберите язык программирования С#.

По умолчанию проект создается в файловой системе. По желанию его можно создать на HTTP или FTP-сервере. Из файловой системы проект всегда можно скопировать на сервер нажатием одной кнопки в заголовке Solution Explorer.

В проекте будет создана страница default.aspx. Выберите ее, и появится окно редактирования с закладками Design и Source. Не меняя ничего, щелкните на кнопке со стрелкой, чтобы просмотреть страницу в браузере. Появится окно, котором спрашивается, нужно ли добавить в файл web.config возможность отладки. Нажмите OK. На панели задач должен появиться значок веб-сервера. Откроется браузер, показывающий страницу по адресу http://localhost:номерпорта/Website1/default.aspx. localhost обозначает сервер, работающий на вашем компьютере. Встроенный сервер Cassini сам назначает себе номер порта – для каждого проекта он разный. Сервер IIS обычно работает через порт 80(или 8080, если тот занят), и для него номер порта указывать не нужно. При этом ваша страница будет скомпилирована.

Пока что страница в бразере пустая.

Но исходный код этой страницы не пустой. Программа сгенерировала код для вас.

Управление состоянием ASP.NET

Сохранение данных в состоянии сеанса

Любой пользователь при первом обращении к приложению получает свой сеанс , который выражается в выделении некоторого объема памяти на стороне сервера для хранения данных любого типа. Доступ к этим совместным данным осуществляется любой страницей через присоединенный к ней объект -словарь Session . За счет этого можно сохранять информацию на одной странице, а получать к ней доступ с другой страницы.

При поступлении первого клиентского запроса на объект страницы ASP.NET генерирует идентификатор сеанса размером 42 байта. Этот идентификатор сеанса включается в отклик сервера и является уникальным в пределах приложения. Если ни одна из страниц приложения, к которым обращается пользователь , не записывает в объект Session данные, то броузер не возвращает его в запросе серверу. Вместо этого сервер при каждом запросе генерирует новый идентификатор сеанса и включает его в отклик. Стоит только странице записать какие-нибудь данные в объект Session , идентификатор сеанса сразу запоминается броузером и начинается обратный процесс. Теперь уже броузер с каждым запросом начинает посылаться на сервер сохраненный идентификатор сеанса, даже если в дальнейшем мы полностью очистим объект Session .

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

Идентификатор сеанса может пересылаться серверу с запросом двумя способами:

  1. С помощью cookie -набора с именем ASP .NET_SessionId
  2. С помощью включения в URL для клиентов, не поддерживающих cookie -наборы (использование измененных URL — адресов)

Идентификатор сеанса можно получить как значение Response . Cookies [» ASP .NET_SessionID»] — при формировании первого отклика, или Session .SessionID — всегда. Но конкретное его значение нас, как правило, не интересует, поскольку процесс распознавания выполняется автоматически.

Данные сеанса могут сохраняться ASP.NET в одном из трех мест на сервере, определяемых свойством Mode объекта Session :

  1. В оперативной памяти сервера внутри процесса — текущего домена приложения (режим InProc — установлен по умолчанию)
  2. В оперативной памяти сервера вне процесса в специальной службе Windows под названием ASP.NET State Service (режим StateServer )
  3. Вне процесса на жестком диске в базе данных SQL Server (режим SQLServer )
Илон Маск рекомендует:  PHP скрипт комментариев + AJAX + JS + MYSQL + CSS

Состояние сеанса утрачивается в следующих случаях:

  1. Пользователь закрывает и вновь запускает броузер
  2. Пользователь получает доступ к приложению через другой броузер
  3. Из-за простоя сеанса больше определенного времени по причине отсутствия запросов от клиента (по умолчанию 20 минут)
  4. Программист завершает сеанс методом Session . Abandon ()
  5. Если сеанс создается внутри текущего домена, то при переходе приложения в новый домен сеанс будет потерян

Сеанс является экземпляром класса System.Web.SessionState.HttpSessionState и может частично управляться из кода. В таблице приведены некоторые свойства и методы класса HttpSessionState

Некоторые свойства и методы класса HttpSessionState
Член Описание
Count Количество элементов в коллекции текущего сеанса. Только для чтения
IsCookieless Булев флаг, показывающий способ хранения идентификатора сеанса: в куках или в модифицированном URL. Только для чтения
IsNewSession Булево значение, которое указывает, был ли сеанс создан с текущим запросом. Если коллекция пуста или сеанс создан ранее, то возвращается false. Только для чтения
Mode Свойство (только для чтения) содержит одно из значений перечисления SessionStateMode , указывающее способ хранения данных сеанса:
  • Off = 0 — сеанс не используется
  • InProc = 1 — данные сеанса хранятся в памяти домена
  • StateServer = 2 — сеанс хранится в специальной службе Windows под названием ASP.NET State Service
  • SQLServer = 3 — сеанс хранится в базе данных SQL Server
  • Custom = 4 — сеанс хранится на основе нестандартного поставщика
SessionID Строка, содержащая уникальный идентификатор сеанса. Только для чтения
Timeout Максимальный срок простоя сеанса в минутах. Для чтения и записи
Abandon () Отменяет текущий сеанс
Add(string name, object value) Добавляет новый элемент в коллекцию сеанса. Допускается альтернативный синтаксис в виде индексатора
Clear () Очищает коллекцию сеанса
RemoveAll() Очищает коллекцию сеанса
Remove (string name) Удаляет элемент данных из коллекции сеанса по ключевому имени
RemoveAt(int index) Удаляет элемент данных из коллекции сеанса по ключевому индексу

Начальное состояние сеанса устанавливается в конфигурационном файле web.config в секции . Настройки секции поддерживаются классом System.Web. Configuration .SessionStateSection через его свойства, но имена свойств в кофигурационном файле начинаются с символа нижнего регистра. Вот некоторые наиболее важные из них

Некоторые свойства SessionStateSection
Свойство Описание
Cookieless Задает режим использования cookie -набора для пересылки идентификатора сеанса. Определяется значениями перечисления System.Web.HttpCookieMode :
  • UseUri = 0 — никогда не использовать cookie -наборы, а включать идентификатор сеанса в URL (в файле web.config допускаются варианты синтаксиса: cookieless=»UseUri» или cookieless=»true» )
  • UseCookies = 1 — всегда использовать cookie -наборы, даже если броузер их не поддерживает или эта функциональность в нем отключена. Этот режим установлен по умолчанию. Для неподдерживающих cookie -наборы броузеров данные сеанса будут теряться, поскольку идентификатор сеанса возвращаться на сервер не будет
  • AutoDetect = 2 — наиболее надежный режим, в котором сервер сам определяет возможности броузера по поддержке куков и автоматически применяет нужной вариант пересылки идентификатора сеанса
  • UseDeviceProfile = 3 — способ пересылки идентификатора сеанса основывается только на потенциальной функциональности броузера по поддержке cookie -наборов, но без учета возможности фактического отключения этой функциональности пользователем
Mode Задает одно из значений перечисления SessionStateMode , указывающее способ хранения данных сеанса:
  • Off = 0 — указывает, что сеанс не задействуется для хранения данных . Такой режим может существенно увеличить быстродействие, когда необходимости в сеансе нет
  • InProc = 1 — данные сеанса хранятся в памяти домена
  • StateServer = 2 — сеанс хранится в специальной службе Windows под названием ASP.NET State Service
  • SQLServer = 3 — сеанс хранится в базе данных SQL Server
  • Custom = 4 — сеанс хранится на основе нестандартного поставщика
Timeout Устанавливают время простоя сеанса в минутах
RegenerateExpiredSessionId Булева переменная , запрещающая ASP.NET использовать поступивший от клиента идентификатор сеанса с просроченной меткой времени, а генерирующая новый. Это особенно важно при включенном режиме cookieless=»true» , когда идентификатор сеанса пересылается броузером в составе URL, куда его может специально встроить злонамеренный пользователь
CookieName Устанавливает имя идентификатора сеанса в cookie -наборе. По умолчанию используется имя » ASP .NET_SessionID»

При включенном режиме cookieless=»true» броузер автоматически встраивает идентификатор сеанса в URL всех относительных ссылок. Это же справедливо и при автоматической переадресации на новую страницу методом Response . Redirect («Относительный_адрес») с полным циклом. Для того, чтобы указать системе, что идентификатор сеанса должен передаваться секретным протоколом, нужно установить Response . Cookies [» ASP .NET_Session >

ASP.Net. Лекция 3. Серверные элементы управления (исходники, документация)

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

Формы применяются в большинстве сайтов. Например, если вы пишете письмо в веб-интерфейсе, появляется форма с текстовыми полями, соответствующими адресату, теме, и тексту письма. Нажатием на кнопку можно добавить прилагаемый файл и окончательно послать письмо кнопкой Send.

Форма HTML содержит теги, такие как текстовое поле, выпадающий список, переключатели (radiobuttons) и флажки (checkbox), кнопки.

Форма ASP.NET отличаются от обычных форм наличием свойства runat=»server». Они обрабатываются ASP.NET на сервере. Формы являются одним из полей страницы. На странице находятся элементы управления . Многие из них должны быть расположены внутри формы. ASP.NET позволяет запоминать состояние элементов управления, то есть текст, который был введен в текстовое поле, или выбранный переключатель, передавать его на сервер и обратно на страницу после ее обновления.

Все формы обрабатываются методом POST. Атрибут Action можно задавать, но не обязательно. По умолчанию это текущая страница.

У элементов управления ASP.NET. тоже имеется свойство runat=»server». Второй обязательный атрибут — это его идентификатор, или id. Он нужен, чтобы обращаться к элементу в программе, то есть это имя члена страницы, по которому мы можем его идентифицировать. Примеры мы уже видели в предыдущих лекциях.

Перечислим группы элементов управления.

Элементы управления HTML

Элементы управления HTML являются наследниками класса System.Web.UI.HtmlControls.HtmlControl. Они непосредственно отображаются в виде элементов разметки HTML. Их отображение не зависит от типа браузера. Свойства таких элементов полностью соответствуют атрибутам тегов HTML.

Сравните обычный тег

с элементом управления HTML

Разница заключается только в наличии атрибута =»server». Но он дает колоссальную разницу. Теги сервер отображает как есть, а элементом управления можно манипулировать в коде. Так можно написать в функции-методе страницы только во втором случае.

что равносильно this.Reset1.Value = «АСП»;

Следовательно, Reset1 становится одним из членов класса страницы.

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

Стандартные или серверные элементы управления

Серверные элементы мощнее, потому что они привязаны не к разметке, а к функциональности, которую нужно обеспечить. Многие элементы не имеют аналогов в HTML, например, календарь. Их отрисовка полностью контролируется ASP.NET. Перехватывая события PreRender, Init, Load, можно вмешаться в этот процесс. Объявления серверного элемента управления начинаются с блока и заканчиваются

Возможно также закрыть объявление тегом />, если внутри блока нет текста.

Свойства этих элементов строго типизированы в отличие от HTML-элементов.

В этой таблице приведены элементы управления, которые имеют пару среди тегов HTML. Вообще их гораздо больше. Некоторые элементы генерируют не только HTML-код, но и JavaScript. В ASP .NET 2.0 было добавлено множество новых сложных элементов управления, например, MultiView, TreeView, Wizard, GridView. Возможностей одного GridView хватит, чтобы написать целую статью.

Таблица соответствия некоторых серверных элементов управления web тегам HTML
Элемент управления ASP..NET Соответствующий тег HTML Назначение
Отобразить текст
, между которыми находятся один или несколько тегов .

DropDownList выдаст тот же самый код, если будет определен так:

Итак, если мы хотим перейти с написания страниц HTML к написанию кода asp:

Отличие серверных элементов управления в том, что их можно программировать на сервере, и получать информацию от них тоже на сервере.

Попробуем написать такую страницу:

Запустите ее на выполнение, выберите Компакт-диски и нажмите на кнопку. На форме появится надпись «Вы выбрали Компакт-диски».

Вот код этой страницы в браузере:

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

Посмотрим, как ASP .NET интерпретировал заголовок формы:

Событие SelectedIndexChanged имеется и тут, как и у всех классов-наследников от абстрактного класса ListControl.

Panel

Часто бывает нужно вставить элемент управления в точно определенное место страницы. Например, объединим два предыдущих примера.


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

Чтобы заставить метку отображаться перед списком, необходимо поместить перед DropDownList обьект Panel.

после чего вызывать метод Controls.Add(. ) от этого оьекта.

Свойство HorizontalAlign элемента Panel полезно, если нужно установить выравнивание содержащихся в нем элементов управления. Поменяем код в предыдущем примере:

Текст теперь размещается в центре метки.

Булевское свойство Wrap элемента Panel заставляет переносить текст на новую строку, есть установлено, или расширять раздел, если текст не помещается в одну строку, если не установлено.

Если в программе установить свойство Visible панели в False, можно сделать невидимыми все элементы, которые в нем находятся. Стили, установленные в панели, наследуются всеми вложенными элементами.

Новая возможность в ASP.NET 2.0 — задавать для Panel полосы прокрутки, как бы имитируя встроенное в страницу окно. Это делается с помощью свойства ScrollBars. Он может принимать следующие значения: None, Both, Vertical, Horizontal, Auto. Если вы установите его в Auto, полосы прокрутки появятся, если содержимое панели не умещается в его видимые размеры.

Реализуется такая возможность с помощью атрибута css overflow.

Ставить свойство ScrollBars в Vertical или Horizontal я вам не рекомендую. этом случае генерируется стиль overflow-x, а это не работает в браузере Opera 9.0. Стиль overflow не поддерживается Opera 6.

Вертикальную полосу прокрутки можно установить и слева. Для этого поменяйте свойство Direction в RightToLeft.

Для Panel можно задать фоновую картинку с помощью свойства BackImageUrl.

Заключение

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

Компоненты представления¶

Просмотрите или скачайте пример с GitHub `__.

Компоненты представления¶

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

  • Работает с частью, а не со всем ответом
  • Использует преимущества разделения ответственности и тестируемости, какие существуют между контроллером и представлением
  • Может содержать параметры и бизнес логику

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

  • меню с динамической навигацией
  • облако тэгов (с запросами к БД)
  • панель логина
  • корзина покупателя
  • недавно опубликованные статьи
  • контент сбоку в обычном блоге
  • панель логина, которая отображается на каждой странице и показывает ссылки для логаута или логина в зависимости от текущего статуса пользователя

Компонент представления состоит из двух частей: класса (обычно наследуется от ViewComponent ) и результата, который он возвращает (обычно представления). Как и контроллер, компонент представления может быть POCO, но большинство разработчиков предпочитают воспользоваться преимуществами методов и свойств, доступных при наследовании от ViewComponent .

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

В этом разделе рассказывается, как создать компонент представления. Далее мы рассмотрим каждый шаг и создадим компонент представления.

Класс компонента представления¶

Класс компонента представления может быть создан каким-либо из этих способов:

  • наследование от ViewComponent
  • когда классу добавляется атрибут [ViewComponent] или когда класс наследуется от класса с атрибутом [ViewComponent]
  • добавить в конце имени класса ViewComponent

Как и контроллеры, компоненты представления должны быть открытыми, не вложенными, не абстрактными классами. Имя компонента представления — это имя класса с удаленным суффиксом “ViewComponent”. Его также можно указать напрямую, используя свойство `ViewComponentAttribute.Name`__ .

Класс компонента представления:

  • полностью поддерживает конструктор DI
  • не принимает участия в жизненном цикле контроллера, то есть, вы не можете использовать фильтры

Методы компонента представления¶

Логика компонента представления определена в его методе InvokeAsync , который возвращает IViewComponentResult. Параметры передаются напрямую при вызове компонента представления, а не при связывании моделей. Компонент представления никогда напрямую не обрабатывает запрос. Обычно компонент представления инициализирует модель и передает ее представлению, вызывая метод View. Методы компонента представления:

  • определяют метод InvokeAsync` , который возвращает IViewComponentResult
  • обычно инициализируют модель и передают ее представлению, вызывая ViewComponentView
  • параметры передаются при вызове метода, не HTTP, здесь нет связывания моделей
  • не доступны напрямую в качестве конечной точки HTTP, они вызываются из кода (обычно в представлении). Компонент представления никогда не обрабатывает запрос

Путь поиска представления¶

Среда разработки ищет представление по следующим путям:

  • Views/ /Components/ /
  • Views/Shared/Components/ /

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

Мы рекомендуем называть файл представления Default.cshtml и использовать путь Views/Shared/Components/ / . Компонент представления « PriorityList«из данного примера использует Views/Shared/Components/PriorityList/Default.cshtml.

Вызов компонента представления¶

Чтобы использовать компонент представления, вызовите из представления @Component.InvokeAsync(«имя компонента представления», тип с параметрами>) . Параметры передаются методу InvokeAsync . Компонент представления PriorityList , используемый в этой статье, вызывается из файла Views/Todo/Index.cshtml. Далее метод InvokeAsync вызывается с двумя параметрами:

Вызов компонента представления напрямую из контроллера¶

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

В этом примере компонент представления вызывается напрямую из контроллера:

Создание простого компонента представления¶

Скачайте, соберите и протестируйте код. Это простой проект с контроллером Todo , который отображает список элементов Todo.

Добавление класса ViewComponent¶

Создайте папку ViewComponents и добавьте класс PriorityListViewComponent .

В коде обратите внимание на:

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

поскольку имя класса PriorityListViewComponent заканчивается на ViewComponent, при рантайме будет использоваться строка “PriorityList”. Позже мы это обсудим более детально.

атрибут [ViewComponent] может изменить имя, которое используется для ссылки на компонент представления. Например, мы могли бы назвать класс XYZ и применить атрибут ViewComponent :

Атрибут [ViewComponent] говорит селектору компонента представлений использовать имя PriorityList , когда он ищет представления, связанные с компонентом, и использовать строку “PriorityList” при ссылке на компонент класса из представления.

Компонент использует внедрение зависимостей для получения данных.

InvokeAsync представляет метод, который можно вызвать из представления, и он может принимать произвольное число аргументов.

Метод InvokeAsync возвращает набор “сырых” элементов ToDo , и их приоритет меньше или равен maxPriority .

Создание нового компонента представления Razor¶

  1. Создайте папку Views/Shared/Components. Эта папка должна быть названа Components.
  2. Создайте папку Views/Shared/Components/PriorityList. Имя этой папки должно соответствовать имени класса компонента представления или имени класса минус суффикс (если мы следовали соглашению и использовали суффикс ViewComponent в имени класса). Если вы использовали атрибут ViewComponent , имя класса должно соответствовать обозначению атрибута.
  3. Создайте Razor представление Views/Shared/Components/PriorityList/Default.cshtml.

Razor представление принимает список«TodoItem« и отображает его. Если метод InvokeAsync не передал имя представления (как в нашем примере), именем представления будет Default. Далее я покажу вам, как передать имя представления. Чтобы переопределить стилизацию для контроллера, нужно добавить в контроллер конкретную папку (например, Views/Todo/Components/PriorityList/Default.cshtml).

Если компонент представления предназначался для конкретного контроллера, вы можете добавить его в папку контроллера (Views/Todo/Components/PriorityList/Default.cshtml)

Добавьте div , содержащий вызов приоритетного списка компонентов, в начале файла Views/Todo/index.cshtml:

Разметка @Component.InvokeAsync показывает синтаксис для вызова компонентов представления. Первый аргумент — это имя компонента, который мы хотим вызвать. Последующие параметры передаются компоненту. InvokeAsync может принимать произвольное число аргументов.

На изображении снизу показан список приоритетных элементов:

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

Определение имени представления¶

При определенных условиях для сложного компонента представления нужно указать представление не по умолчанию. В следующем коде показано, как указать представление “PVC” из метода InvokeAsync . Обновите метод InvokeAsync в классе PriorityListViewComponent .

Скопируйте файл Views/Shared/Components/PriorityList/Default.cshtml в представление Views/Shared/Components/PriorityList/PVC.cshtml. Добавьте заголовок, чтобы указать используемое PVC представление.

Запустите приложение и проверьте PVC представление.

Если PVC представление не отображается, убедитесь, что вы вызываете компонент представления с приоритетом 4 или выше.

Изучение пути представления¶

Измените параметр приоритета на 3 или ниже, чтобы представление не возвращалось.

Временно переименуйте Views/Todo/Components/PriorityList/Default.cshtml в Temp.cshtml.

Протестируйте приложение, и вы увидите следующую ошибку:

Скопируйте Views/Shared/Components/PriorityList/Default.cshtml в *Views/Todo/Components/PriorityList/Default.cshtml. #. Добавьте в представление Todo разметку. #. Протестируйте non-shared.

Как избежать магических строк¶

Вы можете заменить жестко закодированное имя компонента представления именем класса. Создайте компонент представления без суффикса “ViewComponent”:

Добавьте выражение using в файл Razor представления и используйте оператор nameof :

Почему ASP.NET не используют в крупных компаниях?

В настоящий момент С# (asp.net) имеет целый ряд преимуществ над тем, что нам дает Java (в плане удобства и синтаксиса языка). Это правда!

Проблема заключается в том, что Java появился раньше, Java был открытым для использования на Linux. В итоге под сервера на Java написали огромный список уникальных решений, которые сейчас используют топовые команды (посмотри, что такое хадуп, например). В итоге, компании либо не видели смысла переписывать все на C#, так как уже имели билды на Java, либо не хотели тратить время на разработку того, что уже есть на Java.

Именно по этой причине Microsoft сейчас активно начинает спариваться с Linux и везде кричит, что они его любят.

Asp компонент status

Иногда возникает необходимость отправить в ответ на запрос какой-либо статусный код. Например, если пользователь пытается получить доступ к ресурсу, который недоступен или для которого у пользователя нету прав. Либо нам нужно просто уведомить браузер пользователя с помощью статусного кода об успешном выполнении операции, как иногда применяется в ajax-запросах. И фреймворк ASP.NET Core MVC предоставляет множество различных классов, которые можно использовать для отправки статусного кода.

StatusCodeResult

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

Для создания этого результата используется метод StatusCode() , в который передается отправляемый код статуса.

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

HttpNotFoundResult и HttpNotFoundObjectResult

NotFoundResult и NotFoundObjectResult посылает код 404, уведомляя браузер о том, что ресурс не найден. Второй класс в дополнении к статусному коду позволяет отправить доплнительную информацию, которая потом отобразится в браузере.

Объекты обоих классов создаются методом NotFound . Для первого класса — это метод без параметров, для второго класса — метод, который в качестве параметра принимает отправляемую информацию. Например, используем NotFoundObjectResult:

UnauthorizedResult

UnauthorizedResult посылает код 401, уведомляя пользователя, что он не автризован для доступа к ресурсу:

Для создания ответа используется метод Unauthorized() .

BadResult и BadObjectResult

BadResult и BadObjectResult посылают код 400, что говорит о том, что запрос некорректный. Второй класс в дополнении к статусному коду позволяет отправить доплнительную информацию, которая потом отобразится в браузере.

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

Объекты обоих классов создаются методом BadRequest . Для первого класса — это метод без параметров, для второго класса — метод, который в качестве параметра принимает отправляемую информацию:

OkResult и OkObjectResult

OkResult и OkObjectResult посылают код 200, уведомляя об успешном выполнении запроса. Второй класс в дополнении к статусному коду позволяет отправить доплнительную информацию, которая потом отобразится в браузере.

Объекты обоих классов создаются методом Ok() . Для первого класса — это метод без параметров, для второго класса — метод, который в качестве параметра принимает отправляемую информацию:

Компоненты представления¶

Просмотрите или скачайте пример с GitHub `__.

Компоненты представления¶

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

  • Работает с частью, а не со всем ответом
  • Использует преимущества разделения ответственности и тестируемости, какие существуют между контроллером и представлением
  • Может содержать параметры и бизнес логику

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

  • меню с динамической навигацией
  • облако тэгов (с запросами к БД)
  • панель логина
  • корзина покупателя
  • недавно опубликованные статьи
  • контент сбоку в обычном блоге
  • панель логина, которая отображается на каждой странице и показывает ссылки для логаута или логина в зависимости от текущего статуса пользователя

Компонент представления состоит из двух частей: класса (обычно наследуется от ViewComponent ) и результата, который он возвращает (обычно представления). Как и контроллер, компонент представления может быть POCO, но большинство разработчиков предпочитают воспользоваться преимуществами методов и свойств, доступных при наследовании от ViewComponent .

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

В этом разделе рассказывается, как создать компонент представления. Далее мы рассмотрим каждый шаг и создадим компонент представления.

Класс компонента представления¶

Класс компонента представления может быть создан каким-либо из этих способов:

  • наследование от ViewComponent
  • когда классу добавляется атрибут [ViewComponent] или когда класс наследуется от класса с атрибутом [ViewComponent]
  • добавить в конце имени класса ViewComponent


Как и контроллеры, компоненты представления должны быть открытыми, не вложенными, не абстрактными классами. Имя компонента представления — это имя класса с удаленным суффиксом “ViewComponent”. Его также можно указать напрямую, используя свойство `ViewComponentAttribute.Name`__ .

Класс компонента представления:

  • полностью поддерживает конструктор DI
  • не принимает участия в жизненном цикле контроллера, то есть, вы не можете использовать фильтры

Методы компонента представления¶

Логика компонента представления определена в его методе InvokeAsync , который возвращает IViewComponentResult. Параметры передаются напрямую при вызове компонента представления, а не при связывании моделей. Компонент представления никогда напрямую не обрабатывает запрос. Обычно компонент представления инициализирует модель и передает ее представлению, вызывая метод View. Методы компонента представления:

  • определяют метод InvokeAsync` , который возвращает IViewComponentResult
  • обычно инициализируют модель и передают ее представлению, вызывая ViewComponentView
  • параметры передаются при вызове метода, не HTTP, здесь нет связывания моделей
  • не доступны напрямую в качестве конечной точки HTTP, они вызываются из кода (обычно в представлении). Компонент представления никогда не обрабатывает запрос

Путь поиска представления¶

Среда разработки ищет представление по следующим путям:

  • Views/ /Components/ /
  • Views/Shared/Components/ /

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

Мы рекомендуем называть файл представления Default.cshtml и использовать путь Views/Shared/Components/ / . Компонент представления « PriorityList«из данного примера использует Views/Shared/Components/PriorityList/Default.cshtml.

Вызов компонента представления¶

Чтобы использовать компонент представления, вызовите из представления @Component.InvokeAsync(«имя компонента представления», тип с параметрами>) . Параметры передаются методу InvokeAsync . Компонент представления PriorityList , используемый в этой статье, вызывается из файла Views/Todo/Index.cshtml. Далее метод InvokeAsync вызывается с двумя параметрами:

Вызов компонента представления напрямую из контроллера¶

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

В этом примере компонент представления вызывается напрямую из контроллера:

Создание простого компонента представления¶

Скачайте, соберите и протестируйте код. Это простой проект с контроллером Todo , который отображает список элементов Todo.

Добавление класса ViewComponent¶

Создайте папку ViewComponents и добавьте класс PriorityListViewComponent .

В коде обратите внимание на:

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

поскольку имя класса PriorityListViewComponent заканчивается на ViewComponent, при рантайме будет использоваться строка “PriorityList”. Позже мы это обсудим более детально.

атрибут [ViewComponent] может изменить имя, которое используется для ссылки на компонент представления. Например, мы могли бы назвать класс XYZ и применить атрибут ViewComponent :

Атрибут [ViewComponent] говорит селектору компонента представлений использовать имя PriorityList , когда он ищет представления, связанные с компонентом, и использовать строку “PriorityList” при ссылке на компонент класса из представления.

Компонент использует внедрение зависимостей для получения данных.

InvokeAsync представляет метод, который можно вызвать из представления, и он может принимать произвольное число аргументов.

Метод InvokeAsync возвращает набор “сырых” элементов ToDo , и их приоритет меньше или равен maxPriority .

Создание нового компонента представления Razor¶

  1. Создайте папку Views/Shared/Components. Эта папка должна быть названа Components.
  2. Создайте папку Views/Shared/Components/PriorityList. Имя этой папки должно соответствовать имени класса компонента представления или имени класса минус суффикс (если мы следовали соглашению и использовали суффикс ViewComponent в имени класса). Если вы использовали атрибут ViewComponent , имя класса должно соответствовать обозначению атрибута.
  3. Создайте Razor представление Views/Shared/Components/PriorityList/Default.cshtml.

Razor представление принимает список«TodoItem« и отображает его. Если метод InvokeAsync не передал имя представления (как в нашем примере), именем представления будет Default. Далее я покажу вам, как передать имя представления. Чтобы переопределить стилизацию для контроллера, нужно добавить в контроллер конкретную папку (например, Views/Todo/Components/PriorityList/Default.cshtml).

Если компонент представления предназначался для конкретного контроллера, вы можете добавить его в папку контроллера (Views/Todo/Components/PriorityList/Default.cshtml)

Добавьте div , содержащий вызов приоритетного списка компонентов, в начале файла Views/Todo/index.cshtml:

Разметка @Component.InvokeAsync показывает синтаксис для вызова компонентов представления. Первый аргумент — это имя компонента, который мы хотим вызвать. Последующие параметры передаются компоненту. InvokeAsync может принимать произвольное число аргументов.

На изображении снизу показан список приоритетных элементов:

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

Определение имени представления¶

При определенных условиях для сложного компонента представления нужно указать представление не по умолчанию. В следующем коде показано, как указать представление “PVC” из метода InvokeAsync . Обновите метод InvokeAsync в классе PriorityListViewComponent .

Скопируйте файл Views/Shared/Components/PriorityList/Default.cshtml в представление Views/Shared/Components/PriorityList/PVC.cshtml. Добавьте заголовок, чтобы указать используемое PVC представление.

Запустите приложение и проверьте PVC представление.

Если PVC представление не отображается, убедитесь, что вы вызываете компонент представления с приоритетом 4 или выше.

Изучение пути представления¶

Измените параметр приоритета на 3 или ниже, чтобы представление не возвращалось.

Временно переименуйте Views/Todo/Components/PriorityList/Default.cshtml в Temp.cshtml.

Протестируйте приложение, и вы увидите следующую ошибку:

Скопируйте Views/Shared/Components/PriorityList/Default.cshtml в *Views/Todo/Components/PriorityList/Default.cshtml. #. Добавьте в представление Todo разметку. #. Протестируйте non-shared.

Как избежать магических строк¶

Вы можете заменить жестко закодированное имя компонента представления именем класса. Создайте компонент представления без суффикса “ViewComponent”:

Добавьте выражение using в файл Razor представления и используйте оператор nameof :

Как вернуть коды состояния HTTP для ошибок из компонента Asp.Net Core View

2 OjM [2020-11-29 08:52:00]

Я пытаюсь вернуть результат HTTP 500 или BadRequest() из моего компонента View в Asp.Net Core, однако этот тип возврата не представляется доступным для компонентов View. Должны ли типы возврата кода статуса быть доступными для компонентов View или у меня был неправильный дизайн?

Я вызываю свое действие контроллера через ajax, как показано ниже.

Мое действие контроллера вызывает/возвращает мой компонент View в соответствии с ниже.

Мой компонент ClientVisit View имеет следующее.

Когда моя model = await visitAPI.GetVisit(clientID, visitID) вызова базы данных model = await visitAPI.GetVisit(clientID, visitID) терпит неудачу, я хочу вернуть return StatusCode(500, ex.ToString()) но он недоступен, поэтому мой вызов ajax считает мой запрос успешным, что неверно.

c# asp.net-core asp.net-core-viewcomponent

3 ответа

Компонент представления никогда не обрабатывает запрос,

методы просмотра компонентов перегружены в сигнатуре, а не какие-либо детали из текущего HTTP-запроса,

Поэтому, насколько я понимаю, вы не сможете создать HTTP-ответ (например, как StatusCode() или BasRequest() ) внутри вашего компонента View.

Кроме того, вы можете получить доступ к HttpContext.Response.StatusCode , но это также не будет работать так, как вы хотите.

Кроме того, вы не можете вернуть null из View Components — вы увидите исключение:

Из-за выше, я понятия не имею, как вернуть код состояния из View Component.

Возможно, вы можете преобразовать View Component в простой метод «helper», чтобы вы могли поймать исключение в действии, а затем вернуть StatusCode(500) как хотите?

1 Tim Abell [2020-08-30 17:43:00]

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

Компоненты просмотра не используют привязку к модели и зависят только от данных, предоставляемых при вызове.

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

Так что-то вроде этого для вашего примера:

Пока у вас есть HttpResponse в доступе, он должен работать. В качестве альтернативы, из-за возврата проверки предварительных условий ViewComponent, установите статус.

Библиотека Интернет Индустрии I2R.ru

Малобюджетные сайты.

Продвижение веб-сайта.

Контент и авторское право.

Компоненты ASP. Службы COM+ в ASP-компонентах и ASP-приложениях

Создавать и успешно использовать ASP-компоненты можно и без прямого обращения к каким-либо службам COM+. Однако именно эти службы могут внести ту «изюминку», которая превратит просто удовлетворительно работающее ASP-приложение в хорошо масштабируемое и соответствующее предъявляемым ему требованиям, независимо от того, каковы эти требования.

Службы COM+, к которым, прежде всего, стоит обратиться в разработке ASP-компонентов, — это управление транзакциями (transaction management), активация по требованию (just-in-time activation, JIT) и резервирование (pooling). Кроме того, можно использовать новые интерфейсы, которые были созданы для поддержания большей части возможностей этих служб. Однако перед рассмотрением всех этих новшеств обратимся к применению компонентов в приложениях.

Разработка систем на основе компонентов

Именно система, построенная на основе компонентов, выделяет индивидуальные процессы в многократно используемые порции кода и данных, а затем использует один или несколько этих компонентов для сознания полноценных приложений. Среди нескольких типов приложений различают клиент-серверную (client/server), распределенную (distributed) и многоярусную (n-tier) системы. В клиент-серверной системе (client-server system) процессы распределяются между клиентом и сервером, причем клиент отвечает за все взаимодействия с пользователем, отображение данных и подтверждение полномочий клиента, а сервер обрабатывает большую часть обращений к базам данных, проверяет полномочия сервера и контролирует бизнес-правила. В распределенной системе (distributed system) компоненты приложений могут располагаться на разных машинах и географически находиться в разных местах. Кроме того, для обработки множественных запросов может быть создано несколько экземпляров одного и того же компонента, таким образом, появляется возможность предоставлять одну и ту же услугу сразу множеству клиентов. И наконец, многослойная система (n-tier system) объединяет в себе элементы как клиент-серверной, так и распределенной систем. Здесь, как и в клиент-серверной системе, присутствует иерархия компонентов, однако сами по себе компоненты могут дублироваться для распределения загрузки процессов, а также распределяться на большом количестве машин и мест, как это происходит в распределенной системе. Стандартная n-ярусная система может состоять из клиента, выполняющего все взаимодействия с пользователем, проверку полномочий клиента и отображение данных; бизнес-уровня, контролирующего бизнес-правила, общие вопросы управления транзакциями и проверку полномочий, и уровня данных, обрабатывающего все прямые обращения к данным.

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

Другим преимуществом компонентов является тот факт, что гораздо больше родовых функций (generic functions) может быть разделено на отдельные компоненты и, таким образом, использовано во всей системе. Кроме того, применение компонентов упрощает модель и конструкцию n-ярусной системы. В качестве примера можно привести систему, в которой интерфейсный компонент проверяет достоверность адресной информации. Проверка достоверности достаточно характерна: она просто подтверждает тот факт, что все необходимые поля, такие как «Город» или «Почтовый индекс», заполнены. Тогда бизнес-уровень сможет обрабатывать для приложения адресную информацию, исходя из типа бизнеса. На основе адресной информации бизнес-уровень может вести поиск, например, зон отгрузки для компонента с помощью соответствующего приложения или зон доставки для виртуальной системы заказов. Компонент может обратиться к уровню данных для сохранения адресной информации, извлечения дополнительной информации или даже для запуска других виртуальных бизнес-компонентов, выполняющих какую-либо еще обработку информации. Уровень данных сам по себе может быть разделен по отдельным машинам, отдельным базам данных или даже различным типам хранилищ данных, вместе с некоторой информацией, идущей на долговременное или кратковременное хранение (если информация может потребоваться лишь в некоторой специфической задаче, а затем должна быть удалена).

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

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

В Windows 2000 работа с компонентами существенно облегчается службами COM+, выполняющими для компонентов такие действия, как например резервирование и транзакции. Именно для реализации этих задач традиционные интерфейсы COM были дополнены совершенно новыми интерфейсами, о которых вы узнаете в следующем разделе.

Интерфейсы COM+

Большинство важнейших интерфейсов COM, таких как, например, IUnknown и IDispatch, с появлением среды COM+ не претерпело каких-либо изменений и по сию пору решает все те же знакомые нам задачи. Главное отличие между COM и COM+ состоит в том, что та функциональность, которая в Windows NT и Windows 98 выполнялась средствами MTS, нынче полностью интегрирована в архитектуру COM+. Такого рода интеграция не только принесла с собой новые возможности, предоставляемые службами COM+, но и позволила существенно улучшить характеристики компонентов.

Разумеется, разработчики COM+ не забыли о необходимости поддержки новых служб COM+, а также нескольких новых интерфейсов уже имеющимися средствами, реализованными в MTS. В следующих нескольких разделах нами будут рассмотрены несколько ключевых интерфейсов, без знания которых, как нам кажется, разработка ASP-компонентов была бы бессмысленна.

Интерфейс IObjectContext

В главе 4 мы обсуждали концепцию контекстов (contexts) как совокупностей объектов, отвечающих одинаковыми требованиями. Среди таких требований может быть, например, возможность резервирования (pooling) для компонентов или их совместное участие в транзакциях.

В Windows 2000 контекст компонентов представляет собой набор свойств времени выполнения (runtime properties), непосредственная работа с которым может вестись с помощью объекта ObjectContext, управляющего контекстной информацией для компонента. Для доступа к свойствам объекта ObjectContext используется интерфейс IObjectContext, доступный, в свою очередь, с помощью библиотеки типов служб COM+.

Ответ на вопрос о том, каким именно образом осуществляется доступ к объекту ObjectContext, зависит от того, каким языком программирования вы пользуетесь. Например, если взять Visual Basic, то здесь сначала производится импорт ссылки на библиотеку типов служб COM+ в рабочий проект, и только потом можно создать ссылку на объект ObjectContext и вызвать для создания экземпляра метод GetObjectContext:

Dim objContext As ObjectContext
Set objContext = GetObjectContext

В Visual С++ под Windows NT для доступа к объекту ObjectContext также можно применить метод GetObjectContext:

CComPtr m_spObjectContext;
hr = GetObjectContext(&m_spObjectContext);

В то же время, в Visual C++ под Windows 2000 для передачи интерфейсу идентификатора GUID уже используется метод CoGetObjectContext:

hr = CoGetObjectContext(IID_IObjectContextInfo,
(void **)&m_spObjectContext);

Независимо от того, применяется ли метод GetObjectContext или метод CoGetObjectContext, результаты будут одними и теми же, поскольку вызов метода CoGetObjectContext в COM+ является оболочкой для вызова метода GetObjectContext. В Visual С++ придется также добавить в путь библиотеки компонента ссылку на заголовочный файл comsvcs.h служб COM+ и ссылку на файл связанного объекта comsvcs.lib.

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

табл. 1. Методы интерфейса IObjectContext

Метод Описание
CreateInstance Создает экземпляр объекта
DisableCommit Показывает, что компонент не готов к выполнению транзакции
EnableCommit Показывает, что компонент все еще обрабатывается, но транзакция может быть выполнена
IsCallerInRole Показывает, соответствует ли вызывающий определенной роли (с учетом ролевой безопасности)
IsInTransaction Показывает, участвует ли компонент в транзакции
IsSecurityEnabled Показывает, включена ли защита
SetAbort Показывает, что компонент завершил работу и транзакция прервана
SetComplete Показывает, что компонент завершил работу и транзакция готова к принятию

Интерфейс обладает следующими свойствами:

  • ContextInfo — возвращает ссылку на объект контекстной информации, связанный с компонентом;
  • Count — показывает число именованных свойств объекта;
  • Item — содержит имена свойств;
  • Security — возвращает ссылку на объект Security, связанный с объектом ObjectContext.

Интерфейс информации контекста IObjectContextInfo более подробно будет рассмотрен в следующем разделе. Для обращения к встроенным ASP-объектам применяется коллекция Item. Получить доступ к ней можно непосредственно из Visual Basic:

Dim oc As ObjectContext
Dim app As Application
Set oc = GetObjectConext
Set app = oc.Item(«Application»)

Получить доступ к ASP-объектам можно и через объект ObjectContext:

Set app = oc(«Application»)

Из других программных языков для обращения к объектам ASP придется применить другие технологии. В C++, например, для получения доступа к определенному ASP-объекту нужно послать запрос экземпляру интерфейса IGetContextProperties:

CComPtr pProps; //свойства контекста

//получение ObjectContext
hr = CoGetObjectContext(IID_IObjectContext,
(void **)&m_spObjectContext);
if (FAILED(hr)) return hr;

//получение свойств контекста
hr = m_spObjectContext ->
QueryInterface( IID_IGetContextProperties,
(void**)&pProps );
if (FAILED(hr)) return hr;

получение свойства Response
bstrProp = «Response»;
hr = pProps->GetProperty( bstrProp, &vt ) ;
if (FAILED(hr)) return hr;

p > hr = piDispatch->QueryInterface( IID_IResponse,
(void**)&m_piResponse );

В документации к интерфейсу IGetContextProperties сообщается, что он действует только в среде Windows NT, но и в Windows 2000 с его помощью также можно обращаться к встроенным ASP-объектам.

Интерфейс IObjectContextInfo


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

табл. 2. Методы интерфейса IObjectContextInfo

Метод Описание
GetActivityId Возвращает идентификатор текущей активности
GetContextId Возвращает идентификатор текущего контекста
GetTransaction Возвращает указатель на интерфейс ITransaction
GetTransactionId Возвращает идентификатор текущей транзакции
IsInTransaction Показывает, участвует ли компонент в транзакции

Если в компонентах COM+ осуществляется синхронизация (описываемая позже), метод GetActivityId возвращает идентификатор текущей активности, в противном случае будет возвращено значение Null.

Метод GetTransaction возвращает указатель на интерфейс ITransaction. С помощью этого интерфейса можно принять или прервать транзакцию, хотя реализуются эти функции с помощью объекта ObjectContext или интерфейса IContextState, рассматриваемых далее.

Интерфейс IContextState

Интерфейс IContextState предоставляет возможность более четкого управления транзакциями и активацией, чем это допустимо в интерфейсе IObjectContext. Например, в интерфейсе IObjectContext с помощью метода SetComplete можно отметить компонент, как завершивший работу и ожидающий принятия транзакции, а с помощью метода SetAbort отметить его как завершивший работу и ожидающий прерывания текущей транзакции.

На практике есть два условных бита, устанавливаемых при работе с методами SetComplete и SetAbort. Первый из их — бит завершения (done bit), его установка указывает COM+, что обработка компонента завершена. Второй — бит согласованности (consistency bit). Установка этого бита определяет, может ли быть транзакция принята или она должна быть прервана.

Оба метода, SetComplete и SetAbort, интерфейса IObjectContext одновременно устанавливают оба бита, причем оба устанавливают бит завершения в значение True, указывая, что обработка компонента завершена. В то же время, с помощью интерфейса IContextState можно идентифицировать факт окончания работы компонента отдельно от статуса транзакции.

В табл. 3 приведены четыре метода интерфейса IContextState.

табл. 3. Методы интерфейса IContextState

Метод Описание
GetDeactivateOnReturn Получает состояние бита завершения
GetMyTransactionVote Получает состояние бита согласованности
SetDeactivateOnReturn Сигнализирует о завершении работы компонента
SetMyTransactionVote Идентифицирует возможность принятия либо прерывания транзакции

Бит завершения можно получать и устанавливать с помощью методов SetDeactivateOnReturn и GetDeactivateOnReturn. Компонент деактивируется по завершении методов только при значении бита завершения, установленном в True.

Чтобы убедиться во всех этих возможностях, создайте компонент Visual Basic, реализующий для перехвата событий JIT интерфейс IObjectControl. (Интерфейс IObjectControl подробно описывается в следующем разделе.) У этого метода будет два компонента, каждый из которых вызывает метод SetDeactivateOnReturn интерфейса IContextState. Первая функция будет вызывать метод, передавая логическое значение False, вторая — True.

Создайте проект Visual Basic и назовите его asp0501, а класс генерируемого компонента — done. Присоедините к проекту библиотеки типов служб COM+ и Microsoft Active Server Pages. Коль скоро библиотеки типов добавлены как ресурсы, реализуйте, как показано в листинге 5.1, JIT-методы Activate, Deactivate и CanBePooled интерфейса IObjectControl.

Листинг 1. Реализация JIT-функций интерфейса IObjectControl

Dim objResponse As Response

Private Sub ObjectControl_Activate()
Set objResponse = GetObjectContext().Item(«Response»)
objResponse.Write «

Активирован

Private Sub ObjectControl_Deactivate()
objResponse.Write «

Деактивирован

Private Function ObjectControl_CanBePooled() As Boolean
ObjectControl_CanBePooled = False
End Function

В методе Activate созданная ссылка на встроенный ASP-объект Response используется для отображения сообщения о том, что метод активирован. В методе Deactivate на web-страницу выводится сообщение о том, что компонент деактивирован.

Далее, добавьте две функции компонента, вызываемые ASP-страницей. Первая, под именем function1, обращается к интерфейсу IContextState и вызывает его метод SetDeactivateOnReturn, передавая значение False. Вторая функция, function2, также вызывает метод SetDeactivateOnReturn, но на сей раз передается значение True. В листинге 5.2 приведен программный код обеих функций, который и нужно добавить к нашему компоненту.

Листинг 2. Подпрограммы, вызывающие метод SetDeactivateOnReturn

Dim iCntxt As IContextState
Set iCntxt = GetObjectContext

iCntxt.SetDeactivateOnReturn False
End Sub

Dim iCntxt As IContextState
Set iCntxt = GetObjectContext

iCntxt.SetDeactivateOnReturn True
End Sub

После того как проект компонента скомпилирован и добавлен к приложению COM+, протестируйте новый компонент с помощью ASP-сценария примерно такого содержания (как в странице asp0501.asp):

Первой вызывается функция function2, деактивирующая компонент при возвращении значения функцией. Благодаря этому при обращении к функции компонента будет отображаться сообщение «Активирован», а при возвращении функцией значения будет отображаться сообщение «Деактивирован» еще до сообщения «Вызов function 1».

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

Наконец, при повторном вызове функции function2, должны быть отображены оба сообщения, «Активирован» и «Деактивирован», при этом генерируется web-страница со следующими сообщениями:

Вызов function 2

Вызов function 1

Вызов function 2

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

Интерфейс IObjectControl

В этом разделе показано, как можно управлять временем жизни (lifetime) компонента с помощью интерфейса IContextState. В примере также используется активация по требованию (just-in-time activation, JIT) — для управления созданием экземпляра компонента и записи на web-страницу с помощью методов Activate и Deactivate интерфейса IObjectControl сообщений об активации и деактивации компонента.

Разрешение активации по требованию компонента означает, что компонент активируется, только когда он реально требуется, а не при первоначальном создании на ASP-странице. Кроме того, компонент деактивируется, только когда он помечается как готовый к деактивации, удаляется внутри ASP-страницы (например, установлен в Nothing, если вы работаете с VBScript) или процесс выходит за пределы страницы.

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

Как разработчик компонента, вы можете перехватывать моменты активации и деактивации компонента путем реализации методов Activate и Deactivate интерфейса IObjectControl. В этом случае вы не зависите от ресурсов (типа ссылки на объект Response в листинге 5.1) в период простоя компонента и ожидания вызова его методов.

При реализации интерфейса IObjectControl вы должны реализовать и методы Activate и Deactivate — а кроме того, еще и метод CanBePooled. Этот последний метод определяет, находится ли компонент в состоянии, когда он может быть резервирован (pooled). Позднее в этой главе при описании служб COM+ мы рассмотрим резервирование (pooling) компонентов более подробно.

Чтобы воспользоваться преимуществами активации по требованию, компонент должен быть установлен в приложение COM+, а активация по требованию разрешена. Впрочем, поддержка активации по требованию в приложении COM+ для всех компонентов включена по умолчанию.

Интерфейсы IObjectControl и IObjectContext были реализованы в Windows NT и управляются посредством MTS. Фактически же, ASP-компоненты, созданные для Windows NT, за исключением использующих специфические службы NT, можно без проблем перенести на Windows 2000 и COM+, что и обсуждается в следующем разделе.

ПРИМЕЧАНИЕ
В Windows NT приходилось избегать применения обработчиков событий Initialize и Terminate, поскольку они не позволяли обратиться к экземпляру объекта ObjectContext. Это ограничение в Windows 2000 снято. И все же, по-прежнему важно рассмотреть реализацию интерфейса IObjectControl и перехват (trapping) событий Activate и Deactivate для обеспечения доступа к глобальным ресурсам и их высвобождения.

Перенос пакетов MTS в приложения COM+

В Windows NT (or Windows 9x) компонентами можно было управлять как частью пакетов (packages) MTS. Будучи частью пакета MTS, компонент мог воспользоваться некоторыми возможностями MTS, например, выполнением транзакций и активацией по требованию. Те же и многие другие возможности доступны также и в COM+, и обратиться к ним из существующих компонентов можно, перенеся в новую среду пакеты MTS, компоненты или то и другое.

Для переноса существующего пакета MTS нужно, прежде всего, экспортировать пакет в файл с расширением .pak (файл пакета MTS). Это можно сделать, щелкнув правой кнопкой мыши на существующем приложении MTS и выбрав в меню команду Export (Экспорт). Далее нужно просто следовать указаниям по экспорту в файл пакета MTS, решив, в том числе, вопрос об экспорте ролей вместе с пакетом.

Можно относительно просто перенести пакеты MTS в COM+, создав с помощью консоли служб компонентов (Component Services Console) новое приложение COM+ и установив переключатель Install Pre-built Application(s) (Установить готовое приложение). Когда мастер установки приложения COM (COM Application Install Wizard) запросит имя существующего приложения, найдите или выберите созданный ранее PAK-файл.

При импорте существующего пакета MTS в новое приложение COM+ диспетчер служб компонентов (Component Services Manager) импортирует также роли (roles) и пытается сопоставить существующую функциональность MTS новой функциональности служб COM+ — включая настройки транзакций и активации по требованию.

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

В следующем разделе обсуждаются некоторые настройки приложений COM+, влияющие на ASP-приложения.

СОВЕТ
За дополнительной информацией о работе с консолью служб компонентов (Component Services Console) обратитесь к справочной системе Windows 2000.

Активация приложений COM+

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

ПРИМЕЧАНИЕ
В этом разделе рассмотрены не все возможные службы COM+, а лишь самые необходимые для разработки ASP-компонентов, например, безопасность, транзакции и объединение объектов. Активация по требованию подробно рассмотрена в разделе «Интерфейс IObjectControl».

Управлять безопасностью ASP-приложения на уровне страницы или ресурса можно с помощью средств безопасности NTFS или средств безопасности IIS. С помощью средств ролевой безопасности приложений COM+ можно добавить и еще один уровень безопасности.

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

Приложение COM+ можно создать по двум различным схемам активации: активации внутри клиентского процесса и активации в изолированном процессе.

Если приложение COM+ создано как серверное, обращение к компоненту с ASP-страницы генерирует отдельную программу dllhost.exe для этого компонента и любого другого, являющегося частью приложения COM+. Поскольку компонент находится в отдельном процессе, все вызовы компонента с ASP-страницы должны маршализироваться. Вместе с тем, если компонент некачественный и генерирует нечто опасное для программного обеспечения, это нечто останется внутри файла dllhost.exe и не сможет неблагоприятно повлиять на IIS или остальные ASP-приложения.

Если создать приложение COM+ как библиотечное, при обращении к компоненту с ASP-страницы экземпляр этого компонента (и любого другого внутри приложения COM+) создается внутри того же процесса, что и ASP-страница — если только поточная модель компонента совместима. Поскольку приложения COM+ допускают апартаментно-поточную, произвольно-поточную и нейтрально-поточную модели, экземпляр компонента приложения COM+ должен создаваться внутри процесса ASP-страницы, а все вызовы между сценарием страницы и компонентом должны выполняться в том же потоке.

Службы COM+

Компонент, с помощью диспетчера служб COM+ (COM+ Services Manager) установленный как часть приложения COM+, называется сконфигурированным компонентом (configured component). Такой компонент может воспользоваться преимуществами служб COM+, например, поддержкой транзакций и активацией по требованию. Компонент, не установленный как часть приложения COM+ и зарегистрированный с помощью инструментов разработки (например, VB) или утилиты regsvr32.exe, называется несконфигурированным компонентом (unconfigured component). Этот тип компонента использовать в ASP-приложениях можно, но реализовать интерфейс IObjectControl, воспользоваться преимуществами активации по требованию или применить объект ObjectContext для поддержки транзакций нельзя. Можно, однако, как и прежде, обратиться с помощью объекта ObjectContext к встроенным объектам ASP.

Одним из основных доводов в пользу добавления компонента в приложение COM+ является желание применить компонент в транзакциях. Это момент обсуждается в следующем разделе.

Поддержка транзакций

Одна из проблем при работе с компонентами, построенными на основе технологий COM/DCOM, состоит в том, что связь компонентов, особенно удаленная связь, весьма непроста. Выяснение того, успешно ли завершена обработка компонента, что делать дальше и как восстановить задачу, если один из компонентов не смог ее выполнить, а остальные — смогли, может превратить распределенную систему в плохо реализуемую и трудно управляемую.

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

Кроме того, MTS предоставляет менеджеров (managers) и диспетчеров (dispensers) ресурсов, которые управляют данными хранилищ, например, данными баз данных. По сути, любая система баз данных, поддерживающая транзакции OLE, скажем, SQL Server, может участвовать в транзакциях, управляемых MTS. Это означает, что если компонент, участвующий в транзакции, выполняется с ошибкой, то можно отозвать (вернуть к прежнему состоянию) не только его действия и действия других компонентов, но и любое действие, произведенное базой данных.

Все возможности MTS по работе с транзакциями реализованы в службах COM+ и доступны для сконфигурированных компонентов. Отличие состоит в том, что в COM+ (и Windows 2000) присутствует интерфейс IContextState, позволяющий отделить активацию компонента от управления транзакциями. Этот интерфейс способен сигнализировать, собирается ли компонент принять или прервать транзакцию, при этом компонент остается активированным, как было ранее показано в листинге 5.1.

Что такое транзакции?

Если вы имели опыт работы с коммерческими базами данных, например, с Oracle, Sybase и Microsoft SQL Server, то, возможно, знаете, что представляют собой транзакции. Транзакция (transaction) — это одна или несколько задач, некоторым образом логически сгруппированных, причем все задачи, объединенные в данную группу, либо все вместе успешно завершаются, либо все вместе не выполняются, если хотя бы одна из задач внутри транзакции не выполнена. Если транзакция не состоялась, никаких изменений данных, связанных с данной транзакцией, не делается. Если же выполнение транзакции происходит успешно, все изменения данных принимаются. В качестве примера транзакции с несколькими задачами можно привести перевод денег со сберегательного на расчетный счет. Хотя это и похоже на одну транзакцию, в действительности, происходят сразу две транзакции. Первая транзакция состоит в снятии ваших денег со сберегательного счета (то есть они дебетуются на счет), вторая транзакция заключается в переведении этих денег на расчетный счет (то есть они кредитуются на расчетный счет) . Если операция снятия денег со сберегательного счета прошла успешно, а операция по переводу денег на расчетный счет не была выполнена, вы, весьма вероятно, захотите, чтобы целиком вся транзакция была отозвана и начата заново. Транзакции очень существенны для систем, обновляющих несколько структур данных, например, баз данных. Такие обновления, даже основанные на одной операции, должны быть успешно завершены сразу для всех структур данных, именно для того, чтобы обеспечить успешное завершение одной этой операции.

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

Участие компонентов в транзакциях

Компонент может воспользоваться возможностями транзакций COM+, если он удовлетворяет следующим условиям. Во-первых, компонент должен быть внутрипроцессным сервером (то есть DLL). Во-вторых, он не должен быть свободно-поточным. Далее, если компонент создан в Visual С++, он должен реализовать фабрику классов (class factory) и использовать стандартную маршализацию. Кроме того, для компонента нужно будет создать библиотеку типов.

Если компонент удовлетворяет минимальным требованиям, чтобы получить поддержку транзакций, он должен быть зарегистрирован в COM+. В процессе регистрации тип транзакции, в которой участвует компонент, устанавливается в качестве свойства компонента. Например, на рис. 3 показано окно свойств компонента, для которого требуется транзакция, время ожидания завершения которой определено в 10 секунд.

Чтобы начать транзакцию на ASP-странице, поместите первой строкой страницы следующую директиву:

Для работы с транзакциями компонент должен ссылаться на экземпляр объекта ObjectContext (или интерфейса IObjectContext) или экземпляр интерфейса IContextState. Пометить компонент как готовый к принятию транзакции можно с помощью метода SetComplete объекта ObjectContext или метода SetMyTransactionVote интерфейса IContextState:

Пометить транзакцию для отзыва можно с помощью тех же интерфейсов:

Транзакции COM+ в действии показаны в примерах главы 9, посвященной созданию ASP-компонентов промежуточного слоя с помощью ADO. В этих примерах транзакции выполняются для обновления баз данных — и это их традиционное применение. Транзакции с базами данных можно выполнять непосредственно (не прибегая к транзакциям COM+) с помощью объекта ADO Connection. Тем не менее, примеры этой главы продемонстрируют, что гораздо удобней наладить взаимодействие компонентов и баз данных посредством транзакций COM+.

Транзакции COM+ можно также использовать для управления взаимодействием с другими ресурсами, например, с сообщениями в очереди сообщений. В главе 13, посвященной работе с компонентами MSMQ, транзакции управляют непрерывным удалением сообщений из очереди по мере получения к ним доступа.

Помимо поддержки транзакций и активации по требованию, службы COM+ могут также обеспечивать резервирование (pooling) компонентов.

Резервирование компонентов

Ранее уже отмечалось, что у интерфейса IObjectControl есть три метода: Activate, Deactivate и CanBePooled. У вас уже была возможность поработать с методами Activate и Deactivate, но для резервирования компонентов важен именно метод CanBePooled.

В случае резервирования объектов при пуске приложения COM+ создается минимальный резерв, или пул (pool), компонентов, и все запросы компонента обслуживаются из этого пула посредством менеджера пула (pool manager). Если менеджер получает запрос большего, чем имеется в пуле, числа экземпляров компонента, он создает другой экземпляр компонента, добавляя его в пул — до достижения максимального размера пула. Если же максимальный размер пула достигнут, запрос ставится в очередь до тех пор, пока компонент не станет доступным.

Компоненты, объединяемые в пул, должны соответствовать определенному набору условий. Во-первых, компонент не должен быть отдельно-поточным. Далее, компонент должен поддерживать агрегирование (aggregation), однако при этом свободно-поточный составитель (Free-Threaded Marshaler, FTM) использоваться не может.

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

Если компонент обращается к ресурсам, он должен реализовать три метода интерфейса IObjectControl — Activate, Deactivate и CanBePooled. Обратиться к ресурсу можно с помощью метода Activate (когда компонент создается на клиентской ASP-странице). Этот ресурс может быть высвобожден при высвобождении компонента клиентом (с помощью метода Deactivate). Кроме того, компонент обязан проверить, находятся ли его ресурсы в состоянии, когда их можно резервировать при деактивации компонента. Если резервирование возможно, метод компонента CanBePooled должен возвратить значение True, в противном случае, компонент должен возвратить значение False, чтобы предотвратить возврат компонента в пул.

Наконец, состояние компонента не должно зависеть от сеанса.

Создать резервируемый компонент можно с помощью Visual C++ (или любого другого языка, поддерживающего свободно-поточную или произвольно-поточную модели). Для демонстрации резервирования объектов создайте с помощью мастера ATL COM AppWizard новый проект Visual С++ и назовите его asp0502. Оставьте установленные по умолчанию параметры для MTS, MFC, заместителя (proxy) и исполнителя (stub).

После генерации файлов проекта добавьте новый компонент с помощью мастера ATL Object Wizard. (Подробно работа с этим мастером рассмотрена в главе 14.) Выберите тип Simple Object (Простой объект). Назовите компонент pooledComponent, на вкладке Attributes (Атрибуты) выберите произвольно-поточную модель и поддержку агрегирования (но не поддержку FTM).

Для поддержки интерфейса IObjectControl добавьте в определения класса в файле pooledComponent.h следующую строку:

Добавьте в данные COM ссылку на карту COM (COM map):

При работе с компонентом вам придется обращаться к интерфейсу IObjectContext и встроенному объекту ASP Response, поэтому добавьте в заголовочные файлы библиотеки типов службы COM+ и ASP следующее:

Следует также добавить прототипы метода интерфейса IObjectControl и ссылку на два закрытых (private) члена данных типа интерфейсов IObjectContext и IResponse (встроенного объекта ASP Response). Полный программный код заголовочного файла для резервируемого компонента показан в листинге 5.3.

Листинг 3. Заголовочный файл резервируемого компонента

// pooledComponent.h : объявление CpooledComponent

#ifndef __POOLEDCOMPONENT_H_
#define __POOLEDCOMPONENT_H_

#include «resource.h» // основные символы
#include
#include

/////////////////////////////////////////////////////////////////
// CpooledComponent
class ATL_NO_VTABLE CpooledComponent :
public CComObjectRootEx ,
public CComCoClass ,
public IObjectControl,
public IDispatchImpl
<
public:
CpooledComponent()
<
>

BEGIN_COM_MAP(CpooledComponent)
COM_INTERFACE_ENTRY(IpooledComponent)
COM_INTERFACE_ENTRY(IObjectControl)
COM_INTERFACE_ENTRY(IDispatch)
END_COM_MAP()

// IpooledComponent
public:
STDMETHOD(Activate)();
STDMETHOD_(BOOL, CanBePooled)();
STDMETHOD_(void, Deactivate)();

private: CComPtr m_spObjectContext;
CComPtr m_piResponse;
>;

Далее, с помощью вкладки Link (Связь) диалогового окна Project Settings (Настройки проекта) добавьте в список связанных библиотек проекта библиотеку служб COM+ (comsvcs.lib).

Вам придется реализовать три метода интерфейса IObjectControl. В CPP-файле компонента добавьте код, показанный в листинге 5.4. В этом коде экземпляры IObjectContext и IResponse создаются в методе Activate и высвобождаются в методе Deactivate. Кроме того, метод CanBePooled возвращает значение True и помечает, что компонент можно резервировать (помещать в пул).

Листинг 4. Реализация компонентом методов интерфейса IObjectControl

HRESULT CpooledComponent::Activate()
<
HRESULT hr;
CComBSTR bstrProp;
CComVariant vt;
CComPtr pProps; //Свойства контекста

// получение ObjectContext
hr = CoGetObjectContext(IID_IObjectContext,
(void **)&m_spObjectContext);

if (FAILED(hr)) return hr;

// получение ContextProperties
hr = m_spObjectContext
->QueryInterface( IID_IGetContextProperties,
(void**)&pProps );
if (FAILED(hr)) return hr;

// получение свойства Response
bstrProp = «Response»;
hr = pProps->GetProperty( bstrProp, &vt ) ;
if (FAILED(hr)) return hr;

p > hr = piDispatch->QueryInterface( IID_IResponse,
(void**)&m_piResponse );
return hr;
>

void CpooledComponent::Deactivate()
<
m_piResponse.Release();
m_spObjectContext.Release();
>

BOOL CpooledComponent::CanBePooled()
<
return TRUE;
>

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

С помощью вкладки ClassView (Просмотр классов) добавьте новому компоненту не принимающий никаких параметров метод testPooledComponent. Этот метод прост: он выдает с помощью объекта Response сообщение для web-страницы. Добавьте компоненту программный код метода, показанный в листинге 5.5.

Листинг 5. Единственный метод резервированного компонента

STDMETHODIMP CpooledComponent::testPooledComponent()
<
// печать сообщения
CComVariant vt(«Привет от резервированного компонента»); m_piResponse->Write(vt);

Чтобы воспользоваться резервированием компонентов, компонент нужно добавить в приложение COM+. Создайте новое приложение — с помощью консоли управления службами компонентов (Component Services Management Console) — или воспользуйтесь существующим приложением COM+ и добавьте компонент в приложение.

Добавив компонент в приложение COM+, откройте с помощью контекстного меню диалоговое окно Properties (Свойства) и перейдите на вкладку Activation (Активация). Установите флажок объединения компонентов, задайте минимальный размер пула 10, максимальный — 20.

При первом запуске приложение COM+ создает пул из 10 уже созданных компонентов. При обращении с ASP-страниц к этим компонентам они извлекаются из этого пула до тех пор, пока все не будут активированы. После этого все новые вызовы компонентов будут добавлять экземпляры этих компонентов в пул, пока не будет достигнут максимальный размер пула в 20 экземпляров.

Протестируйте компонент с помощью следующей тестовой ASP-страницы (asp0502.asp):

На этой странице создаются 20 экземпляров компонента и вызывается метод каждого из компонентов. Результатом обращения к этой ASP-странице будет список сообщений со строкой «Привет от резервированного компонента». Первые 10 экземпляров были созданы при запуске приложения COM+, а последние 10 — при обращении к ASP-странице.

Измените теперь число экземпляров на 21 и обратитесь к ASP-странице. Похоже, она виснет. Это происходит потому, что менеджер пула выдал все компоненты из доступного пула, вследствие чего достигнут максимальный размер пула. Запрос 21-го компонента ставится в очередь до тех пор, пока какой-нибудь компонент не освободится. Но поскольку до завершения страницы все компоненты остаются недоступными, а запрос компонента происходит на той же самой странице, экземпляр 21-го компонента не может быть создан, и страница зависает. Фактически страница будут продолжать висеть до истечения времени ожидания запроса компонента. После этого страница выведет следующее сообщение об ошибке («активация COM+ не удалась, поскольку она не может быть завершена в течение заданного времени»):

COM+ activation failed because the activation could not be
completed in the specified amount of time.

Как было показано, резервирование объектов может служить весьма мощным ускорителем производительности, но оно же может и ограничить масштабируемость (scalability) или истощить ресурсы (поскольку резервируемые компоненты удерживаются в памяти). Пользуйтесь этой службой COM+ с осторожностью.

Состояние компонента

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

setState() планирует обновление объекта состояния компонента. Когда состояние изменяется, компонент отвечает переотрисовкой.

Какая разница между state и props?

props (сокращение от «properties») и state — оба обычные объекты JavaScript. Хотя каждый из них содержат информацию, которая влияет на результат отрисовки компонента, между ними имеется важное отличие: props передается компоненту (аналогично параметрам функции), тогда как state управляется внутри компонента (подобно переменным, объявленным внутри функции).

Вот некоторые полезные ресурсы для более подробного изучения того, когда необходимо использовать props или state :

Почему setState мне дает неправильное значение?

В React оба this.props и this.state представляют отображаемые значения, то есть то, что в данный момент отображается на экране.

Вызовы setState асинхронны — не полагайтесь на this.state , чтобы отображать новое значение сразу после вызова setState . Передайте функцию обновления вместо объекта, если вам нужно вычислить значения на основе текущего состояния (подробнее см. ниже).

Пример кода, который будет вести себя не так, как ожидалось:

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

Как мне обновлять состояние новыми значениями, которые зависят от текущего состояния?

Передайте функцию вместо объекта в метод setState , чтобы гарантировать, что вызов всегда использует самую обновленную версию состояния (см. ниже).

В чем отличие между передачей объекта и функции в метод setState?

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

Когда setState асинхронен?

На данный момент setState асинхронен внутри обработчиков событий.

Это гарантирует, например, что если оба Parent и Child вызывают setState во время события click , Child не перерисовывается дважды. Вместо этого React «сбрасывает» обновления состояния в конце события браузера. Это приводит к значительным улучшениям производительности в более крупных приложениях.

Это всё детали реализации, не полагайтесь на них! В будущих версиях React в большинстве случаев будет группировать обновления в пакеты по умолчанию.

Почему React не обновляет this.state синхронно?

Как объяснялось в предыдущем разделе, React намеренно «ждет» до тех пор, пока все компоненты не вызовут setState() в своих обработчиках событий, перед началом переотрисовки. Это повышает производительность, избегая ненужных переотрисовок.

Тем не менее, у вас все равно может оставаться вопрос, почему React просто не обновляет this.state немедленно без переотрисовки.

На это есть две главные причины:

  • Это может поломать консистентность между props и state , вызывая проблемы, которые очень тяжело отладить.
  • Это сделало бы невозможным реализацию наших некоторых новых функций.

Данный комментарий на GitHub дает глубокое описание специфических примеров.

Следует ли мне использовать специальные библиотеки для управления состоянием, вроде Redux или MobX?

Рекомендуется сначала познакомиться с React, прежде чем добавлять дополнительные библиотеки. Вы можете создавать довольно сложные приложения, используя только React.

Илон Маск рекомендует:  HTML статьи, примеры и другое о html
Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL