Узнайте о преимуществах использования аргументов обобщенных типов с помощью директивы @typeparam для реализации повторно используемых и типобезопасных компонентов Razor.
Поддержка обобщенных типов привносит обобщения в компоненты Razor, позволяя нам создавать масштабируемые веб-приложения Blazor.
В этой статье мы узнаем, как использовать обобщенные типы в наших компонентах Razor и когда стоит задуматься об их применении.
Подсказка: если вы новичок в обобщениях C#, пожалуйста, сначала ознакомьтесь с обобщенными типами и методами в C#, чтобы вам было проще следовать материалу.
Вы можете получить доступ к коду на GitHub.
Реализация простого обобщенного компонента Razor
Атрибут @typeparam позволяет нам определить обобщенный параметр для компонента Razor.
Рассмотрим следующий простой обобщенный компонент NamedObjectRenderer:
Этот компонент определяет обобщенный тип с помощью директивы @typeparam.
Затем мы можем использовать TType в качестве типа для свойства параметра с именем Object.
Поскольку мы используем ограничение типа, мы можем использовать метод GetName, определенный в интерфейсе INamedObject:
Теперь давайте воспользуемся этим компонентом.
Сначала мы создаем класс Person, который реализует интерфейс INamedObject. Мы добавляем два свойства: Name и Age, и предоставляем значение свойства Name в методе GetName из интерфейса INamedObject.
Использование компонента NamedObjectRenderer довольно просто:
Мы передаем объект класса Person в качестве аргумента для параметра Object компонента NamedObjectRenderer.
Подсказка: обратите внимание, что мы специально не указываем тип Person в качестве аргумента для параметра TType. Это возможно, потому что Blazor способен вывести тип предоставленного объекта.
Также можно явно указать тип для аргумента обобщенного типа. Однако в большинстве случаев вывода типов достаточно, и это делает использование обобщенных компонентов Razor простым.
Реализация обобщенного компонента Razor более высокого уровня
Предыдущий пример продемонстрировал основы реализации обобщенных компонентов Razor.
Соглашусь, что этот пример не выглядит революционным. Для него могут найтись отдельные варианты использования, но он не меняет общего подхода к реализации ваших веб-приложений Blazor.
Однако мы можем опираться на этот фундамент и реализовать более продвинутый обобщенный компонент Razor, который способен изменить то, как вы структурируете и проектируете свои веб-приложения Blazor.
Рассмотрим следующий сценарий: мы хотим отобразить на экране два столбца. Столбец имени и столбец значения. Мы хотим реализовать единый компонент для инкапсуляции поведения, а также внешнего вида компонента.
Но есть нюанс! Мы хотим иметь возможность использовать этот компонент с совершенно разными объектами данных.
Следующий обобщенный компонент DataTable является отличным примером:
Снова мы определяем аргумент обобщенного типа с помощью директивы @typeparam в верхней части компонента.
В разделе кода мы используем этот тип для реализации трех свойств параметров. Свойство Items типа IEnumerable<TItem> содержит список предоставленных элементов.
Этот список перебирается в разделе шаблона кода, и для каждого элемента вызываются функции GetName и GetValue, предоставленные во втором и третьем параметрах компонента.
Теперь давайте посмотрим, как мы можем использовать этот компонент в наших приложениях и почему эта реализация настолько мощная, как я заявлял.
Здесь у нас есть тот же класс Person, который мы уже использовали в первой главе этой статьи. Мы создаем список объектов Person и передаем этот список в параметр Items компонента DataTable.
Магия происходит при определении функций параметров GetName и GetValue.
Мы используем лямбда-выражение для определения поведения параметров GetName и GetValue.
Для класса Person мы используем его метод GetName для отображения имени человека, а для столбца значения мы используем свойство Age и вызываем его метод ToString.
Используя аргумент обобщенного типа, мы можем реализовать поведение компонента DataTable вне определения самого компонента.
Давайте рассмотрим второй пример с использованием совершенно несвязанного объекта:
Здесь мы реализуем класс Animal с двумя свойствами: Name и Type.
Мы хотим отобразить имя животного (как владелец называет питомца) и его тип (вид животного).
Мы можем повторно использовать тот же компонент DataTable и передать список животных в свойство Items. Опять же, вывод типов работает идеально; нам не нужно явно указывать тип Animal.
И снова мы реализуем поведение извне компонента DataTable при его использовании, а не при его определении. Мы используем свойство Name для значения столбца имени и свойство Type для столбца значения.
Этот пример показывает, как реализовать гибкие обобщенные компоненты Razor, которые позволяют совместно использовать код при многократном использовании одного и того же компонента и позволяют каждому экземпляру предоставлять свое поведение.
Мы видим, что внешний вид первого и второго списков абсолютно одинаков, хотя мы знаем, что предоставили два совершенно несвязанных типа данных.
Преимущества обобщенных компонентов Razor
Мы узнали, как использовать директиву @typeparam для реализации аргумента обобщенного типа для компонентов Razor.
Мы также реализовали два примера, которые показывают, как создавать обобщенные компоненты Razor для ваших веб-приложений Blazor.
Теперь давайте более широко рассмотрим преимущества использования аргументов обобщенных типов в компонентах Razor:
- Аргументы обобщенных типов делают компоненты более пригодными для повторного использования и сохраняют их типобезопасность. Вместо использования object в качестве базового типа параметра или использования System.Reflection, компилятор предоставляет типобезопасную среду.
- Используя конструкцию Func<TItem, ...>, мы можем внедрять/предоставлять поведение извне компонента. Можно использовать разное поведение в каждом экземпляре компонента в зависимости от предоставленных данных. Компоненту в нашем втором примере не нужно знать, отображает ли он список животных, людей или зданий. Но он отвечает за обеспечение единообразного и удобного взаимодействия с пользователем.
- Благодаря выводу типов нам не нужно явно указывать обобщенный тип при использовании компонента. Blazor может вывести тип за нас. Это помогает нам сделать код лаконичным и выразительным.
Короче говоря: поддержка обобщенных типов позволяет нам реализовывать аргументы обобщенных типов в компонентах Razor, позволяя повторно использовать типобезопасный компонент, который обеспечивает единообразный внешний вид и предоставляет поведение для каждого экземпляра.
Заключение
Обобщенные компоненты Razor — это мощный инструмент для создания повторно используемых и типобезопасных приложений Blazor. Используя директиву @typeparam, мы можем создавать компоненты, которые работают с различными типами данных.
Обобщенные компоненты могут отделять представление (отрисовку) компонента от его данных и поведения.
В примере с компонентом DataTable мы продемонстрировали, как использовать один и тот же компонент Razor с двумя совершенно несвязанными классами данных.
По сравнению с реализацией компонента Razor для каждого типа данных и поиском способа совместного использования кода шаблона, аргументы обобщенных типов предоставляют элегантное и лаконичное решение.
Если вы хотите узнать больше о разработке на Blazor, посмотрите мой бесплатный экспресс-курс по Blazor на YouTube. И следите за обновлениями в блоге Telerik, чтобы узнать больше об основах Blazor.











