ASP.Net — введение, жизненный цикл и программа Hello World


История развития ASP.NET

— это инфраструктура для разработки веб-приложений от Microsoft, которая сочетает в себе эффективность и аккуратность архитектуры «модель-представление-контроллер» (model-view-controller — MVC), новейшие идеи и приемы гибкой разработки, а также все лучшее из существующей платформы ASP.NET. Она представляет собой полномасштабную альтернативу традиционной технологии ASP.NET Web Forms, предоставляя преимущества для всех проектов веб-разработки, кроме самых тривиальных.

На момент своего появления в 2002 г. платформа ASP.NET оказалась огромным шагом вперед. На рисунке ниже показано, как выглядел на то время стек технологий Microsoft.

В Web Forms разработчики из Microsoft попытались сокрыть как протокол HTTP (с присущим ему отсутствием состояния), так и язык HTML (который на тот момент был незнаком многим разработчикам) за счет моделирования пользовательского интерфейса в виде иерархии объектов, представляющих серверные элементы управления. Каждый элемент управления отслеживает собственное состояние между запросами (с помощью средства View State (состояние представления)), по мере необходимости визуализируя себя в виде HTML-разметки, и автоматически соединяя события клиентской стороны (например, щелчки на кнопках) с соответствующим кодом их обработки на стороне сервера.

Фактически Web Forms — это гигантский уровень абстракции, спроектированный для предоставления классического управляемого событиями графического пользовательского интерфейса через веб-среду. Идея заключалась в том, чтобы веб-разработка выглядела подобно разработке с применением Windows Forms. Разработчики больше не должны были иметь дело с последовательностями независимых запросов и ответов HTTP. Они могли мыслить терминами пользовательского интерфейса, поддерживающего состояние, и в Microsoft появилась возможность переместить армию разработчиков настольных Windows-приложений в новый мир веб-приложений.

Недостатки технологии ASP.NET Web Forms

Разработка с использованием традиционной технологии ASP.NET Web Forms в принципе была замечательной, однако действительность оказалась более сложной.

Ресурсоемкостъ View State

Действительный механизм поддержки состояния между запросами (известный как View State) требует передачи огромных блоков данных между клиентом и сервером. Объем этих данных может достигать сотен килобайт даже в самых скромных веб-приложениях. Эти данные передаются туда и обратно с каждым запросом, приводя к замедлению реакции и увеличивая требования к ширине полосы пропускания сервера.

Жизненный цикл страницы

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

Ложное чувство разделения ответственности

Модель отделенного кода ASP.NET Web Forms (Code Behind) предоставляет средства вынесения кода приложения из HTML-разметки в специальный файл отделенного кода. Это отвечает широко принятому принципу разделения логики и представления, но в действительности разработчикам приходилось смешивать код представления (например, работу с деревом элементов управления серверной стороны) и логику приложения (скажем, манипулирование информацией из базы данных) в огромных классах отделенного кода. Конечный результат мог оказаться хрупким и трудным для понимания.

Ограниченный контроль над HTML-разметкой

Серверные элементы управления визуализируют себя в виде HTML-разметки, но не обязательно в виде того кода HTML, который вам нужен. В ранних версиях Web Forms выходная HTML-разметка не соответствовала веб-стандартам или неэффективно использовала каскадные таблицы стилей (Cascading Style Sheets — CSS), а серверные элементы управления генерировали непредсказуемые и сложные значения для идентификаторов, к которым было трудно получать доступ с помощью JavaScript. Эти проблемы были значительно смягчены в последних выпусках Web Forms, но получение ожидаемой HTML-разметки по-прежнему может оказаться затруднительным.

«Дырявая» абстракция

Технология Web Forms пытается скрывать детали, связанные с HTML и HTTP, где только возможно. При попытке реализации специального поведения часто приходится отказываться от абстракции, прибегая к воссозданию механизма обратной отправки событий либо предпринимая противоестественные действия для генерирования желаемой HTML-разметки. Кроме того, вся эта абстракция может превратиться в досадное препятствие для опытных разработчиков веб-приложений.

Низкая тестируемость

Проектировщики Web Forms даже не предполагали, что автоматизированное тестирование станет неотъемлемой частью разработки программного обеспечения. Не удивительно, что построенная ими тесно связанная архитектура совершенно не была приспособлена для модульного тестирования. Интеграционное тестирование также может оказаться сложной задачей.

С технологией Web Forms не все было плохо, и в Microsoft вложили немало средств в улучшение степени соответствия стандартам, упрощение процесса разработки и даже заимствование ряда возможностей из ASP.NET MVC. Технология Web Forms показывает себя лучше в ситуациях, когда необходим быстрый результат, и вполне реально построить и запустить умеренно сложное веб-приложение всего за один день. Но если вы проявляете осмотрительность во время разработки, то обнаружите, что созданное приложение трудно для тестирования и дальнейшего сопровождения.

Современное состояние веб-разработки

За рамками решений от Microsoft со времен появления Web Forms технология веб-разработки быстро развивалась в нескольких разных направлениях.

Веб-стандарты и REST

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

