Основы шаблонов С++: шаблоны функций
Дисклаймер: статья была начата еще в феврале, но, по зависящим от меня причинам, закончена не была. Тема очень обширна, поэтому публикуется в урезанном виде. Что не поместилось, будет рассмотрено позже.
Невозможно разбираться в современном С++, не зная, что такое шаблоны программирования. Данное свойство языка открывает широкие возможности оптимизации и повторного использования кода. В данной статье попробуем разобраться, что это такое и как это всё работает.
Механизм шаблонов в языке С++ позволяет решать проблему унификации алгоритма для различных типов: нет необходимости писать различные функции для целочисленных, действительных или пользовательских типов – достаточно составить обобщенный алгоритм, не зависящий от типа данных, основывающийся только на общих свойствах. Например, алгоритм сортировки может работать как с целыми числами, так и с объектами типа «автомобиль».
Существуют шаблоны функций и шаблоны классов.
Рассмотрим более подробно шаблоны функций.
Шаблоны функций
Как написать первую шаблонную функцию?
Рассмотрим случай определения минимального элемента из двух. В случае целых и действительных чисел придется написать 2 функции.
Можно, конечно, реализовать только одну функцию, с действительными параметрами, но для понимания шаблонов это будет вредным.
Что произойдёт в случае компиляции приложения? Обе реализации функции попадут в бинарный код приложения, даже если они не используются (впрочем, сейчас компиляторы очень умные, умеют вырезать неиспользуемый код). А если необходимо добавить функцию, определяющую минимальную из 2 строк (сложно представить без уточнения, что есть минимальная строка)?!
В этом случае, если алгоритм является общим для типов, с которыми приходится работать, можно определить шаблон функции. Принцип, в общем случае, будет следующим:
Самым интересным является тот факт, что пока нет вызова функции min, при компиляции она в бинарном коде не создается (не инстанцируется). А если объявить группу вызовов функции с переменными различных типов, то для каждого компилятор создаст свою реализацию на основе шаблона.
Вызов шаблонной функции, в общем, эквивалентен вызову обыкновенной функции. В этом случае компилятор определит, какой тип использовать вместо Type, на основании типа фактических параметров. Но если подставляемые параметры окажутся разных типов, то компилятор не сможет вывести (инстанцировать шаблон) реализацию шаблона. Так, в ниже следующем коде компилятор споткнётся на третьем вызове, так как не может определить, чему равен Type (подумайте, почему?):
Решается эта проблема указанием конкретного типа при вызове функции.
Шаблоны (справочник по C#)
Возможность использовать сопоставление шаблонов впервые появилась в C# 7.0. С тех пор в каждой новой основной версии C# возможности сопоставления шаблонов расширяются. Сопоставление шаблонов поддерживают следующие выражения и операторы C#:
В этих конструкциях можно сравнить входное выражение с любым из следующих шаблонов:
Логические шаблоны, шаблоны свойств и позиционные шаблоны являются рекурсивными шаблонами. То есть, они могут содержать вложенные шаблоны.
Пример использования этих шаблонов для создания управляемого данными алгоритма можно посмотреть в разделе Учебник: использование сопоставления шаблонов для создания управляемых типами и управляемых данными алгоритмов.
Шаблоны объявления и шаблоны типов
Шаблоны объявления и шаблоны типов используются для проверки того, совместим ли с указанным типом тип определенного выражения в среде выполнения. С помощью шаблона объявления можно также объявить новую локальную переменную. Если шаблон объявления соответствует выражению, этой переменной присваивается результат преобразованного выражения, как показано в следующем примере:
Начиная с C# 7.0, шаблон объявления с типом T соответствует выражению в том случае, если результат выражения имеет значение, отличное от NULL, и выполняется любое из следующих условий:
В следующем примере показаны два последних условия:
Начиная с C# 9.0, для этой цели можно использовать шаблон типа, как показано в следующем примере:
Как и шаблон объявления, шаблон типа соответствует выражению, если результат выражения не равен NULL, а его тип в среде выполнения удовлетворяет любому из указанных выше условий.
Дополнительные сведения см. в разделах Шаблон объявления и Шаблон типа в примечаниях к предлагаемой функции.
Шаблон константы
Начиная с C# 7.0, вы можете использовать шаблон константы для проверки того, равен ли результат выражения заданной константе, как показано в следующем примере:
В шаблоне константы можно использовать любое константное выражение, например:
Начиная с C# 9.0, вы можете использовать шаблон константы null с отрицанием для проверки неравенства значению NULL, как показано в следующем примере:
Дополнительные сведения см. в разделе Шаблон константы в примечании к предлагаемой функции.
Реляционные шаблоны
Начиная с C# 9.0, вы можете использовать реляционный шаблон для сравнения результата выражения с константой, как показано в следующем примере:
Чтобы проверить, находится ли результат выражения в определенном диапазоне, сопоставьте его с шаблоном конъюнкции ( and ), как показано в следующем примере:
Если результат выражения — null или его не удается преобразовать в тип константы с помощью преобразования, допускающего значение NULL, или распаковки-преобразования, то реляционный шаблон не соответствует выражению.
Дополнительные сведения см. в разделе Реляционные шаблоны в примечании к предлагаемой функции.
Логические шаблоны
Как показано в предыдущем примере, блоки объединения в шаблоне можно использовать многократно.
Дополнительные сведения см. в разделе Блоки объединения шаблонов в примечании к предлагаемой функции.
Шаблон свойства
Начиная с C# 8.0, вы можете использовать шаблон свойства для сопоставления свойств или полей выражения с вложенными шаблонами, как показано в следующем примере:
Шаблон свойства соответствует выражению, если результат выражения не равен NULL, а каждый вложенный шаблон соответствует соответствующему свойству или полю результата выражения.
Вы также можете добавить проверку типа среды выполнения и объявление переменной в шаблон свойства, как показано в следующем примере:
Шаблон свойства является рекурсивным шаблоном. Это значит, что любой шаблон можно использовать как вложенный шаблон. Используйте шаблон свойства для сопоставления элементов данных с вложенными шаблонами, как показано в следующем примере:
В предыдущем примере используются две возможности, доступные в C# 9.0 и более поздних версиях языка: блок объединения шаблонов or и типы записей.
Начиная с C# 10 можно ссылаться на вложенные свойства или поля в шаблоне свойства. Например, можно выполнить рефакторинг метода из предыдущего примера в следующий эквивалентный код:
Дополнительные сведения см. в разделе Шаблон свойства в примечании к предлагаемой функции и примечание к предлагаемой функции Расширенные шаблоны свойств.
Позиционный шаблон
Начиная с C# 8.0, вы можете использовать позиционный шаблон для деконструкции результата выражения и сравнения результирующих значений с соответствующими вложенными шаблонами, как показано в следующем примере:
В предыдущем примере тип выражения содержит метод Deconstruct, используемый для деконструкции результата выражения. Можно также сопоставлять выражения кортежных типов с позиционными шаблонами. Таким образом можно сопоставить несколько входных значений с различными шаблонами, как показано в следующем примере:
В предыдущем примере используются реляционные и логические шаблоны, доступные в C# 9.0 и более поздних версиях языка.
Можно также расширить позиционный шаблон одним из следующих способов:
Добавьте проверку типа среды выполнения и объявление переменной, как показано в следующем примере:
Используйте шаблон свойства в позиционном шаблоне, как показано в следующем примере:
Можно объединить два предыдущих варианта, как показано в следующем примере:
Позиционный шаблон является рекурсивным шаблоном. Это значит, что любой шаблон можно использовать как вложенный шаблон.
Дополнительные сведения см. в разделе Позиционный шаблон в примечании к предлагаемой функции.
Шаблон var
В шаблоне var тип объявленной переменной равен установленному во время компиляции типу выражения, сопоставляемого с данным шаблоном.
Дополнительные сведения см. в разделе Шаблон var в примечании к предлагаемой функции.
Шаблон пустой переменной
В предыдущем примере шаблон пустой переменной используется для обработки значения null и любых целочисленных значений, которые не соответствуют имеющимся членам перечисления DayOfWeek. Благодаря этому гарантируется, что выражение switch в приведенном примере сможет обработать все возможные входные значения. Если в выражении switch не используется шаблон пустой переменной и при этом ни один из шаблонов выражения не соответствует входным данным, среда выполнения генерирует исключение. Если выражение switch не обрабатывает все возможные входные значения, компилятор генерирует предупреждение.
Дополнительные сведения см. в разделе Шаблон пустой переменной в примечании к предлагаемой функции.
Шаблон в круглых скобках
Начиная с C# 9.0, вы можете использовать круглые скобки вокруг любого шаблона. Как правило, это делается для того, чтобы подчеркнуть или изменить приоритет логических шаблонов, как показано в следующем примере:
Спецификация языка C#
Дополнительные сведения см. в следующих примечаниях к предлагаемой функции.
Шаблоны данных
»» В ДАННОЙ СТАТЬЕ ИСПОЛЬЗУЕТСЯ ИСХОДНЫЙ КОД ДЛЯ ПРИМЕРОВ
Стили предоставляют некоторые базовые возможности форматирования, но они не преодолевают наиболее существенные ограничения списков, которые демонстрировались до сих пор: независимо от того, как изменяется ListBoxItem, это всего лишь ListBoxItem, а не более сложная комбинация элементов. И поскольку каждый ListBoxItem поддерживает только одно привязанное поле, нет способа создать развитый список, включающий в себя множество полей или графических изображений.
Однако в WPF есть другой инструмент, который может преодолеть эти тесные рамки, позволив использовать комбинацию свойств привязанного объекта и скомпоновать его специфическим способом либо отобразить визуальное представление, более сложное, чем простая строка. Этим инструментом является шаблон данных.
— это фрагмент XAML-разметки, который определяет, как привязанный объект данных должен быть отображен. Шаблоны данных поддерживают два типа элементов управления:
Элементы управления содержимым поддерживают шаблоны данных через свойство ContentTemplate. Шаблон содержимого используется для отображения того, что помещается в свойство Content.
Списочные элементы управления (элементы, унаследованные от ItemsControl) поддерживают шаблоны данных через свойство ItemTemplate. Этот шаблон используется для отображения каждого элемента списка из коллекции (или каждой строки из DataTable), которая применяется в качестве ItemsSource.
Средство основанного на списке шаблона на самом деле базируется на шаблонах элементов управления с содержимым. Причина в том, что каждый элемент в списке помещен в оболочку элемента управления содержимым, такого как ListBoxItem для ListBox, ComboBoxItem для ComboBox и т.д. Какой бы шаблон не был указан для свойства ItemTemplate списка, он используется как ContentTemplate каждого элемента в списке.
Так что же можно поместить внутрь шаблона данных? На самом деле все довольно просто. Шаблон данных — это простой блок XAML-разметки. Подобно любому другому блоку XAML-разметки, шаблон может включать любую комбинацию элементов. Он также должен включать одно или более выражений привязки, которые извлекают информацию для отображения. (В конце концов, если не предусмотреть никаких выражений привязки данных, то каждый элемент в списке будет выглядеть одинаково, от чего мало толку.)
Ниже приведен пример, в котором каждый элемент списка заключается в прямоугольник со скругленными углами, отображаются две порции информации, и используется форматирование полужирным начертанием для выделения марки машины:
Когда этот список привязывается, для каждого автомобиля создается отдельный объект Border. Внутри элемента Border находится Grid с двумя порциями информации, как показано на рисунке:
Отделение и повторное использование шаблонов
Подобно стилям, шаблоны часто объявляются как ресурс окна или приложения, который определен в списке, где он используется. Такое отделение часто более ясно, особенно если применяются длинные сложные шаблоны или множество шаблонов к одному и тому же элементу управления. Это также дает возможность повторно использовать шаблоны в более чем одном списочном элементе управления или элементе с содержимым, если нужно представлять данные одинаковым образом в разных местах пользовательского интерфейса.
Все, что потребуется — это определить шаблон данных в коллекции ресурсов и назначить ему ключевое имя. Ниже приведен пример извлечения шаблона, показанного в предыдущем примере:
Теперь шаблон данных можно применить с использованием ссылки StaticResource:
Если нужно автоматически повторно использовать тот же шаблон данных в других типах элементов управления, можно воспользоваться другим интересным трюком — установить свойство DataTemplate.DataType, чтобы идентифицировать тип привязанных данных, для которых должен применяться шаблон. Например, предыщущий пример можно было бы изменить, исключив ключ и указав этот шаблон, как предназначенный для привязки объектов CarTable, независимо от того, где они появляются:
В разметке предполагается, что определен префикс пространства имен XML по имени databinding, отображенный на пространство имен проекта.
Теперь этот шаблон будет использован с любым списочным элементом или элементом управления содержимым в данном окне, который привязан к объектам CarTable. Настройку ItemTemplate указывать не нужно.
Шаблоны данных не требуют привязки данных. Другими словами, использовать свойство ItemsSource для заполнения шаблона списка не понадобится. В предыдущих примерах добавлять объекты CarTable можно было декларативно (в XAML-разметке) или программно (вызывая метод ListBox.Items.Add()). В обоих случаях шаблон данных работает одинаково.
Более развитые шаблоны
Шаблоны данных могут быть замечательно самодостаточными. Наряду с базовыми элементами, такими как TextBlock и выражениями привязки данных, они также используют более изощренные элементы управления, присоединенные обработчики событий, преобразуют данные в различные представления, применяют анимацию и т.д.
Стоит рассмотреть пару небольших примеров, которые демонстрируют, насколько мощными могут быть шаблоны данных. Прежде всего, в привязке данных могут быть использованы различные объекты конвертеров, чтобы преобразовывать данные в более удобное представление (выше было показано как использовать конвертер StringUpperConverter, который преобразует названия машин в верхний регистр).
В следующем примере применяется показанный ранее конвертер ImagePathConverter для вывода изображений машин в списке:
Хотя данная разметка не содержит ничего экзотического, в результате получается более интересный список:
Селекторы шаблонов
Селекторы шаблонов работают точно так же, как рассмотренные ранее селекторы стилей — они проверяют привязанный объект и выбирают подходящий шаблон на основе заданной логики.
Ранее было показано, как строить селектор стилей, который ищет определенные значения и выделяет их стилем. Ниже приведен аналогичный селектор шаблонов:
А вот разметка, создающая два шаблона:
Ниже показана разметка, применяющая селектор шаблонов:
Как видите, селекторы шаблонов намного мощнее селекторов стилей, потому что каждый шаблон может отображать разные элементы, организованные в разной компоновке. Один недостаток этого подхода связан с тем, что, скорее всего, придется создавать несколько похожих шаблонов. В случае сложных шаблонов это может привести к большому объему дублирования. Чтобы облегчить сопровождение, не следует создавать слишком много шаблонов для одного списка; вместо этого используйте триггеры и стили для применения различного форматирования к шаблонам.
Шаблоны отображения и редактирования данных в ASP.NET MVC 2
Перевод серии статей посвящённых шаблонам отображения и редактирования.
Часть первая. Введение.
Введение в шаблоны
Одно из главных новых нововведений в ASP.NET MVC — это шаблоны.
Шаблоны подобны динамическим данным (Dynamic Data) в классическом ASP.NET. По существующему объекту данного типа, система автоматически генерирует разметку для его отображения или редактирования, вне зависимости от того представляет ли собой объект простые данные (integer, decimal, string и т.п.), или же является представителем класса.
Html.Display
Для того чтобы отобразить элемент, используется три метода отображения (каждый из которых имеет по несколько перегрузок):
1-ый метод, может использоваться для показа данных как из ViewData, так и из модели, тип которой вы можете и не знать.
Следующий метод используется в основном для передачи данных из модели. Кроме того, этот метод можно использовать, например, полностью игнорируя значения исходных данных (model => someOtherValue).
И последний метод является хелпером, для текущей модели. Метод DisplayForModel эквивалентен записи DisplayFor(model => model).
Начнём примеры с модели:
В результате получим такую страничку:
Html.Editor
Подобно Html.Display, также три метода, которые используются для генерации html для редактирования объекта:
Если я поменяю в своём View метод DisplayForModel на EditorForModel, то страница будет выглядеть так:
Как видите, система сгенерировала текстбоксы для строк и для целых значений.
Что происходит на самом деле?
Система шаблонов в MVC 2 содержит несколько встроенных шаблонов.
Для того чтобы отобразить объект, система использует рефлексию для поиска всех свойств объекта, затем генерирует разметку для каждого из свойств.
Если вы не будете использовать шаблоны, то разметка может выглядеть примерно так:
Стоит иметь в виду, что сейчас это ещё не законченная реализация. Я расскажу чего здесь не хватает позже.
Это основа шаблона для отображения сложного объекта: пройтись по всем свойствам текущей модели, для каждой из них показать лэйбл и вызвать метод Html.Display() для отображения значения свойства.
Что происходит когда мы хотим показать строку? А происходит приблизительно следующее:
И снова, это не реальный код, То что происходит на самом деле, обсуждается позже.
Подмена шаблонов
Существует множество достоинств встроенных шаблонов, но пожалуй самое важное, это возможность подменить их в любом месте рендеринга.
Давайте рассмотрим пример подмены шаблона для строк. Для этого создадим partial view, который назовём String и расположим в папке
Обновив страницу мы увидим:
Как видите, новый шаблон был подставлен автоматически и нам не понадобилось просматривать все наши строки. Однако, шаблон применился и к свойству Age, тип которого на самом деле является целым, но об это поговорим чуть позже.
Если нам понадобится написать шаблон для редактирования, то его необходимо разместить в папке EditorTemplates.
Часть вторая. ModelMetadata
Осмысление модели
Один из новых классов, появившийся вместе с ASP.NET MVC 2 — это Model Metadata. Этот класс разработан для того, чтобы сообщить вам необходимую информацию об объекте для его отображения. И хотя в основном это используется для написания шаблонов, метаданные доступны всегда, не только в шаблонах.
Что такое Model?
В контексте использования ModelMetadata, определение понятия «Model» немного расплывается.
Рассмотрим опять же модель из предыдущей части:
Мы создали строго-типизированное представление для этой модели. Если в этом представлении вы обратитесь к ViewData.ModelMetadata, то модель в этом случае будет объект класса Contact.
Однако, с помощью объекта метаданных вы можете получить информацию обо всех свойствах объекта. Вы можете получить коллекцию объектов ModelMetadata для каждого из свойств. В контексте нашего примера, мы получим 3 новых метаобъекта, для FirstName, LastName и Age. Если вы посмотрите на метаданные для свойства FirstName, вы увидите что тип данных модели string, а тип объекта-контейнера — Contact. Таким образом вы можете рекурсивно перебрать все свойства сложного объекта.
Где мне взять ModelMetadata?
Используя текущую модель.
Самый простой способ получить доступ к метаданным — это использовать свойство ViewData. В этом случае ModelMetadata описывает модель, представленную в ViewData. В случае рендеринга шаблона для объекта, этот способ является самым простым.
Получить одно из свойств метаданных, которые у вас уже есть.
Если у вас уже есть объект метаданных, вы можете использовать свойство Properties, которое возвращает список объектов ModelMetadata для каждого свойства.
Класс ModelMetadata имеет два статических метода: FromStringExpression и FromLambdaExpression. Эти методы используются когда мы хотим получить из выражения (к примеру «PropertyName» или «m => m.PropertyName») соответствующие метаданные. Большинство существующих HTML хелперов уже переписаны в рамках этих двух методов.
Что у них внутри?
Перед тем как говорить от том как работать с ModelMetadata, давайте посмотрим какую информацию предоставляет объект класса ModelMetadata.
Свойства относящиеся к модели и её контейнеру:
Значение по умолчанию для SimpleDisplayText следует следующим правилам:
Как формируется ModelMetadata?
Мы добавили настраиваемую систему метаданных в ASP.NET MVC 2. По умолчанию, мета-объекты формируются на основе данных, полученных из атрибутов.
Следующие атрибуты используются для формирования модели метаданных:
Часть третья. Встроенные шаблоны.
Подход к использованию шаблонов
Перед тем как поговорить о встроенных шаблонах, потратим несколько минут на объяснение того, как шаблоны используются в работе, как напрямую перекрыть шаблон.
Когда решено какой шаблон использовать, система просматривает несколько путей. По каждому из них, ищет ascx-файл с именем «DisplayNames/TemplateName» или «EditorName/TemplateName», в зависимости от того какой результат вы хотите.
Поиск происходит в следующем порядке:
(Замените DisplayTemplates на EditorTemplates для шаблонов редактирования.)
Имена шаблонов
Имена шаблонов ищутся в следующем порядке:
Класс TemplateInfo
И последнее о чем стоит сказать перед тем, как углубиться в реализацию, это класс TemplateInfo. TemplateInfo не всегда доступен из ViewData, в отличии от метаданных модели, только в момент когда вы находитесь в шаблоне.
Основное свойство, используемое в TemplateInfo — это FormattedModelValue. Значением этого поля является либо корректно отформатированное значение модели, в виде строки (на основе формата указанного в ModelMetadata), либо оригинальное значение модели (если не указан формат строки).
Есть ещё несколько вещей, которые мы тоже будем использовать (например свойство TemplateDepth и метод Visited). Но смысл их я объясню по мере знакомства с ними.
Встроенные шаблоны отображения
Всего существует 9 имён шаблонов, которые используются системой для отображения данных: «Boolean», «Decimal», «EmailAddress», «HiddenInput», «Html», «Object», «String», «Text» и «Url». Два из них («Text» и «String») реализованы одинаково. У некоторых из них есть соответствующие аналоги для шаблонов редактирования, у некоторых — нет.
DisplayTemplate/String.ascx
Никаких сюрпризов: просто отображаем модель, заменив в ней специальные символы html.
DisplayTemplates/Html.ascx
Этот шаблон даже немного проще предыдущего, потому что тип «Html» подразумевает, что содержимое будет в виде html и поэтому не должно быть кодировано. Будьте аккуратны при использовании этого типа если данные получены от конечного пользователя, во избежание XSS-атак!
DisplayTemplates/EmailAddress.ascx
Этот шаблон предполагает, что ваша модель является адресом электронной почты, и автоматически создаёт ссылку на неё. Обратите внимание, что модель используется для адреса электронной почты, а FormattedModelValue для отображения.
DisplayTemplates/Url.ascx
Работает подобно предыдущему примеру.
DisplayTemplates/HiddenInput.ascx
Этот шаблон используется в паре с атрибутом [HiddenInput] (описанный выше). Он будет генерировать отображаемое значение только если пользователь явно не указал свойство HideSurroundHtml.
DisplayTemplates/Decimal.ascx
Этот шаблон отображает значение типа decimal, с двумя знаками после запятой, поскольку этот тип в основном используется для денежных представлений. Обратите внимание на условие такого форматирования.
DisplayTemplates/Boolean.ascx
Шаблон для Boolean интересен тем, что в нём необходимо генерировать разметку в зависимости от того является ли тип nullable, или нет. Для non-nullable используется обычный чекбокс, в противном случае отображается выпадающий список с тремя значениями.
DisplayTemplates/Object.ascx
Стоит объяснить логику работы этого шаблона, прежде чем мы рассмотрим код, поскольку очень много работы проделывается от вашего имени.
Главная цель шаблон для типа object это всех свойств сложного объекта, вместе с html-разметкой для каждого. Кроме того, он ответственный за отображение значения модели NullDisplayText, если значение её null. И обеспечивает, так называемое «мелкое погружение» (shallow dive), отображая только нужный уровень свойств. Позднее мы поговорим о настройке этого шаблона, включая подготовку операции «глубокое погружение» (deep dive).
Давайте рассмотрим этот пример более детально.
В этом месте всё понятно, выводится NullDisplayText, в случае если модель равна null.
В этом месте мы ограничиваем уровень вложенности свойств («мелкое погружение», shallow dive). Класс TemplateInfo отслеживает глубину вложенности шаблонов. Для верхнего уровня свойство TemplateDepth равно 1.
Это основной цикл прохода по свойствам объекта. Свойства, которым указано что они не должны отображаться, игнорируются. Другая часть фильтра свойств, спрашивает у TemplateInfo рендерился ли этот объект ранее, для того чтобы предотвратить бесконечную рекурсию.
Если это свойство установлено в true, то шаблон просто просит свойство отобразиться, без лишней html-разметки.
В этом месте проверяется есть ли отображаемое имя у свойства и, если оно есть, оно выводится, обрамляемое div-ом. Затем запускается рендеринг для свойства.
Встроенные шаблоны редактирования
Шаблоны редактирования немного сложнее, чем шаблоны отображения, поскольку они включают возможность редактирования значений. Они строятся на основе существующих HTML-хелперов. Всего существует 7 шаблонов редактирования: «Boolean», «Decimal», «HiddenInput», «MultilineText», «Object», «Password» и «String».
Часто, в качестве имени элемента в html-хелперы будут передаваться пустые строки. Обычно это неправильно, но в случае с шаблонами у нас есть «контекст» свойства. С помощью этого нам проще работать со сложными объектами, поскольку мы можем сохранить иерархию вложенности свойств (например «Contact.HomeAddress.City»).
Когда вы передаёте имя в html-хелпер, вы как бы говорите «дай мне текстбокс для редактирования свойства объекта, которого зовут „City“. Но что случится если ваш шаблон не для адреса, как сложного объекта, а для города, как для строки? Если вы передаёте пустую строку, в качестве имени, то вы говорите html-хелперу „дай мне текстбокс, чтобы отредактировать себя“.
EditorTemplates/String.ascx
И снова начнём со строки, поскольку это простейший для понимания шаблон. Этот шаблон говорит системе, что хочет получить текстбокс (для редактирования себя), и мы инициируем его форматированным значением редактируемого свойства. Дополнительно, для этого текстбокса мы хотим использовать два класса CSS „text-box“ и „single-line“.
EditorTemplates/Password.ascx
Шаблон для ввода пароля похож на шаблон для строки, за исключением того, что мы вызываем метод хелпера Password и используем ещё один класс CSS (»password»).
EditorTemplates/MultilineText.ascx
И снова без всяких сюрпризов. Вызываем метод TextArea, указываем количество строк и колонок равное 0 (поскольку мы используем CSS), и вместо класса «single-line» используем класс «multi-line».
EditorTemplates/HiddenInput.ascx
Как видите, намного сложнее, чем в шаблоне для отображения. Свойство ModelValue определяет является ли модель массивом байт или бинарным linq2sql объектом, и конвертирует их в строку с помощью base64. Затем записывает результат в hidden-поле.
EditorTemplates/Decimal.ascx
Шаблон для Decimal похож на соответствующий шаблон для отображения, за исключением того, что генерируется текстбокс для редактирования.
EditorTemplates/Boolean.ascx
Этот шаблон тоже похож на соответствующий шаблон для отображения.
EditorTemplates/Object.ascx
Точно также этот шаблон практически не изменился, только добавился вызов метода ValidationMessage.
Часть четвёртая. Создание собственных шаблонов
Для дальнейших примеров будут использоваться следующие модель, контроллер и представление: