C# ASP.NET Core. Уровень 1. Cоздание веб-сайтов и порталов


Содержание

Веб-сайты ASP.NET

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

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

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

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

Так же будет показано, как можно расширять веб-страницы с помощью дополнительных технологий: специальных элементов управления, GDI+ для создания графики вручную, JavaScript и Ajax и средства Web Parts, которое позволяет легко создавать веб-порталы.

Пишем свой первый RESTful веб-сервис на ASP.NET

Что такое RESTful веб-сервис?

REST используется для создания легковесных, поддерживаемых и масштабируемых веб-сервисов. Сервис, построенный на REST архитектуре, называется RESTful-сервисом. REST использует HTTP — базовый сетевой протокол.

Ключевые составляющие RESTful

Веб-сервисы прошли долгий путь с момента их появления. В 2002 году W3C выпустил определения WSDL и SOAP веб-сервисов. Это сформировало стандарт по созданию веб-сервисов.

В 2004 году W3C выпустил определение ещё одного стандарта под названием RESTful. В последние годы этот стандарт стал довольно популярным. На данный момент он используется многими известными сайтами по всему миру, в число которых входят Facebook и Twitter.

20 ноября в 18:30, Москва, беcплатно

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

Ключевые составляющие реализации RESTful:

  1. Ресурсы. Допустим, у нас есть сервер с записями о сотрудниках, а адрес веб-приложения — http://server.com. Чтобы получить доступ к записи сотрудника, мы можем выполнить команду http://server.com/employee/1, которая говорит серверу предоставить запись сотрудника под номером 1.
  2. Методы запросов. Они говорят, что вы хотите сделать с ресурсом. Браузер использует метод GET, чтобы проинформировать удалённую сторону о том, что он хочет получить данные. Кроме GET есть много других методов вроде POST, PUT и DELETE. В примере с http://server.com/employee/1 выше браузер на самом деле использует метод GET, поскольку он хочет получить данные о сотруднике.
  3. Заголовки запроса. Это дополнительные инструкции, посылаемые вместе с запросом. Они могут определять тип необходимого ресурса или подробности авторизации.
  4. Тело запроса. Это данные, отправляемые вместе с запросом. Данные обычно отправляются, когда выполняется POST-запрос к REST веб-сервису. Зачастую в POST-запросе клиент говорит серверу, что он хочет добавить на него ресурс. Следовательно, тело запроса содержит подробную информацию о ресурсе, который необходимо добавить на сервер.
  5. Тело ответа. Это основная часть ответа. В нашем примере на запрос http://server.com/employee/1 сервер мог бы прислать XML-документ с данными о сотруднике в теле ответа.
  6. Коды ответа. Эти коды возвращаются сервером вместе с ответом. Например, код 200 обычно означает, что при отправке ответа не произошло никакой ошибки.

Методы RESTful

Представим, что у нас есть RESTful веб-сервис по адресу http://server.com/employee/. Когда клиент делает запрос к нему, он может указать любой из обычных HTTP-методов вроде GET, POST, DELETE и PUT. Ниже указано, что могло бы произойти при использовании соответствующего метода:

  • POST — с его помощью можно создать новую запись сотрудника;
  • GET — с его помощью можно запросить список сотрудников;
  • PUT — с его помощью можно обновить данные сотрудников;
  • DELETE — с его помощью можно удалять записи сотрудников.

Посмотрим на это с точки зрения одной записи. Допустим у нас есть запись сотрудника под номером 1. Вот какое значение могли бы иметь следующие действия:

  • POST — этот метод нельзя применить, так как сотрудник с номером 1 уже существует;
  • GET — этот метод можно использовать для получения данных о сотруднике под номером 1;
  • PUT — этот метод можно использовать для обновления данных сотрудника под номером 1;
  • DELETE — этот метод можно использовать для удаления записи сотрудника под номером 1.

Почему RESTful

В основном популярность RESTful обусловлена следующими причинами:

1. Разнородные языки и среды — это одна из основных причин:

  • У веб-приложений, написанных на разных языках, есть возможность взаимодействовать друг с другом;
  • Благодаря RESTful эти приложения могут находиться в разных средах, будь то Windows или Linux.

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

Facebook, Twitter и Google дают доступ к их функциональности посредством RESTful веб-сервисов. Это даёт возможность любому клиентскому приложению взаимодействовать с этими сервисами с помощью REST.

2. Технологический бум – сегодня всё должно работать на разнообразных устройствах, будь то смартфон, ноутбук или кофеварка. Представляете, каких бы усилий стоило наладить взаимодействие этих устройств с помощью обычных веб-приложений? RESTful API делают эту задачу гораздо проще, поскольку, как было упомянуто выше, вам не нужно знать, что у устройства «под капотом».

3. Появление облачных сервисов — всё переезжает в облако. Приложения медленно перемещаются в облачные системы вроде Azure или Amazon, которые предоставляют большое количество API на основе RESTful архитектуры. Следовательно, приложения должны разрабатываться таким образом, чтобы они были совместимы с облаком. Так как все облачные архитектуры работают на основе REST, логично разрабатывать веб-сервисы тоже на REST-архитектуре, чтобы извлечь максимум пользы из облачных сервисов.

RESTful архитектура

Приложение или архитектура считается RESTful, если ей присущи следующие характеристики:

  1. Состояние и функциональность представлены в виде ресурсов — это значит, что каждый ресурс должен быть доступен через обычные HTTP-запросы GET, POST, PUT или DELETE. Так, если кто-то хочет получить файл на сервере, у них должна быть возможность отправить GET-запрос и получить файл. Если он хочет загрузить файл на сервер, то у него должна быть возможность использовать POST или PUT-запрос. Наконец, если он хочет удалить файл, должна быть возможность отправить запрос DELETE.
  2. Архитектура клиент-сервер, отсутствие состояния (stateless) и поддержка кеширования:
    • Клиент-сервер — обычная архитектура, где сервером может быть веб-сервер, на котором, на котором размещено приложение, а клиентом — обычный веб-браузер;
    • Архитектура без сохранения состояния означает, что состояние приложения не сохраняется в REST. Например, если вы удалили ресурс с сервера командой DELETE, то даже при получении положительного кода ответа нет гарантий, что он действительно был удалён. Чтобы убедиться, что ресурс удалён, необходимо отправить GET-запрос. С его помощью можно запросить ресурсы, чтобы посмотреть, присутствует ли там удалённый.

Принципы и ограничения RESTful

Архитектура REST основывается на нескольких характеристиках, которые описаны ниже. Любой RESTful веб-сервис должен им соответствовать, чтобы называться таковым. Эти характеристики также известны как принципы проектирования, которым нужно следовать при работе с RESTful-сервисами.

RESTful клиент-сервер

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

Отсутствие состояния

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

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

Многослойная система

Суть этой концепции заключается в том, что любой дополнительный слой вроде промежуточного (слой, в котором создаётся бизнес-логика; это может быть дополнительный сервис, с которым клиент взаимодействует до сервера) можно поместить между клиентом и сервером, на котором располагается RESTful веб-сервис. Однако этот слой должен быть внедрён прозрачно, чтобы он не нарушил взаимодействия клиента и сервера.

Единообразие интерфейса

Это фундаментальное требование дизайна RESTful-сервисов. RESTful работает на уровне HTTP и использует нижеприведённые методы для работы с ресурсами на сервере:

  • POST — для создания ресурса;
  • GET — для его получения;
  • PUT — для его обновления;
  • DELETE — для его удаления.

Создаём свой первый RESTful веб-сервис с ASP.NET

Веб-сервисы можно создавать на множестве языков. Многие IDE можно использовать для создания REST-сервисов.

Мы напишем REST-приложение на .NET, используя Visual Studio.

Наш сервис будет работать со следующим набором данных «туториалов»:

TutorialId TutorialName
Arrays
1 Queues
2 Stacks

Мы реализуем следующие RESTful методы:

  • GET Tutorial — при его вызове клиент получает все доступные TutorialName;
  • GET Tutorial/TutorialId — при его вызове клиент получает TutorialName, соответствующее переданному TutorialId;
  • POST Tutorial/TutorialName — при его вызове клиент отправляет запрос на добавление туториала с переданным TutorialName;
  • DELETE Tutorial/TutorialId — при его вызове клиент отправляет запрос на удаление туториала с TutorialName, соответствующему переданному TutorialId.

Теперь создадим шаг за шагом наш веб-сервис.

Шаг первый

Нам нужно создать пустое ASP.NET веб-приложение. Для этого откройте Visual Studio и создайте новый проект:

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

Шаг второй

В открывшемся окне перейдите по вкладкам C# → Веб. Выберите опцию «Веб-приложение ASP.NET (.NET Framework)» и введите необходимые данные проекта вроде названия и каталога:

Если далее у вас появилось следующее окно, выбирайте вариант «Пустой»:

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

Шаг третий

Теперь нужно создать файл нашего RESTful веб-сервиса. Для этого сначала нажмите Ctrl+Shift+A, либо кликните правой кнопкой по файлу проекта Webservice.REST и выберите опции Добавить → Создать элемент…:

В открывшемся окне найдите опцию «Служба WCF (с поддержкой технологии AJAX)» и дайте ей имя TutorialSevice.svc:

Прим. перев. Если вы не можете найти эту опцию, то попробуйте открыть Visual Studio Installer и загрузить часть среды, ответственную за работу с ASP.NET:

После выбора опции «Служба WCF (с поддержкой технологии AJAX)» Visual Studio создаст код, который будет основой для реализации веб-сервиса. WCF (Windows Communication Foundation) — библиотека, необходимая для налаживания взаимодействия между приложениями с помощью разных протоколов вроде TCP, HTTP и HTTPS. AJAX позволяет асинхронно обновлять веб-страницы, обмениваясь небольшими объёмами информации с сервером.

Шаг четвёртый

Теперь нам нужно внести изменения в конфигурационный файл Web.config. Он содержит настройки, необходимые для правильной работы приложения. Наше изменение позволит приложению отправлять и принимать данные как RESTful веб-сервис.

Откройте конфигурационный файл:

В открывшемся файле найдите строку и замените её на .

Шаг пятый

Пора приниматься за код. Откройте файл TutorialService.svc. Сначала добавим код для отображения наших данных. Создадим список со строками «Arrays», «Queues» и «Stacks». Они будут отражать имена доступных туториалов:

Шаг шестой

Теперь напишем код для нашего метода GET в том же файле. Этот метод будет запускаться при каждом вызове сервиса из браузера. Он будет использоваться для получения доступных туториалов:

Строка [WebGet(UriTemplate=»/Tutorial»)] — самая важная. Она нужна для определения того, как мы будем вызывать этот метод по URL. Если наш сервис расположен по адресу http://localhost:52645/TutorialService.svc и в его конец мы добавим «/Tutorial» и получим http://localhost:52645/TutorialService.svc/Tutorial, то будет вызван вышеприведённый код. Атрибут WebGet является параметром, который позволяет GetAllTutorials() быть RESTful-методом, который можно вызвать GET-запросом.

Цукерберг рекомендует:  Реализация полей с автозаполнением при помощи элемента datalist

В самом методе GetAllTutorials() находится код, который собирает все названия туториалов и возвращает их в одной строке.

Шаг седьмой

Код, показанный ниже, нужен для того, чтобы вернуть соответствующий TutorialName при получении GET-запроса с TutorialId :

Как и в предыдущем примере, первая строка — самая важная, так как определяет то, как мы будем вызывать этот метод. Если мы сделаем запрос http://localhost:52645/TutorialService.svc/Tutorial/1, то веб-сервис должен вернуть TutorialName , соответствующий TutorialId с индексом 1.

Метод GetTutorialByID() реализует описанную логику. Обратите внимание на то, что мы приводим TutorialId к типу Integer . Это связано с тем, что всё передаваемое в адресную строку браузера является строкой. А поскольку индексом списка не может быть строка, мы добавляем код, необходимый для преобразования в число.

Шаг восьмой

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

На первой строке находится атрибут WebInvoke , прикреплённый к нашему методу, что позволяет вызывать его с помощью POST-запроса. Для атрибутов RequestFormat и ResponseFormat мы указываем JSON, так как именно с этим форматом работает RESTful веб-сервис.

Шаг девятый

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

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

В самом методе DeleteTutorial() мы приводим переданный TutorialId к типу Integer и удаляем из списка соответствующий элемент.

В итоге код должен выглядеть так (не учитывая элементов, которые были там изначально):

Запускаем наш веб-сервис

Мы создали наш веб-сервис, пора его запустить.

Сначала кликните правой кнопкой по файлу проекта Webservice.REST и выберите опцию «Назначить автозагружаемым проектом», чтобы Visual Studio запустила этот проект при запуске всего решения:

Теперь осталось запустить проект. Рядом с кнопкой запуска будет указано имя браузера, в котором будет запускаться проект. Автоматически будет предложен браузер по умолчанию, однако вам ничто не мешает выбрать другой:

После запуска должно открыться окно браузера. Перейдите по адресу http://localhost:51056/TutorialService.svc/Tutorial и в зависимости от выбранного браузера вы увидите что-то такое:

Прим. перев. В вашем случае сервис может запуститься на localhost с другим портом. Далее в статье мы будем использовать значение 51056, однако не забывайте заменять его на своё, когда будете пытаться запускать примеры.

В этом примере браузер делает GET-запрос и тем самым вызывает написанный нами метод GetAllTutorials() , который возвращает список со всеми туториалами.

Тестируем веб-сервис

Выше мы увидели, как браузер делает GET-запрос для вызова GetAllTutorials() . Давайте проверим другие сценарии.

1. GET Tutorial/TutorialId — при вызове этого RESTful API клиент должен получить TutorialName , соответствующий переданному TutorialId .

Для вызова просто добавьте строку «/1» в конце URL, чтобы получить http://localhost:51056/TutorialService.svc/Tutorial/1. После перехода по этой ссылке вы должны увидеть следующее:

В этот раз был вызван метод GetTutorialByID() , который вернул туториал с индексом 1 — «Queues».

2. POST Tutorial/TutorialName — при вызове этого API клиент отправляет запрос на добавление переданного TutorialName , который сервер должен добавить в список. В этот раз нам понадобится инструмент Fiddler, который можно бесплатно скачать с официального сайта.

Запустите Fiddler и выполните следующие действия:

  1. Переключитесь на вкладку Composer. Она используется для создания запросов, которые можно отравить любому веб-приложению;
  2. Установите тип запроса равным «POST», а в URL вставьте адрес сервиса, в нашем случае это http://localhost:51056/TutorialService.svc/Tutorial;
  3. В окне, где уже есть строка «User-Agent: Fiddler» добавьте строку «Content-Type: application/json». Наш сервис работает только с данными в формате JSON, помните?
  4. Осталось ввести данные в поле «Request Body». Наш метод для POST-запросов принимает параметр str . Передавая строку <"str": "Trees">, мы указываем, что хотим добавить в список значение «Trees».

Нажмите на кнопку «Execute». После этого нашему сервису будет отправлен запрос на добавление «Trees».

Чтобы убедиться, что всё прошло как надо, получим список всех туториалов, перейдя по ссылке http://localhost:51056/TutorialService.svc/Tutorial. Вы должны увидеть следующее:

3. DELETE Tutorial/TutorialId — при вызове этого API клиент отправит запрос на удаление из списка TutorialName , которое соответствует переданному TutorialId .

Запустите Fiddler и выполните следующие действия:

  1. Переключитесь на вкладку Composer;
  2. Установите тип запроса равным «DELETE», а в URL вставьте адрес сервиса вместе с id элемента, который хотите удалить. Если мы хотим удалить второй элемент, то адрес будет http://localhost:51056/TutorialService.svc/Tutorial/1.

Нажмите на кнопку «Execute», чтобы отправить DELETE-запрос на удаление элемента «Queues».

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

Создание первого Web API с помощью ASP.NET Core MVC и Visual Studio¶

HTTP предназначен не только для подачи веб страниц. Он также является мощной платформой для создания API, которые раскрывают сервисы и данные. HTTP прост, гибок и общедоступен. Фактически у любой платформы есть HTTP библиотека, так что HTTP сервисы могут достичь широкого круга клиентов, включая браузеры, мобильные устройства и традиционные десктоп приложения.


В этом руководстве мы создадим просто веб API для управления списком элементов “to-do”. Никакого UI здесь мы создавать не будем.

В ASP.NET Core есть встроенная поддержка MVC Web API. Унификация двух фреймворков упрощает создание приложения, которые включают в себя и UI (HTML), и API, поскольку они сейчас делят между собой и код, и поток.

Если вы портируете существующее Web API приложение в ASP.NET Core, см. Migrating from ASP.NET Web API

Обзор¶

Вот API, который мы создадим:

API Описание Тело запроса Тело ответа
GET /api/todo Получает все элементы to-do Нету Массив элементов to-do
GET /api/todo/ Получает элемент по ID Нету Элемент To-do
POST /api/todo Добавляет новый элемент Элемент To-do Элемент To-do
PUT /api/todo/ Обновляет существующий элемент Элемент To-do Нету
PATCH /api/todo/ Обновляет существующий элемент Элемент To-do Нету
DELETE /api/todo/ Удаляет элемент Нету Нету

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

  • Клиентом является что-то, что потребляет API (браузер, мобильное приложение и тд). В этом руководстве мы не будем писать клиент. Для тестирования приложения мы будем использовать Postman.
  • Модель — это объект, который представляет в приложении данные. В данном случае единственной моделью является элемент to-do. Модели представлены как простые C# классы (POCO).
  • Контроллер — это объект, который обрабатывает HTTP запросы и создает HTTP ответы. В этом приложении будет один контроллер.
  • Для упрощения приложения мы не будем использовать БД. Элементы to-do будут храниться в памяти. Но мы включим слой доступа к данным, чтобы показать разделение между веб API и слоем данных. Если вы хотите использовать БД, просмотрите Создание первого ASP.NET Core MVC приложения с помощью Visual Studio .

Создание проекта¶

Запустите Visual Studio. Из меню File выберите New > Project.

Выберите шаблон ASP.NET Core Web Application (.NET Core). Назовите проект TodoApi , очистите Host in the cloud и нажмите OK.

В диалоговом окне New ASP.NET Core Web Application (.NET Core) — TodoApi выберите шаблон Web API. Нажмите OK.

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

Модель — это объект, который представляет в приложении данные. В данном случае модель — это элемент to-do.

Добавьте папку “Models”. В Solution Explorer кликните правой клавишей мышки по проекту. Выберите Add > New Folder. Назовите папку Models.

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

Добавьте класс TodoItem . Кликните правой клавишей мышки по папке Models и выберите Add > > TodoItem и нажмите Add.

Замените сгенерированный код следующим:

Добавления класса репозитория¶

Репозиторий — это объект, который инкапсулирует слой данных и содержит логику для получения данных и приведения их к модели. Хотя мы не используем БД, полезно посмотреть, как внедрять репозиторий в контроллеры. Создайте код для репозитория в папке Models.

Определите интерфейс репозитория с именем ITodoRepository . Используйте шаблон (Add New Item > Class).

Этот интерфейс определяет базовые операции CRUDы.

Далее, добавьте класс TodoRepository , который реализует ITodoRepository :

Соберите приложение, чтобы проверить, что ошибок компиляции нет.

Регистрация репозитория¶

При определении интерфейса репозитория мы можем отделить класс репозитория от MVC контроллера, который его использует. Вместо создания экземпляра TodoRepository внутри контроллера мы внедрим ITodoRepository , используя встроенную поддержку ASP.NET Core для DI .

Такой подход упрощает модульное тестирование контроллеров. Юнит тесты используют “mock” или “stub” версию ITodoRepository . Тогда тесты нацелены на логику контроллера, а не на слой доступа к данным.

Чтобы внедрить репозиторий в контроллер, нам нужно зарегистрировать его с помощью DI контейнера. Откройте файл Startup.cs. Добавьте следующую директиву using:

В метод ConfigureServices добавьте выделенный код:

Добавление контроллера¶

В Solution Explorer кликните правой клавишей мышки по папке Controllers. Выберите Add > New Item. В диалоговом окне Add New Item выберите шаблон Web API Controller > TodoController .

Замените сгенерированный код следующим:

Это определит класс контроллера. В следующем разделе мы добавим методы, чтобы реализовать API.

Получение элементов to-do¶

Чтобы получить элементы to-do, добавьте следующие методы в класс TodoController .

Эти методы реализуют два метода GET:

Вот пример HTTP ответа для метода GetAll :

HTTP/1.1 200 OK Content-Type: application/json; charset=utf-8 Server: Microsoft-IIS/10.0 Date: Thu, 18 Jun 2015 20:51:10 GMT Content-Length: 82

Далее в руководстве я покажу, как просмотреть HTTP ответ с помощью инструмента Postman.

Роутинг и URL пути¶

Microsoft.AspNetCore.Mvc.HttpGetAttribute` ) указывает, что это HTTP GET методы. URL путь для каждого метода построен следующим образом:

  • Возьмите строку шаблона из атрибута route контроллера, [Route(«api/[controller]»)]
  • Замените “[Controller]” именем контроллера, что является именем класса контроллера минус суффикс “Controller”. В данном примере именем класса контроллера является TodoController, а именем коревой директории — “todo”. ASP.NET MVC Core роутинг не чувствителен к регистру.
  • Если у атрибута [HttpGet] также есть строка шаблона, добавьте ее к пути. В данном примере не используется строка шаблона.

Для метода GetById “ < >todo . В рантайме, когда MVC вызывает GetById , он присваивает значение “ < >id .

В методе GetById :

«» — это переменная-заменитель для > todo . Когда вызывается GetById , он присваивает значение “ < >id .

Name = «GetTodo» создает именованный роут и позволяет вам ссылаться на этот роут в HTTP ответе. Позже я это поясню.

Возвращаемые значения¶

Метод GetAll возвращает IEnumerable . MVC автоматически сериализует объект в JSON и записывает JSON в тело ответа. Кодом ответа для этого метода является 200, если нет необработанных исключений. (Необработанные исключения переводятся в ошибки 5xx).

Метод GetById наоборот возвращает более общий тип IActionResult , который представляет широкий спектр возвращаемых типов. У GetById есть два возвращаемых типа:

  • Если ни один элемент не соответствует запрашиваемому > NotFound .
  • Иначе метод возвращает 200 с телом ответа JSON путем возвращения :dn:cls:`

Запуск приложения¶

В Visual Studio нажмите CTRL+F5, чтобы запустить приложение. Visual Studio запускает браузер и переходит по http://localhost:port/api/values , где port — это случайно выбранный номер порта. Если вы используете Chrome, Edge или Firefox, будут отображены данные. Если вы используете IE, IE предложит вам открыть или сохранить файл values.json.

Реализация других операций CRUD¶

Наконец, нам надо добавить в контроллер методы Create , Update и Delete . Я просто покажу вам код и выделю главные отличия. Соберите проект после добавления или изменения кода.

Create¶

Это метод HTTP POST, указанный атрибутом [HttpPost]. Атрибут [FromBody] говорит MVC, чтобы он получил значение элемента to-do из тела HTTP запроса.

Метод CreatedAtRoute возвращает ответ 201, являющимся стандартным ответом для метода HTTP POST, который создает новый источник на сервере. CreateAtRoute также добавляет в ответ заголовок Location. Заголовок Location определяет URI нового элемента to-do. См. 10.2.2 201 Created.

Использование Postman для отправки Create запроса¶

  • Установите HTTP метод на POST
  • Нажмите кнопку Body
  • Нажмите кнопку raw
  • Установите тип на JSON
  • В редакторе “ключ-значение” введите элемент Todo, например <"Name":" to-do item>«>
  • Нажмите Send
  • Нажмите на вкладку Headers и скопируйте заголовок Location:

Вы можете использовать заголовка Location, чтобы получить доступ к ресурсу, который создали. Снова вызовите метод GetById , созданный именованным роутом «GetTodo» :

Update¶

Update похож на Create , но он использует HTTP PUT. Ответом является 204 (No Content). В соответствии со HTTP спецификацией, запросу PUT требуется, чтобы клиент отправлял полностью обновленные данные, а не только дельты. Для частичных обновлений используется HTTP PATCH.

Обновление с Patch¶

Этот вариант похож на Update , но здесь используется HTTP PATCH. Ответом является 204 (No Content).

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

ASP.Net — это платформа для веб-разработки, созданная корпорацией Microsoft . Она была выпущена в 2002 году.

Последняя версия ASP.Net — 4.6. предназначена для работы с протоколом HTTP . Это стандартный протокол, используемый во всех веб-приложениях.

ASP.Net-приложения можно создавать на различных .Net-языках . К ним относятся C # , VB.NET и J # .

Из этой статьи об ASP.Net для начинающих вы узнаете:

  • Что такое ASP.Net ?
  • О жизненном цикле ASP.Net ;
  • О жизненном цикле страницы ASP.Net ;
  • Как создать простую программу на ASP.Net .

Что такое ASP.Net?

ASP.Net — это платформа, которая используется для разработки веб-приложений. Базовая архитектура ASP.Net приведена ниже:

Архитектура .Net Framework включает в себя следующие компоненты:

  1. Язык — в .Net для разработки веб-приложений используются VB.net и C# ;
  2. Библиотека — .NET включает в себя набор библиотек стандартных классов. В частности, библиотека Web используется для разработки веб-приложений;
  3. Common Language Runtime (CLR) — общеязыковая инфраструктура или CLI . На ее основе выполняются .Net программы. CLR используется для выполнения ключевых действий. Действия включают в себя обработку исключений и освобождение ресурсов ( Garbage Collection ).

Ключевые характеристики ASP.Net , важные для начинающих:

  • Разделения дизайна и кода — позволяет легче поддерживать приложения ASP.NET . Общий тип файлов ASP.Net — aspx . Предположим, что у нас есть веб-страница с именем MyPage.aspx . К ней должен прилагаться еще один файл с именем MyPage.aspx.cs , содержащий часть кода страницы. Таким образом, Visual Studio создает отдельные файлы для каждой веб-страницы: один для дизайна, а второй для кода.
  • Управление состоянием — ASP.Net позволяет управлять состоянием. HTTP известен, как протокол, не имеющий состояний. Давайте в качестве примера рассмотрим приложение корзины интернет-магазина. Когда пользователь решил, какой товар он хочет купить, он нажимает кнопку « Добавить в корзину ».

Приложение должно запомнить информацию, касающуюся того, что пользователь решил приобрести. Это называется запоминание состояния приложения в текущий момент времени. Протокол HTTP не поддерживает состояний. Когда пользователь переходит на страницу оплаты товара, HTTP не сохраняет информацию о товарах, находящихся в корзине. Чтобы перенести их на страницу оплаты, нужно добавить код. Такая реализация может стать более сложной. Но ASP.Net позволяет управлять состояниями: запоминать товары в корзине и передавать их на страницу оплаты.

  • Кэширование — ASP.Net реализовывает концепцию кэширования. Это улучшает производительность приложения. Кэшируя те страницы, которые часто запрашиваются, их можно держать во временном хранилище. Эти страницы можно быстрее извлечь, уменьшая время отклика. Так что кэширование может значительно повысить производительность приложения.

Жизненный цикл ASP.Net

При изучении ASP.Net mvc 4 для начинающих важно знать жизненный цикл приложения. Когда запускается приложение ASP.Net , выполняется несколько этапов. Эта цепочка составляет жизненный цикл приложения:

  1. Запуск — жизненный цикл приложения ASP.NET начинается, когда пользователь выполняет запрос, направленный на веб-сервер к приложению ASP.Net . Обычно это происходит, когда пользователь переходит на главную страницу приложения в первый раз. В течение этого времени существует метод, называемый Application_Start , который выполняется на веб-сервере. В этом методе для всех глобальных переменных устанавливаются их значения по умолчанию;
  2. Создание объектов — создание на веб-сервере HttpContext , HttpRequest и HttpResponse . HttpContext — это контейнер для объектов HTTPRequest и HTTPResponse . Объект HttpRequest содержит информацию о текущем запросе, включая куки и информацию браузера. Объект HttpResponse содержит ответ, который отправляется клиенту;
  3. Создание HttpApplication — этот объект создается на веб-сервере. Он используется для обработки каждого последующего запроса, адресованного приложению. Предположим, что у нас есть два веб-приложения. Одним из них является приложение корзины, а другое — это новостной сайт. Для каждого приложения создается объект HttpApplication . Все дальнейшие запросы к каждому сайту будут обрабатываться соответствующим экземпляром HttpApplication ;
  4. Сброс — это событие вызывается до удаления экземпляра приложения. В это время можно использовать данный метод, чтобы вручную сбросить любой неуправляемый ресурс;
  5. Конец приложения — на данном этапе приложение окончательно выгружается из памяти.

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

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

В рамках этой статьи ASP.Net для начинающих рассмотрим последовательность этапов обработки страницы:

  1. Запрос страницы — когда страница запрашивается, сервер проверяет, запрашивается ли она в первый раз. Если да, то страница создается, обрабатывается ответ и отправляется пользователю. Если страница запрашивается не в первый раз, проверяется кэш. Если страница существует в кэше, сохраненный ответ отправляется пользователю;
  2. Запуск страницы — на этом этапе создаются объекты Request и Response . Объект Request используется для хранения информации, которая была отправлена при запросе страницы. Объект Response используется для хранения информации, которая отправляется обратно пользователю;
  3. Инициализация страницы — на этом этапе инициализируются все элементы управления веб-страницы;
  4. Загрузка страницы — страница загружается со всеми значениями по умолчанию. Например, если текстовое поле должно иметь значение по умолчанию, оно загружается во время page load ;
  5. Валидация — в некоторых случаях для определенных форм может быть задана валидация. Например, может запрашиваться подтверждение того, что элемент списка содержит определенный набор значений. Если условие не выполняется, должна выводиться ошибка при загрузке страницы;
  6. Повторная обработка событий — возникает, если страница загружается снова. Это происходит в ответ на предыдущее событие. Если пользователь нажимает на кнопку отправки данных на странице. В этом случае та же страница отображается снова. Тогда вызывается повторный обработчик события;
  7. Отображение страницы — происходит перед тем, как ответ отправляется пользователю. Вся информация о форме сохраняется, а результат отправляется пользователю в виде полной веб-страницы;
  8. Выгрузка — после того, как страница отправляется пользователю, больше нет необходимости хранить объекты веб-формы в памяти. Таким образом, процесс выгрузки включает в себя удаление всех ненужных объектов из памяти.

Программа «Hello World» в ASP.Net

Изучение ASP.Net web forms для начинающих лучше начать с создания простого приложение « Hello, World «. Для этого необходимо выполнить следующие шаги.

Шаг 1: Создание нового проекта в Visual Studio . После запуска Visual Studio нужно выбрать пункт меню Новый> Проект :

Шаг 2: Следующим шагом является выбор типа проекта — веб-приложение ASP.NET . Здесь нужно указать название и расположение проекта.

  1. В диалоговом окне проекта выберите вариант « Веб » в левой панели. А затем « Веб-приложение ASP.Net »;
  2. Задайте имя приложения и место его хранения;
  3. Нажимаем на кнопку « OK », чтобы Visual Studio создал проект.

Шаг 3: В следующем окне нужно выбрать тип веб-приложения ASP.NET , которое должно быть создано. Мы хотим создать простое приложение веб-формы.

  • Выберите тип проекта – « Пустой »;
  • Выберите опцию « Веб-форма ». После этого будут добавлены общие папки. Они необходимы для создания базового приложения веб-формы;
  • В конце нажимаем на кнопку « OK », чтобы Visual Studio создал приложение.

Если вы выполните указанные выше шаги руководства ASP.Net для начинающих, то получите в Visual Studio результат, продемонстрированный на рисунке ниже:

В « Solution explorer » появится приложение DemoApplication . Оно содержит два файла проекта, как показано на рисунке выше. Один из ключевых файлов проекта — это Global.asax.cs . Он содержит информацию конкретного приложения. В этом файле можно инициализировать все переменные, определив для них значения по умолчанию.

Шаг 4: Теперь пришло время добавить в проект файл веб-формы. Это файл, который будет содержать весь код проекта.

  • Кликните правой кнопкой мыши по DemoApplication ;
  • Выберите из контекстного меню пункт Добавить> Веб-форма .

Шаг 5: В следующем окне задайте имя веб-формы. В нашем случае это будет Demo .

Visual Studio автоматически создаст веб-форму Demo и откроет ее.

Шаг 6: Следующим шагом является добавление кода, который позволит отобразить « Hello World «. Это можно сделать, добавив одну строку кода в файл Demo.aspx :


  • Объект Response в ASP.Net используется для передачи информации обратно пользователю. В данном случае мы используем метод Write объекта Response , чтобы написать текст « Hello World «. Маркеры используются для добавления специфического кода ASP.net .

Если вы выполните все шаги, перечисленные в этой статье об ASP.Net mvc для начинающих и запустите созданную программу в Visual Studio , то получите следующий результат:

В окне браузера отображается фраза « Hello, World «.

ASP.NET Core Developer

ASP.NET Core-разработчик — специалист в области разработки веб-приложений с использованием технологии от компании Microsoft — ASP.NET Core.

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

В основе ASP.NET Core лежит успевший себя зарекомендовать с хорошей стороны язык программироания C#. В распоряжении ASP.NET Core-программиста будут такие мощные инструменты, как LINQ, лямбда-выражения и множество различного «синтаксического сахара», в значительной мере упрощающего процесс разработки — в основном за счет увеличения скорости написания кода и меньших затратах на поддержку. Также при желании разработчик легко сможет компонировать другие языки .NET группы, а именно: Visual Basic и F#.

Приставка Core говорит о том, что фреймворк исполнен на базе самой новой платформы, релиз которой ознаменовал переход к новой эре разработки под эгидой Microsoft. Речь идет о стандарте .NET Core.

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

Что же уникального привносит Core-технология в сравнении с .NET Framework? Во-первых (и самое главное) — это кросс-платформенность. Теперь разработчик сможет запустить .NET-приложение не только под Windows, но и под Linux или даже MacOS. Во-вторых, это скорость работы программ, которая, в сравнении с предыдущей версией, стала несколько выше. Третье преимущество — полностью открытый исходный код платформы, благодаря чему каждый желающий сможет приобщиться к развитию или изучить особенности работы новой технологии.

Создание страниц 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 Core, MVC, Entity Framework Core, Bootstrap, и Angular

Building a Web App with ASP.NET Core, MVC, Entity Framework Core, Bootstrap, and Angular

Этот курс поможет вам создать веб-приложение с нуля, используя ASP.NET Core 2.0, Visual Studio 2020, Entity Framework Core 2.0, Bootstrap 3.3 и Angular (v4.3).

Создание веб-приложения — сложная задача, требующая знания многих разных навыков. В этом курсе, создавая веб-приложение с ASP.NET Core, MVC, Entity Framework, бутстрапом и Angular, вы узнаете как создать серверный код, код на стороне клиента и спроектировать внешний вид веб-приложение. Во-первых, вы изучите ASP.NET Core 2 и MVC 6 для создания кода на стороне сервера. Затем вы узнаете, как использовать JavaScript, TypeScript и Angular 4 для клиентского кода. Наконец, вы будете вникать в использование HTML, CSS и Bootstrap для дизайна своего веб-приложения. Когда вы закончите с этим курсом, вы получите базовые знания ASP.NET Core 2, которые помогут вам при продвижении к созданию веб-приложений.

Необходимое программное обеспечение: Visual Studio 2020.

Курс 20486D: Разработка Web приложений с использованием ASP.NET Core MVC

Visual Studio

SharePoint

Этот курс в нашем Центре
успешно закончили
5131 человек!

Developing ASP.NET Core MVC Web Applications

Внимание! Данный курс участвует
в программе Microsoft Plus.

А это значит, что уже с первого занятия вместе с учебными материалами вам будет предоставлен полугодовой доступ к практическим тестам Measure Up в подарок. В свободное от занятий время Вы сможете проверить и закрепить полученные знания.

Увлекательно и эффективно — запоминаемость увеличивается
с 20 вплоть до 90%.

Курс читается по последней версии!

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

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

Для обучения на данном курсе Вам необходим действующий доступ к аккаунту Microsoft Azure. Примите во внимание, что получение нового доступа может занимать до 48 часов. Если у Вас нет доступа – просьба сообщить об этом Вашему менеджеру при записи на обучение. В этом случае мы предоставим Вам trial-версию: 30-дневный Windows Azure Pass.

Вам необходима усиленная практика? Готовитесь к сдаче сертификационных экзаменов Microsoft? Приобретите доступ к Labs Online – виртуальным лабораторным работам по авторизованным курсам Microsoft – в течение всего курса и двух недель по окончании обучения! Услуга уникальна и доступна только в Центре «Специалист»

Скидка до 60% всем слушателями и выпускникам Центра «Специалист» на курсы английского языка.

Скидка не суммируется с программой «Резерв» и другими скидками Центра «Специалист».

По окончании курса Вы будете уметь:

  • Описывать основные технологии Microsoft в области веб-разработки и выбирать наиболее подходящие для решения ваших задач.
  • Проектировать веб-приложения, удовлетворяющие различным требованиям.
  • Создавать модели шаблона CORE MVC и реализовывать бизнес-логику в рамках этих моделей.
  • Создавать контроллеры CORE MVC приложения, взаимодействующие с пользователями, моделями и представлениями данных.
  • Создавать представления CORE MVC приложения, предназначенные для отображения и редактирования данных, а также для взаимодействия с моделями и контроллерами.
  • Создавать unit-тесты и использовать средства отладки Visual Studio при разработке веб приложений.
  • Создавать веб-приложения, использующие удобочитаемые для человека URL.
  • Использовать единый интерфейс и стиль в Вашем MVC приложении.
  • Ускорить взаимодействие с пользователем за счет кэширования и частичного обновления страниц.
  • Создавать клиентский код на JavaScript, использующий библиотеку jQuery.
  • Создавать защищенные CORE MVC приложения.
  • Использовать веб-сервисы Microsoft Azure из Вашего CORE MVC приложения.
  • Разворачивать CORE MVC приложения.

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

Первые страницы на ASP.NET

Первые страницы на ASP.NET дают первоначальное знакомство с солидной технологией создания веб-приложений. Не усложняя первые шаги фреймворками WebForms, MVC, WebAPI создадим простые веб-страницы с внедренным программным кодом для двух обработчиков представлений — ASPX и Razor. Обработчики кода, называемые еще механизмами визуализации или движками, предназначены для динамического создания веб-страницы путем замены программного кода соответствующей html разметкой.

Движок ASPX — стандартная модель добавления кода на веб-страницу ASP.NET. ASPX использует блоки объявления типов, процедур и переменных и встроенный блок отрисовки html разметки . Модель добавления программного кода ASPX с некоторыми изменениями перешла в ASP.NET из первой платформы ASP.

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

Для создание первых веб-страниц будем использовать бесплатную программную среду для работы с веб-сайтами WebMatrix. На текущий момент создана 3-я версия этого, достаточного для создания профессиональных сайтов, инструмента программирования. Скачать ее можно с сайта компании Microsoft по ссылке WebMatrix. В состав программы WebMatrix входит все необходимое для создания и тестирования веб-сайтов на основе ASP.NET: редактор кода с подсветкой и IntelliSense, вебсервер IIS Express, система управления базами данных SQL LocalDB.

Сайт включает из три страницы: главная и две одинаковые страницы динамического создания таблиц на движках ASPX и Razor. Размерность таблицы можно задавать в строке запроса двумя параметрами. Надо сказать, что в принципе оба обработчика эффективно создают html разметку, но предоставляют разный комфорт работы.

Движок ASPX требует заключения всех частей и частичек программного кода в блоки вида . Типы, процедуры и переменные можно объявлять в блоке . Атрибут runat=»server» отличает данный блок от блока javascript и обозначает обработку кода в этом блоке непосредственно на сервере.

Листинг №1 Вебстраница на движке ASPX

Ниже показан код веб страницы для обработчика внедренного программного кода Razor. Обратите внимание на гармоничное слияние html кода и выражений на языке C#. Движок Razor позволяет использовать html теги непосредственно внутри программного кода: интеллектуальная составляющая обработчика ловко отделяет html разметку от программного кода C#.

Листинг №2 Вебстраница на движке Razor

Протестировать работу сайта можно несколькими способами:

  1. MS Visual Studio — Файл->Открыть веб-сайт ->Выбрать папку в которую распакован архив Запуск в браузере (или клавиша F5)
  2. WebMatrix — Открыть->Папка->Выбрать папку в которую распакован архив сайта->Выбор папки Запуск
  3. Распаковать архив в физическую папку локального или интернет сайта. Запустите сайт в браузере по его URL адресу.

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

Программист ASP.NET MVC C#

Кнопка для разрабоки, просьба не нажимать

Asp.net для начинающих: Базовые понятия в ASP.NET MVC. Создание проекта

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

Запустите Visual Studio, в меню выберите «File»->»New»->»Project. «

В открытом окне выбираем из списка Installed Templates «Web» (1). Дальше выбираем «ASP.NET MVC 3 Web Application» (2). Пишем название проекта и путь к каталогу, где оно будет находиться (3)

Жмем ОК. В следующем окне оставляем выбранным «Internet Application» и жмем ОК

У нас создаться базовый проект asp.net mvc. После нажатия клавиши F5 (Start Debugging), мы увидим наш сайт (запуститься виртуальный IIS и на панели Пуск появится значок, которые отображает его работу). Каждый сайт запущенный с помощью Visaul Studio работает на каком-то порту (например, localhost:29663) по этому не волнуйтесь, если цифры у Вас будут отличатся от моих.

Что же нам насоздавала студия, и как работает asp.net mvc приложение.

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