Начал массово использоваться стандарт HTML5, и он предоставляет разработчику веб-приложений развитые возможности, позволяющие клиенту выполнять работу, которая ранее входила в исключительную ответственность сервера. Эти новые возможности и рост зрелости таких JavaScript-библиотек, как jQuery, jQuery UI и jQuery Mobile, означает, что стандарты становятся все более важными и формируют необходимую основу для насыщенных веб-приложений.

В то же самое время превалирующей архитектурой взаимодействия между приложениями через HTTP становится , полностью затмевая собой SOAP (технологию, лежащую в основе первоначального подхода к веб-службам в ASP.NET).

Стандарт REST описывает приложение в терминах ресурсов (URI), представляющих реальные объекты, и стандартных операций (методов HTTP), представляющих доступные операции над этими ресурсами. Например, можно было бы выполнить операцию PUT применительно к http://www.example.com/Products/Pen или операцию DELETE — к http://www.example.com/Customers/Charles_Dickens.


Современные веб-приложения генерируют не только HTML-разметку. Часто они должны также предоставлять данные в форматах JSON или XML различным клиентским технологиям, таким как AJAX, и встроенным приложениям для смартфонов. При использовании REST это происходит естественным образом, устраняя различие между веб-службами и веб-приложениями, но требует определенного подхода к обработке HTTP и URL, который было непросто поддерживать с помощью ASP.NET Web Forms.

Гибкая разработка и разработка через тестирование

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

Двумя примерами являются разработка через тестирование (test-driven development — TDD) и относительно близкая к ней разработка через тестирование поведения (behavior-driven development — BDD).

Идея состоит в таком проектировании программного обеспечения, при котором сначала описываются примеры желаемого поведения (известные как тесты или спецификации), чтобы в любой момент можно было проверить стабильность и корректность работы приложения путем выполнения набора тестов применительно к текущей реализации. Недостатка в инструментах .NET, поддерживающих TDD/BDD, нет, однако они не слишком хорошо работают с Web Forms:

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

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

Сообщество независимых поставщиков программного обеспечения вместе с сообществом открытого кода разработали множество высококачественных инфраструктур модульного тестирования ( NUnit и xUnit), инфраструктур имитации ( Moq и Rhino Mocks), контейнеров инверсии управления ( Ninject и AutoFac), серверов непрерывной интеграции ( Cruise Control и TeamCity), инструментов объектно-реляционного отображения ( NHibernate и Subsonic) и аналогичных средств. Из-за своего монолитного проектного решения, традиционная технология ASP.NET Web Forms не слишком подходит для таких инструментов и приемов, и поэтому удостаивается не особенно большого внимания со стороны этих проектов.

Ruby on Rails

В 2004 г. платформа Ruby on Rails была тихим и незаметным продуктом с открытым кодом от неизвестного игрока. Однако весьма неожиданно она добилась популярности изменив сами правила веб-разработки. Это было связано не с тем, что платформа Ruby on Rails предложила революционную технологию, а с тем, что она собрала существующие ингредиенты и смешала их настолько великолепным способом, что смогла буквально «пристыдить» существующие на то время платформы.

Платформа Ruby on Rails (или просто Rails, как ее обычно называют) заключала в себе архитектуру MVC. Применение архитектуры MVC и работа в гармонии с протоколом HTTP, внедрение соглашений вместо обязательного конфигурирования и интеграция инструмента в ядро позволило приложениям Rails без особых усилий завоевать относительно высокую популярность.

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

Node.js

Еще одна важная тенденция — переход к использованию JavaScript в качестве основного языка программирования. Технология AJAX первой продемонстрировала важность JavaScript, технология jQuery показала, что этот язык может быть мощным и изящным, а JavaScript-механизм с открытым кодом V8 от Google продемонстрировал, что он может быть невероятно быстрым.

В настоящее время JavaScript становится серьезным языком программирования серверной стороны. Он служит языком хранения и запрашивания данных для нескольких нереляционных баз данных, включая CouchDB и Mongo, а также применяется в качестве универсального языка в таких серверных платформах, как Node.js. Платформа Node.js появилась в 2009 г. и быстро завоевала широкое признание. Ниже перечислены ее ключевые инновации.

Мастер Йода рекомендует:  70 ресурсов по функциональному программированию

Использование JavaScript. Разработчикам приходится иметь дело с единственным языком — в клиентском коде, внутри логики серверной стороны, в логике запроса данных через CouchDB и т.п.

Hello World

05.03.2020, 21:41

Поменять слова местами то есть Hello World > World Hello C++
Ребят всем привет помогите решить задачку: Имеется предварительно созданный текстовый файл.

Hello World
Написал первую прогу на Ява, среда разработки Нетбинс 6,7,1. Не могу увидеть екзешника в папке.

Hello World
Написать программу для оконного приложения «Hello, World!», где строка приветствия выводится в.

Hello World
программа компилируется, но сообщение Hello World не появляется .386 .model flat, stdcall.

Hello World ВК
Господи, один эс — это нечто. За несколько недель изучения я все больше стал не понимать его. Во.

06.03.2020, 06:46 2

otto-fukin, вот вам простой сайт из одного файла:

Сохраните под именем index.html и всё, сайт готов.

06.03.2020, 07:33 [ТС] 3

06.03.2020, 07:40 4

otto-fukin, вы спросили про один файл, я вам одним файлом и ответил. Точность задаваемого вопроса никто не отменял.

ASP.NET: События жизненного цикла страницы

Эта статья является продолжением статьи «ASP.NET: Этапы жизненного цикла страницы». Сейчас я хочу более подробно рассказать о событийной модели в ASP.NET. Во время прохождения этапов жизненного цикла возникают события, подписавшись на которые, разработчик может выполнять свой собственный код. Зачастую, многие начинающие разработчики, путают порядок событий в ASP.NET приложении. Проверить trace загрузки страницы достаточно просто:

  • Создадим простое ASP.NET Web Forms Application в студии
  • Добавим атрибуты Trace и TraceMode директивы @Page и устанавливаем значения ‘true’ и ‘SortByName’ соответственно.
  • Запускаем наш сайт (нажимаем F5 в студии)
  • Прямо в окне браузера вместе с сайтом загрузилась информации трассировки.

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

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

Событие Использование
PreInit На данном этапе элементы управления еще не созданы и равны null . Здесь разработчик может создать динамически элементы управления, динамически устанавливать шаблон дизайна или тему оформления, считывать или устанавливать свойства объекта Profile .
Init Здесь происходит начальная инициализация контролов, значения берутся из aspx файла. Tracking ViewState еще отключен. В случае, если разработчик самостоятельно установит свойства на этом этапе, то на следующем установленные значения могут быть изменены. На этом этапе разработчик может считывать или инициализировать свойства элементов управления.
Load Загружаются данные из ресурсов. Если произошел Postback, элементы управления получают значения, которые были отправлены с формы. На этом этапе разработчик может считывать или изменять свойства элементов управления.
PreRender Последняя возможность внести изменения во внешний вид страницы.
Unload Освобождение занятых ресурсов (закрытие открытых соединений с базой данных, завершение работы с файлами и т.п.) Важно, что на этом этапе уже создано HTML представление страницы и попытка внести какие-либо изменения (например, вызвав метод Response.Write() ), приведет к исключению. Если на данном этапе изменить знамения элементов управления, они не попадут конечному пользователю.

Пример

Результат работы скрипта приведен в таблице:

MVC проект «Hello World»

Данная глава охватывает следующие темы:

  • Настройка вашей среды разработки
  • Создание вашего первого приложения на платформе ASP.NET MVC
  • Знакомство с контроллерами, действиями и представлениями
  • Организация простого доступа к данным

В этой главе мы познакомим вас с приложением «Guestbook», которое будет выступать в роли нашего примера на протяжении всей оставшейся части 1 данной книги. «Guestbook» – это простое приложение, которое даст пользователям возможность публиковать свои имена и сообщения на сайте, а также просматривать сообщения, опубликованные другими пользователями. Несмотря на то, что концепция приложения «Guestbook» довольно проста, мы будем использовать его для изучения основных компонентов платформы ASP.NET MVC.

На протяжении всей части 1 данной книги мы будем создавать это приложение. Мы начнем с рассмотрения инструментов разработки, которые должны быть установлены для того, чтобы обеспечить возможность работы с MVC приложениями, а затем мы создадим первоначальный каркас приложения «Guestbook» и изучим компоненты, которые по умолчанию поставляются с только что созданным MVC приложением. Мы также изучим то, как получить доступ к базе данных SQL Server Compact, используя некоторые новые возможности Entity Framework 4.1.

В главе 3 мы усовершенствуем приложение, которое начнем создавать в главе 2, посредством изучения теоретических основ представлений и того, как использовать новый движок представления Razor, а также HTML Helpers (вспомогательные методы) для создания элементов пользовательского интерфейса. Наконец, в главе 4 будут подробно рассматриваться контроллеры, и кроме того, вы познакомитесь с технологией модульного тестирования MVC приложений.

Теперь давайте рассмотрим то, как вы можете настроить вашу среду разработки.

Одностраничные приложения: создание современных адаптивных веб-приложений с помощью ASP.NET

Продукты и технологии:

Single-Page Applications (SPA), ASP.NET Web API, Knockout.js, Ember.js, AJAX и HTML5

В статье рассматриваются:

  • создание уровня сервисов и веб-клиента AJAX для приложения-примера;
  • шаблоны MVC и MVVM;
  • связывание с данными;
  • создание веб-клиента с применением Knockout.js;
  • создание веб-клиента с применением Ember.js.


Одностраничные приложения (Single-Page Applications, SPA) — это веб-приложения, которые загружают одну HTML-страницу и динамически обновляют ее при взаимодействии с пользователем.

SPA используют AJAX и HTML5 для создания гибких и адаптивных веб-приложений без постоянных перезагрузок страницы. Однако это означает, что большая часть работы возлагается на клиентскую сторону, а именно на JavaScript-код. Разработчику для традиционной ASP.NET может быть трудно совершить такой кульбит. К счастью, существует множество JavaScript-инфраструктур с открытым исходным кодом, которые облегчают создание SPA.

В этой статье я пошагово пройду процесс создания простого SPA-приложения. Попутно вы ознакомитесь с некоторыми фундаментальными концепциями создания SPA, в том числе с шаблонами Model-View-Controller (MVC) и Model-View-ViewModel (MVVM), связыванием с данными и маршрутизацией (routing).

О приложении-примере

Я создал приложение-пример для операций с простой базой данных по фильмам (рис. 1). В крайнем слева столбце страницы отображается список жанров. Выбор жанра приводит к появлению списка соответствующих фильмов. Кнопка Edit рядом с записью позволяет изменять эту запись. После редактирования можно щелкнуть кнопку Save для передачи обновления на сервер или кнопку Cancel для отмены изменений.

Рис. 1. SPA-приложение для базы данных по фильмам

Я создал две версии этого приложения: одна из них использует библиотеку Knockout.js, а другая — библиотеку Ember.js. Эти две библиотеки основаны на разных подходах, поэтому будет весьма поучительно сравнить их. В обоих случаях клиентское приложение не требовало более 150 строк JavaScript-кода. На серверной стороне я задействовал ASP.NET Web API, чтобы обслуживать JSON для клиента. Исходный код обеих версий вы найдете на github.com/MikeWasson/MoviesSPA.

(Примечание Я создавал приложение, используя RC-версию Visual Studio 2013. В RTM-версии некоторые вещи могли измениться, но они не должны повлиять на код.)

Обзор

В традиционном веб-приложении при каждом вызове сервера тот осуществляет рендеринг новой HTML-страницы. Это вызывает обновление страницы в браузере. Если вы когда-нибудь писали приложение Web Forms или PHP, этот жизненный цикл страниц должен быть знаком вам.

В SPA после загрузки первой страницы все взаимодействие с сервером происходит через AJAX-вызовы. Эти AJAX-вызовы возвращают данные (не разметку) — обычно в формате JSON. Приложение использует JSON-данные для динамического обновления страницы без ее перезагрузки. Рис. 2 иллюстрирует разницу между этими двумя подходами.

Рис. 2. Сравнение традиционного жизненного цикла страницы с жизненным циклом в SPA

Traditional Page Lifecycle Традиционный жизненный цикл страницы
Client Клиент
Page Reload Перезагрузка страницы
Server Сервер
Initial Request Начальный запрос
HTML HTML
Form POST Передача формы командой POST
SPA Lifecycle Жизненный цикл в SPA
AJAX AJAX
JSON JSON

Одно из преимуществ SPA очевидно: приложения более гибкие и адаптивные, свободные от рваного эффекта перезагрузки страницы и ее рендеринга заново. Другое преимущество может оказаться менее очевидным и касается того, как вы проектируете архитектуру веб-приложения. Отправка данных приложения как JSON обеспечивает разделение между презентационной частью (HTML-разметкой) и прикладной логикой (AJAX-запросы плюс JSON-ответы).

Это разделение упрощает проектирование и развитие каждого уровня. В SPA-приложении с тщательно продуманной архитектурой можно изменять HTML-разметку, не касаясь кода, который реализует прикладную логику (по крайней мере, в идеале). Вы увидите это на практике, когда мы будем обсуждать связывание с данными.

В чистом SPA все UI-взаимодействие происходит на клиентской стороне через JavaScript и CSS. После начальной загрузки страницы сервер действует исключительно как уровень сервисов. Клиенту нужно просто знать, какие HTTP-запросы он должен посылать. Ему не важно, как сервер реализует свою часть.

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

Создание проекта в Visual Studio

В Visual Studio 2013 есть один тип проекта ASP.NET Web Application. Мастер этого проекта позволяет выбрать ASP.NET-компоненты, которые будут включены в проект. Я начал с шаблона Empty, а затем добавил в проект ASP.NET Web API, установив флажок Web API в разделе Add folders and core references for, как показано на рис. 3.

Рис. 3. Создание нового ASP.NET-проекта в Visual Studio 2013

В новом проекте есть все библиотеки, необходимые для Web API, а также кое-какой конфигурационный код Web API. Я не вводил никаких зависимостей от Web Forms или ASP.NET MVC.

Обратите внимание на рис. 3, что Visual Studio 2013 включает шаблон Single Page Application. Этот шаблон устанавливает скелет SPA-приложения, основанный на Knockout.js. Он поддерживает вход с применением базы данных с информацией о членстве в группах или с помощью внешнего провайдера аутентификации. Я не стал использовать этот шаблон в своем приложении, потому что хотел показать более простой пример с нуля. Шаблон SPA — отличный ресурс, особенно если вам нужно добавить аутентификацию в приложение.

Создание уровня сервисов

Я использовал ASP.NET Web API, чтобы создать простой REST API для приложения. Не буду здесь вдаваться в детали Web API — подробности вы можете прочитать по ссылке asp.net/web-api.

Сначала я создал класс Movie, представляющий фильм. Этот класс делает две вещи:

  • сообщает Entity Framework (EF), как создавать таблицы базы данных для хранения информации о фильмах;
  • сообщает Web API, как форматировать полезные данные JSON.


Вы не обязаны использовать одну модель для обеих целей. Например, вам может понадобиться, чтобы схема базы данных отличалась от полезных данных JSON. В этом приложении я ничего не усложняю:

ASP.Net — введение, жизненный цикл и программа Hello World

Whilst the article shows how to use MEF to use parts (plug-ins) to return values to the host application,
it does not show how to get a plug-in to activate within the host.

If I make the part (plugin) a web-page in its own right:

how do I get it to become visible? I.e. How does the part get activated & loaded?

I’m trying to build a web-based console like the MS MMC and require that plug-ins are added at run-time and are shown inside an area of the host web page.

Thanks, Dave Radcliffe Sign In· View Thread

Re: Plug-in capabilities

mgkr 2-Apr-13 6:50

«use MEF to use parts (plug-ins) to return values to the host application»

A «value» can be anything — Including an object. Say a web page «Control».

This is what you need to return from your plugin — And then add it to the pages control collection (ie. page.controls.add(«control from plugin») )

If you’ve created your control correctly, then everything will work «auto-magically».

This gets VERY tricky however, if your plugin control needs to communicate with other controls (and values) on the page etc — Not to mention post back behavior and what not.
Not for the faint of hearth — And completely outside the scope of this particular article

Sign In· View Thread
More detail informationa about MEF

Gunjal Amol 21-Aug-12 23:09
http://msdn.microsoft.com/en-us/magazine/ee291628.aspx[^] Ra-one 29-May-12 20:04
Have 5, Just a suggestion use the proper names for the classes, controls and the variables in the example, that makes it more readable and easier to understand.
Sign In· View Thread
My vote of 5 Vinod Satapara 7-Feb-12 2:12
Nice one
Sign In· View Thread
Nice Job Mike Hankey 11-Mar-11 18:54
Just starting to get into MEF and this helps get me started. mgkr 12-Mar-11 2:55

Perfect — That was exactly the intention.

Thanks for the feedback.

Sign In· View Thread
Last Visit: 9-Nov-19 3:27 Last Update: 9-Nov-19 3:27 Refresh 1

General News Suggestion Question Bug Answer Joke Praise Rant Admin

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

Жизненный цикл Request в MVC 3 Framework приложении

Любой разработчик знает, что URL в маршрутизации MVC играет ключевую роль. Как известно, существует стандартная маршрутизация:

Она представляет собой правило по которым выбираются маршруты. В простейших случаях, можно поменять местами action и controller, или добавить еще множество параметров, которые будут выглядеть в url следующим образом- param1/param2/param3/. Иногда, например в CMS системах, необходимо сделать так, чтоб часть url приходила как переменная.


Это правило выделяет Action и Controller, а остальную часть присваивает переменной url.
Регистрируются Routes при старте приложения. А именно в файле Global.asax в методе Application_Start().

Для создания большинства приложений этих знаний хватает. Цель же моей статьи пройти весь жизненный цикл Request и посмотреть, что же происходит, перед тем как приложение разберет url и передаст управление нужному action.

1. Создание обработчика запроса MVC.
MVC включает следующие типы обработчика: (По материалам MSDN)
• MvcHandler. Этот обработчик отвечает за инициирование конвейера ASP.NET для приложения MVC. Он получает экземпляр Controller из фабрики MVC контроллера; данный контроллер выполняет дальнейшую обработку запроса. Обратите внимание, что несмотря на то, что MvcHandler реализует IHttpHandler, его нельзя сопоставить как обработчик (например, для расширения имени файла .mvc), поскольку класс не поддерживает конструктор без параметров. (Единственный конструктор требуется объект RequestContext).
• MvcRouteHandler. Этот класс реализует IRouteHandler, поэтому его можно интегрировать с маршрутизацией ASP.NET. Класс MvcRouteHandler связывает маршрут с экземпляром MvcHandler. Экземпляр MvcRouteHandler регистрируется с маршрутизацией, при использовании метода MapRoute. При вызове класса MvcRouteHandler класс создает экземпляр MvcHandler, используя текущий экземпляр RequestContext. Затем он передает элемент управления новому экземпляру MvcHandler.
• MvcHttpHandler. Этот обработчик используется для упрощения прямого сопоставления обработчика минуя модуль маршрутизации. Это полезно, при необходимости сопоставления расширения имени файла, например .mvc, непосредственно обработчику MVC. На внутреннем уровне, MvcHttpHandler выполняет одни и те же задачи, что и обычная маршрутизация ASP.NET (проходя через MvcRouteHandler и MvcHandler). Однако, он выполняет эти задачи как обработчик, а не модуль. Этот обработчик обычно не используется, если UrlRoutingModule включен для всех запросов.

Для чего это может понадобиться?

  • a. Простейший пример для локализации приложений (Thread.CurrentThread.CurrentUICulture и Thread.CurrentThread.CurrentCulture).
  • b. Для маршрутизации между несколькими приложениями.
  • c. Для выполнения настроек перед Dependency Injection (например выбор строки подключения к DB).

Общий вид переопределения MvcRouteHandler следующий:

Инициализировать CustomRouteHandler нужно в классе Global методе Application_Start()

2. Выбор и создание контроллера
За выбор и создание контроллера отвечает класс ControllrerFactory. Этот класс реализует интерфейс IControllerFactory

Естественно вы можете создать свою фабрику контроллеров, реализуя этот интерфейс, но как правило, для удовлетворения потребностей достаточно переопределить методы класса DefaultControllerFactory. Как правило это IController CreateController(RequestContext requestContext, string controllerName). Ниже пример переопределенной фабрики контроллеров.

Между прочем Autofac, Ninject, Unity все они создают свою фабрику контроллеров для Dependency Injection.
Регистрирование собственной фабрики, так же происходит в классе Global, методе Application_Start()
ControllerBuilder.Current.SetControllerFactory(new MyControllerFactory());

3. Action
После создания нужно экземпляра контроллера вызывается метод IController.Execute(). В методе Execute() мы должны выполнить необходимые нам действия. В стандартном классе Controller управление передается ActionInvoker, он то и отвечает за вызов определенного action.

Зарегистрировать в контроллере его можно инициализировав в конструкторе.

ActionInvoker также перед вызовом Action проверяет его атрибуты, производные от ActionMethodSelectorAttribute и FilterAttribute (AuthorizeAttribute, HandleErrorAttibute, ValidateAntiForgeryTokenAttribute, ValidateInputAttribute). Эти атрибуты позволяют принять решение, можно ли передать управление тому или иному action.
Для создания своих action selectorов – наследование от этого атрибута

4. Binders
Как мы уже знаем, механизм MVC позволяет помимо простейших параметров(int, string), использовать более сложные, например классы. Но иногда нужно принять, достаточно экзотический класс, с которым стандартный binder не справляется. В этом случае мы можем написать свой собственный binder. Для этого достаточно наследоваться от DefaultModelBinder и переопределить его методы.

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

Либо в классе Global, методе Application_Start().

5 ActionResult
И наконец после того как отработал action, on возвращает ActionResult(). Это может быть View(), PartialView(), JsonResult(), FileResult(), EmptyResult().
Естественно этот список может быть расширен и дополнен, нашими реализациями ActionResult(). Для этого достаточно, наследоваться от класса ActionResult, и переопределить метод void ExecuteResult(ControllerContext context)

Так же есть интересный способ добавить нужные методы на View() и пользоваться ими непосредственно из *.cshtml файла. Для этого наследуемся от класса WebViewPage.

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

Теперь вы можете использовать новые методы во View.

Заключение
Вот и все. В этом посте мы прошли все этапы Request в MVC, мы рассмотрели как мы можем влиять на каждый этап. Надеюсь теперь у вас сложилась полная картина, о том как работает MVC3 framework.

Hello, world!

In almost every programming tutorial you will find the classic «Hello, world!» example, and who am I to break such a fine tradition? Let me show you how you can say hello to the world from ASP.NET. Open the Default.aspx (if it’s not already opened) by doubleclicking it in the Solution Explorer. It already contains a bunch of HTML markup, as well as some stuff you probably won’t recognize, like the Page directive in the top, or the runat attribute on the form tag. This will all be explained later, but for now, we want to see some working code.

First of all, we will add a Label control to the page. A Label control is some what simple, since it’s just used to hold a piece of text. Add the following piece of HTML-looking code somewhere between the set of

Создание страниц ASP.NET в среде Visual Studio

Среда Visual Studio существенно облегчает разработку Web-приложений. Основными действиями, выполняемыми в ходе создания приложения в среде, являются создание форм, написание обработчиков событий, добавление файлов (таблиц стилей, страниц и т.п.), отладка

В Visual Studio разных версий предлагается несколько режимов создания Web-приложений, функционирующих на основе ASP.NET, чаще всего используются Website… и Project… В Visual Studio 2005 включен только Website…, в 2008 и 2010 – оба.

В режиме создания Web-сайта (File — New Website…). Visual Studio создает только файлы, относящиеся к сайту (файл с кодом страницы, файл с программами обработчиков и файл конфигурации).


В окне New Web Site могут быть дополнительно указаны параметры: версия .NET, шаблон (выбираем ASP.NET WEB Site), размещение (место хранения файлов Web-сайта), язык программирования. После того, как выбор сделан (нажата ОК) будет создана заготовка Web-приложения (три основных файла). Компиляция страниц будет выполняться средой ASP.NET перед открытием в браузере.

В режиме создания проекта (File — New Project…) кроме основных файлов, генерируется несколько вспомогательных и файл проекта с расширением .csproj, в котором фиксируются составляющие проект файлы и сохраняются некоторые отладочные параметры.

В окне New Project кроме типа (ASP.NET Web Application), места размещения и языка, необходимо выбрать имя (Solution Name), которое затем будет использовано для создания в выбранном месте размещения соответствующего подкаталога.