Когда мы открываем какой-то сайт (например www.aspnet.com.ua/Category/category-3.aspx), то отправляется запрос на сервер (это равносильно событию нажатия какой-то кнопки в дескоп приложений), и говорим серверу отдать нам какую-то информацию (в нашем примере отдать инфу о «категории 3» сайта aspnet.com.ua).

Сервер, в свою очередь, либо знает эту команду (этот url) и отдает нам нужную инфу, либо возвращает ошибку (например страничку 404). После того, как сервер команду выполнил, он про нас запрос забывает.

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

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

На заметку. Технология asp.net forms стремилась к такому принципу: легко напоминать серверу, какие действия применялись до этого клиентом и какую информацию клиент уже получил. Так появилось понятия ViewState — это сохраненная информация состоянии странички. Но эта технология была не удачной

Перейдем теперь к тому, как работает asp.net mvc технология. (Сейчас я опишу совсем базовые вещи, многие шаги упущены для простоты).

Для начала откройте окно «Solutin Explorer» в VS (если его нет, то его можно найти в меню «View»-> «Solutin Explorer»). В нем мы увидим все файлы проекта. (это окно удобно разместить справа, так как мы постоянно будем ним пользоваться).

Нас сейчас интересует папка Controllers — в ней мы создаем файлики, которые будут обрабатывать наши действия (обрабатывать наши url). Так же нас интересует файл Global.asax, в нем мы будет задавать какой файл из папки Controllers какой url будет обрабатывать. Откроем файл Global.asax и найдем вот такой код:

public static void RegisterRoutes(RouteCollection routes)
<
routes.IgnoreRoute(«.axd/<*pathInfo>«);

Это правило привязки url к Controllers. Удалим строку с «routes.MapRoute. » по «. UrlParameter.Optional > );» Вместо нее мы напишем свои три правила:

routes.MapRoute(
«Root», // название правила
«», // какой URL
new < controller = "Home", action = "Index" >//какой файл controller
);

routes.MapRoute(
«Home-About», // название правила
«About.aspx», // какой URL
new < controller = "Home", action = "About" >//какой файл controller
);

routes.MapRoute(
«Account-LogOn», // название правила
«Account/LogOn.aspx», // какой URL
new < controller = "Account", action = "LogOn" >//какой файл controller
);

Каждое правило имеет свое название, которое не должно повторятся («Root» «Home-About» «Account-LogOn»). Так же каждое правило должно указывать URL и controller, который будет это действие обрабатывать.

Сейчас в моем сайте есть три странички/три правила:

Account/LogOn.aspx — ее будет обрабатывать контроллер AccountController и метод этого контроллера LogOn

About.aspx — эту страничку будет обрабатывать контроллер HomeController и метод этого контроллера About

корневая стр — ее будет обрабатывать контроллер HomeController и метод этого контроллера Index

Теперь откроем файл HomeController (для открытия файлов пользуйтесь «Solutin Explorer») в этом файле вы увидите класс HomeController, которые наследуется от класса Controller и два метода этого класса Index и About. Эти методы и будут обрабатывать наши url.

Основная логика работы приложения пишется в этих методах (например считывания или внесение информации в базу данных). Давайте мы в методе Index считаем серверное время, а вот в методе About посчитаем сколько будет 345 умножить на 23.

public class HomeController : Controller
<
public ActionResult Index()
<
var date = DateTime.Now;

public ActionResult About()
<
var result = 345 * 23;
return View();
>
>

Теперь нам нужно результат свои действий отобразить пользователю. В web приложениях это делается с помощью html страничек. Эти странички, как правило, находятся в папке View (пользуйтесь «Solutin Explorer»). В папке View для каждого контролера создается своя папка с названием этого контроллера (так легче ориентироваться). Создадим несколько страничек.

Правой клавишей нажимаем на папке «Home» в контекстном меню выбираем «Add»->»View. «

Перед нами откроется окно, в котором мы укажем имя нашей страничке «ViewDateTime». Так же нужно убрать галочку «Use layout or master page», о ней мы поговорим позже. Итак, окно должно иметь вид:

Жмем Add. Студия создаст нам файл ViewDateTime.cshtml и создаст в нем базовую структуру html. Таким же образом добавим еще файл ViewResult

Вернемся теперь к нашим методам контролера. Изменим строку «return View();» в методе Index на «return View(«

/Views/Home/ViewDateTime.cshtml», date);» а в методе About на «return View(«

Это означает, что результат своих действий мы будем отображать на представлениях (View) ViewDateTime и ViewResult соответственно, так же мы в эти представления передали date и result.

Что бы упростить жизнь программистам и не писать всегда длинный путь («

/Views/Home/. cshtml) к файлам отображения принято использовать такие правила:

    return View(); // означает, что файл отображения находиться в папке с именем контролера, а файл имеет тоже название что и метод. Пример, для метода Index контролера HomeController представление будет находиться «

/Views/Home/Index.cshtml»
return View(«MyView»); // означает, что файл отображения находиться в папке с именем контролера, а файл имеет название MyView. Пример, для метода Index контролера HomeController представление будет находиться

Исходя из выше сказанного еще раз изменим строки кода: метод Index будет возвращать return View(«ViewDateTime», date); а метод About вернет return View(«ViewResult», result);

Теперь обратите внимания, что кроме указания View-файла мы еще передаем данные для отображения (date и result). Сейчас нам нужно настроить их корректное отображение.

Откроем файл ViewDateTime.cshtml и вначале добавим код «@model DateTime». Он означает, что файл ViewDateTime будет отображать переменную типа DateTime. Если бы мы не задавали, какой тип переменой будет отображать данное представление, то код был бы рабочим, но тогда на этой страничке у нас не было подсказки. Между тегами добавим код @Model.ToShortDateString().

Используя код @Model — мы обращаемся к объекту, который передали в View. Полный код файла ViewDateTime.cshtml

@model DateTime
@ <
Layout = null;
>

Цукерберг рекомендует:  C++ - Помогите исправить ошибку в программе
Понравилась статья? Поделиться с друзьями:
Все языки программирования для начинающих