В отличие от режима создания Web Site, кроме размещения информации в различных файлах, при запуске Web-проекты компилируются Visual Studio (а не ASP.NET). Классы Web-страниц объединяются в одну сборку, которая получает то же имя, что и у Web-проекта (например, WebApplication) и затем размещается в папке bin. В Web-проекте для страниц всегда используют модель отделенного кода, объявления для всех элементов управления содержаться в файле с расширением .aspx.desginer.cs. Во время компиляции файлы с кодами обработчиков и кодами элементов управления будут объединены. В беспроектном Web-сайте файла с объявлениями элементов управления нет, поскольку эта часть кода генерируется во время компиляции системой ASP.NET. Есть и другие отличия (например, в содержании директивы Page и т.п.), останавливаться на которых мы не будем.

Дальнейшие действия по созданию Web-приложения практически не отличаются.

В ходе работы по созданию сайтов используются окна и панели, состав и место расположения которых можно изменять, используя меню View и перетаскивая их мышью. Типичный вид среды при разработке Web-приложений приведен на рис.4.4.

Рис. 4.4. Вид окна для разработки Web-приложений

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

Обозреватель решений, отображает файлы и папки веб-узла.

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

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

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

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

Окно вывода служит для вывода сообщений среды (ошибки, информация отладчика и т.п.).

Создание форм. Создаваемые документы (формы и файлы с программным кодом) открываются в окне документов. При работе с формами предусмотрено два режима отображения Design и Source. В первом режиме интерфейс можно конструировать визуально, во втором – путем написания кода разметки. Для переключения используются закладки в нижней части окна. В режиме Design можно повысить наглядность отображаемой структуры, выполнив команду Details из меню View.

Форма ASP.NET – документ, на основе которого формируется HTML-страница, отправляемая клиенту. Она создается путем размещения элементов в окне документов. Элементы для размещения выбираются из панели инструментов. В панели элементы сгруппированы по типам.

Чаще всего используются элементы из групп HTML и Standard.

Группа HTML содержит HTML-элементы, соответствующие одноименным элементам обычных Web-страниц. С их использование создается статическая разметка страницы. Однако они могут быть преобразованы в серверные путем добавления атрибута runat=»server» или выполнения команды Run As Server Control из контекстного меню элемента. Их называют серверными HTML-элементами управления, при их обработке перед отправкой формируется только один HTML-тег.

Группа Standard содержит серверные элементы управления с расширенной функциональностью. Среди них имеются полнофункциональные элементы управления, выполняющие генерацию достаточно сложного HTML-кода и клиентских сценариев JavaScript для создания развитого интерфейса на клиенте. Это такие элементы как Calendar, AdRotator, TreeView. Среди них есть и аналоги HTML-элементов (кнопок, текстовых полей и т.д.). Элементы этой группы называют серверными Web-элементами управления, они являются основными при создании форм.

Среди других групп отметим такие.

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

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

Validation — элементы управления проверкой правильности заполнения полей пользователем.

Data — элементы управления данными.

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

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


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

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

ASP.NET и разработка Web-приложений

Многие разработчики полагают, что технология ASP.NET является чем-то вроде продолжения ASP, т. е. что это, если так можно выразиться, перенесенная на платформу .NET версия ASP 3.0, несколько усовершенствованная и дополненная поддержкой новых языков. Подобное представление в корне неверно. ASP.NET является концептуально новой современной платформой, предназначенной для создания Web-приложений. Специалистами Microsoft в ASP.NET заложено все для того, чтобы сделать цикл разработки Web-приложения более быстрым, а поддержку — более простой.

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

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

Библиотеки. Теперь при написании приложений можно задействовать набор компонентов, поставляемых с .NET, а он достаточно велик. Использование библиотеки классов Common Language Runtime (CLR) уменьшает количество кода, ускоряет процесс разработки, установки и переноса приложения.

ADO.NET. В приложениях ASP.NET, как и в любом другом программном коде под .NET, можно использовать ADO.NET. Я упоминаю ADO.NET особо, чтобы подчеркнуть, насколько часто эта библиотека применяется при создании приложений на ASP.NET. Среди функций ADO.NET, используемых в ASP.NET, можно назвать, например, возможность сохранения набора данных в XML и загрузки его из XML, что упрощает разработку распределенных приложений на основе ASP.NET, а также полезно при передаче данных между Web-службами ASP.NET.

Поддержка средств разработки. Visual Studio.NET предоставляет возможность создания и редактирования приложений в режиме WYSWYG, включает в себя средства, упрощающие разработку и перенос приложений, а также отладку сценариев. Но, несомненно, никто не отнимает права написания кода в любимом редакторе, будь то CodeWright, EditPlus или NotePad.

Языковая независимость. ASP.NET работает в рамках Common Language Runtime, что позволяет писать код на любом языке, для которого существует компилятор, поддерживающий эту технологию. Сейчас имеется поддержка для JScript, VB, Perl и C#.

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

Обработка ошибок. В связи с новыми концепциями (в частности, с компиляцией программных текстов) в ASP.NET добавлены более широкие возможности обработки ошибок. На стадии разработки можно получить полную информацию об ошибке и листинг нужного куска кода. Для обработки ошибок, которые могут случиться во время выполнения приложения, можно использовать новую директиву ErrorPage.

Объектно-ориентированная разработка. Использование C# позволяет в полной мере задействовать концепции, методы и шаблоны объектно-ориентированной разработки.

Повторное применение. Помимо возможностей объектно-ориентированного программирования, ASP.NET представляет новые технологии, такие, как пользовательские элементы управления (user controls), новую концепцию установки (bin) и другие возможности.

Набор серверных компонентов ASP.NET. В комплект ASP.NET входят различные серверные компоненты: от самых простых (кнопка, список) до нестандартных и более функционально богатых (календарь).

Структура

Теперь немного поговорим о внутренней организации ASP.NET. Если продолжить сравнение с ASP, надо отметить, что в связи с описанными нововведениями внутренняя организация не могла остаться прежней. Если ASP представляла собой ISAPI DLL, с набором компонентов и несколькими системными файлами, то ASP.NET — часть глобальной платформы .NET. Создание этой платформы — важнейшее направление новой стратегии Microsoft; она соответствует всем современным стандартам разработки как для распределенных систем, так и для настольных приложений. На Рисунке 1 приведена схема, на которой показано взаимодействие различных частей .NET. Взаимодействие строится следующим образом: библиотека .NET Framework предоставляет интерфейс приложениям, а сама при этом взаимодействует непосредственно с операционной системой. Выше лежит интерфейс приложений ASP.NET, на котором, в свою очередь, базируются Web-формы (страницы ASP.NET) и Web-службы. Интерфейс .NET Framework позволяет стандартизировать обращение к системным вызовам и предоставляет среду для более быстрой и удобной разработки.

Рисунок 1. Схема работы .NET.

Intermediate Language — общий промежуточный язык, в который компилируется любой код под .NET, независимо от того, был ли он написан на C#, VB.NET или другом языке, — позволяет создавать системы на любом языке. И независимо от того, используется ли C#, VB.NET, JScript.NET или Perl.NET, на выходе получается готовый к выполнению код. На Рисунке 2 показана схема процесса компиляции и выполнения приложения ASP.NET. При запросе страницы проверяется, есть ли на диске ее скомпилированная версия и не обновлялась ли страница с момента компиляции. Если есть актуальная версия, она подгружается с диска и выполняется средой .NET. Результат выполнения страницы отсылается клиенту. Если же такая версия не была найдена, страница сначала компилируется. Для этого используются соответствующие компиляторы, которым на вход подается исходный код самой страницы, ее code-behind (т. е. непосредственно исполняемый код, стоящий за Web-формой, который написан отдельно — он может отсутствовать) и код элементов управления. Полученный в результате код сохраняется на диске. В некоторых случаях, а именно, когда в кэше имеется сохраненный результат обработки страницы, MSIL-код даже не приходится выполнять.

Рисунок 2. Схема работы ASP.NET.

На практике

Данный процесс кажется сложным, но разработчики всей этой сложности не замечают — процедура создания страниц ASP.NET достаточно проста. В подтверждение своих слов я хочу создать простейшую ASP.NET-форму. Для написания формы нужно сначала установить, собственно, ASP.NET. Установка начинается с получения комплекта .NET Framework SDK. Размер дистрибутива достигает 90 Мбайт, однако имеется возможность загрузки SDK в виде набора маленьких файлов. После загрузки требуется запустить файл setup.exe и следовать его инструкциям. ASP.NET распространяется как составная часть .NET SDK — сборника всех технологий, необходимых для создания, сборки и тестирования приложений, основанных на .NET Framework. Перед установкой ASP.NET следует инсталлировать Internet Explorer 6. NET SDK можно взять и с компакт-диска Windows Component Update из Visual Studio.NET. Если VS.NET на сервере установлен, то для того, чтобы запускать приложения ASP.NET, уже все есть.

Первую форму мы создадим с привлечением минимальных средств — нам падобится .NET Framework, Internet Information Services 5 и текстовый редактор. Создание формы начнем с написания приложения на Web-сервере. Создадим папку, в которой будет находиться приложение. Предположим, C:SampleApplication. Затем запустим Internet Services Manager. Создадим на сервере новый виртуальный каталог. Для этого нужно вызвать контекстное меню Web-сервера и выбрать пункт NewVirtual Director. На экране появится мастер Virtual Directory Creation Wizard. С его помощью нужно указать имя нового приложения, пусть это будет CustomApp. Далее следует указать каталог, в котором будут находиться файлы приложения. В нашем случае это C:SampleApplication. Следующий шаг — назначить права доступа к приложению (их можно оставить заданными по умолчанию). Далее в полученной папке создадим файл Default.aspx (см. Листинг 1).

Листинг 1. Default.aspx.

Опишу вкратце код этого листинга.

В первой строчке стоит директива @ Page, которая задает параметры страницы. Здесь, в частности, указано, что мы пишем на C#, что на странице у нас будет проводиться дополнительная программная обработка, определенная в файле Default.aspx.cs (мы его еще напишем), а наследоваться страница будет от класса Default (который будет описан в файле Default.aspx.cs).

Далее следует форма. Все серверные элементы управления должны быть включены в серверную форму (

Добавить комментарий