huahaofeng
/
aspnetcore
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Add TagHelperDescriptorResolver. 

- This involved also adding a TagHelperTypeResolver and TagHelperDescriptorFactory.
- The TagHelperTypeResolver is responsible for determining the format of lookup text's used throughout the tag helper system.  By default it handles the following formats:
"assemblyName"
"specificType, assemblyName"
- It also restricts what types are considered TagHelpers.  In this implementation we only accept public, non-nested, non-abstract, non-generic TagHelpers.
- The TagHelperDescriptorFactory is responsible for converting a Type to a TagHelperDescriptor.
- Added tests to validate TagHelperDescriptorResolver, TagHelperTypeResolver and TagHelperDescriptorFactory.

#99
#158
This commit is contained in:
NTaylorMullen 2014-09-28 14:26:15 -07:00 committed by N. Taylor Mullen
parent 7db4ed7f7e
commit f9c70a0644
15 changed files with 501 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/Microsoft.AspNet.Razor.Runtime/AssemblyInfo.cs Normal file
View File

@ -0,0 +1,6 @@
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Runtime.CompilerServices;
[assembly: InternalsVisibleTo("Microsoft.AspNet.Razor.Runtime.Test")]

12
src/Microsoft.AspNet.Razor.Runtime/NotNullArgument.cs Normal file
View File

@ -0,0 +1,12 @@
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
namespace Microsoft.AspNet.Razor.Runtime
{
[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false)]
internal sealed class NotNullAttribute : Attribute
{
}
}

82
src/Microsoft.AspNet.Razor.Runtime/Properties/Resources.Designer.cs generated Normal file
View File

@ -0,0 +1,82 @@
// <auto-generated />
namespace Microsoft.AspNet.Razor.Runtime
{
using System.Globalization;
using System.Reflection;
using System.Resources;
internal static class Resources
{
private static readonly ResourceManager _resourceManager
= new ResourceManager("Microsoft.AspNet.Razor.Runtime.Resources", typeof(Resources).GetTypeInfo().Assembly);
/// <summary>
/// Invalid tag helper directive look up text '{0}'. The correct look up text formats are:
/// "assemblyName"
/// "typeName, assemblyName"
/// </summary>
internal static string TagHelperDescriptorResolver_InvalidTagHelperLookupText
{
get { return GetString("TagHelperDescriptorResolver_InvalidTagHelperLookupText"); }
}
/// <summary>
/// Invalid tag helper directive look up text '{0}'. The correct look up text formats are:
/// "assemblyName"
/// "typeName, assemblyName"
/// </summary>
internal static string FormatTagHelperDescriptorResolver_InvalidTagHelperLookupText(object p0)
{
return string.Format(CultureInfo.CurrentCulture, GetString("TagHelperDescriptorResolver_InvalidTagHelperLookupText"), p0);
}
/// <summary>
/// Cannot resolve TagHelper containing assembly '{0}'. Error: '{1}'.
/// </summary>
internal static string TagHelperTypeResolver_CannotResolveTagHelperAssembly
{
get { return GetString("TagHelperTypeResolver_CannotResolveTagHelperAssembly"); }
}
/// <summary>
/// Cannot resolve TagHelper containing assembly '{0}'. Error: '{1}'.
/// </summary>
internal static string FormatTagHelperTypeResolver_CannotResolveTagHelperAssembly(object p0, object p1)
{
return string.Format(CultureInfo.CurrentCulture, GetString("TagHelperTypeResolver_CannotResolveTagHelperAssembly"), p0, p1);
}
/// <summary>
/// Tag helper directive assembly name cannot be null or empty.
/// </summary>
internal static string TagHelperTypeResolver_TagHelperAssemblyNameCannotBeEmptyOrNull
{
get { return GetString("TagHelperTypeResolver_TagHelperAssemblyNameCannotBeEmptyOrNull"); }
}
/// <summary>
/// Tag helper directive assembly name cannot be null or empty.
/// </summary>
internal static string FormatTagHelperTypeResolver_TagHelperAssemblyNameCannotBeEmptyOrNull()
{
return GetString("TagHelperTypeResolver_TagHelperAssemblyNameCannotBeEmptyOrNull");
}
private static string GetString(string name, params string[] formatterNames)
{
var value = _resourceManager.GetString(name);
System.Diagnostics.Debug.Assert(value != null);
if (formatterNames != null)
{
for (var i = 0; i < formatterNames.Length; i++)
{
value = value.Replace("{" + formatterNames[i] + "}", "{" + i + "}");
}
}
return value;
}
}
}

131
src/Microsoft.AspNet.Razor.Runtime/Resources.resx Normal file
View File

@ -0,0 +1,131 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<data name="TagHelperDescriptorResolver_InvalidTagHelperLookupText" xml:space="preserve">
<value>Invalid tag helper directive look up text '{0}'. The correct look up text formats are:
"assemblyName"
"typeName, assemblyName"</value>
</data>
<data name="TagHelperTypeResolver_CannotResolveTagHelperAssembly" xml:space="preserve">
<value>Cannot resolve TagHelper containing assembly '{0}'. Error: '{1}'.</value>
</data>
<data name="TagHelperTypeResolver_TagHelperAssemblyNameCannotBeEmptyOrNull" xml:space="preserve">
<value>Tag helper directive assembly name cannot be null or empty.</value>
</data>
</root>

12
src/Microsoft.AspNet.Razor.Runtime/TagHelpers/ITagHelper.cs Normal file
View File

@ -0,0 +1,12 @@
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
namespace Microsoft.AspNet.Razor.Runtime.TagHelpers
{
public interface ITagHelper
{
// TODO: Will be implemented in https://github.com/aspnet/razor/issues/154
}
}

83
src/Microsoft.AspNet.Razor.Runtime/TagHelpers/TagHelperDescriptorFactory.cs Normal file
View File

@ -0,0 +1,83 @@
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using Microsoft.AspNet.Razor.TagHelpers;
namespace Microsoft.AspNet.Razor.Runtime.TagHelpers
{
/// <summary>
/// Factory for <see cref="TagHelperDescriptor"/>s from <see cref="Type"/>s.
/// </summary>
public static class TagHelperDescriptorFactory
{
private const string TagHelperNameEnding = "TagHelper";
// TODO: Investigate if we should cache TagHelperDescriptors for types:
// https://github.com/aspnet/Razor/issues/165
/// <summary>
/// Creates a <see cref="TagHelperDescriptor"/> from the given <paramref name="type"/>.
/// </summary>
/// <param name="type">The type to create a <see cref="TagHelperDescriptor"/> from.</param>
/// <returns>A <see cref="TagHelperDescriptor"/> that describes the given <paramref name="type"/>.</returns>
public static TagHelperDescriptor CreateDescriptor(Type type)
{
var tagName = GetTagName(type);
var typeName = type.FullName;
var attributeDescriptors = GetAttributeDescriptors(type);
var contentBehavior = GetContentBehavior(type);
return new TagHelperDescriptor(tagName,
typeName,
contentBehavior,
attributeDescriptors);
}
// TODO: Make this method support TagNameAttribute tag names: https://github.com/aspnet/Razor/issues/120
private static string GetTagName(Type tagHelperType)
{
var name = tagHelperType.Name;
if (name.EndsWith(TagHelperNameEnding, StringComparison.OrdinalIgnoreCase))
{
name = name.Substring(0, name.Length - TagHelperNameEnding.Length);
}
return name;
}
private static IEnumerable<TagHelperAttributeDescriptor> GetAttributeDescriptors(Type type)
{
var typeInfo = type.GetTypeInfo();
var properties = typeInfo.DeclaredProperties.Where(IsValidProperty);
var attributeDescriptors = properties.Select(ToAttributeDescriptor);
return attributeDescriptors;
}
// TODO: Make the HTML attribute name support names from a AttributeNameAttribute:
// https://github.com/aspnet/Razor/issues/121
private static TagHelperAttributeDescriptor ToAttributeDescriptor(PropertyInfo property)
{
return new TagHelperAttributeDescriptor(property.Name, property);
}
// TODO: Make the content behavior pull from a ContentBehaviorAttribute: https://github.com/aspnet/Razor/issues/122
private static ContentBehavior GetContentBehavior(Type type)
{
return ContentBehavior.None;
}
private static bool IsValidProperty(PropertyInfo property)
{
return property.GetMethod != null &&
property.GetMethod.IsPublic &&
property.SetMethod != null &&
property.SetMethod.IsPublic;
}
}
}

78
src/Microsoft.AspNet.Razor.Runtime/TagHelpers/TagHelperDescriptorResolver.cs Normal file
View File

@ -0,0 +1,78 @@
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.AspNet.Razor.TagHelpers;
namespace Microsoft.AspNet.Razor.Runtime.TagHelpers
{
/// <summary>
/// Used to resolve <see cref="TagHelperDescriptor"/>s.
/// </summary>
public class TagHelperDescriptorResolver : ITagHelperDescriptorResolver
{
private readonly TagHelperTypeResolver _typeResolver;
// internal for testing
internal TagHelperDescriptorResolver(TagHelperTypeResolver typeResolver)
{
_typeResolver = typeResolver;
}
/// <summary>
/// Instantiates a new instance of the <see cref="TagHelperDescriptorResolver"/> class.
/// </summary>
public TagHelperDescriptorResolver()
: this(new TagHelperTypeResolver())
{
}
/// <inheritdoc />
public IEnumerable<TagHelperDescriptor> Resolve(string lookupText)
{
var lookupStrings = lookupText?.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
// Ensure that we have valid lookupStrings to work with. Valid formats are:
// "assemblyName"
// "typeName, assemblyName"
if (string.IsNullOrEmpty(lookupText) ||
(lookupStrings.Length != 1 && lookupStrings.Length != 2))
{
throw new ArgumentException(
Resources.FormatTagHelperDescriptorResolver_InvalidTagHelperLookupText(lookupText),
nameof(lookupText));
}
var tagHelperTypes = ResolveTagHelperTypes(lookupStrings);
// Convert types to TagHelperDescriptors
var descriptors = tagHelperTypes.Select(TagHelperDescriptorFactory.CreateDescriptor);
return descriptors;
}
private IEnumerable<Type> ResolveTagHelperTypes(string[] lookupStrings)
{
// Grab the assembly name from the lookup text strings. Due to our supported lookupText formats it will
// always be the last element provided.
var assemblyName = lookupStrings.Last().Trim();
// Resolve valid tag helper types from the assembly.
var types = _typeResolver.Resolve(assemblyName);
// Check if the lookupText specifies a type to search for.
if (lookupStrings.Length == 2)
{
// The user provided a type name retrieve the value and trim it.
var typeName = lookupStrings[0].Trim();
types = types.Where(type =>
string.Equals(type.Namespace + "." + type.Name, typeName, StringComparison.Ordinal));
}
return types;
}
}
}

74
src/Microsoft.AspNet.Razor.Runtime/TagHelpers/TagHelperTypeResolver.cs Normal file
View File

@ -0,0 +1,74 @@
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
namespace Microsoft.AspNet.Razor.Runtime.TagHelpers
{
/// <summary>
/// Class that locates valid <see cref="ITagHelper"/>s within an assembly.
/// </summary>
public class TagHelperTypeResolver
{
private static readonly TypeInfo ITagHelperTypeInfo = typeof(ITagHelper).GetTypeInfo();
/// <summary>
/// Instantiates a new instance of the <see cref="TagHelperTypeResolver"/> class.
/// </summary>
public TagHelperTypeResolver()
{
}
/// <summary>
/// Loads an <see cref="Assembly"/> using the given <paramref name="name"/> and resolves
/// all valid <see cref="ITagHelper"/> <see cref="Type"/>s.
/// </summary>
/// <param name="name">The name of an <see cref="Assembly"/> to search.</param>
/// <returns>An <see cref="IEnumerable{Type}"/> of valid <see cref="ITagHelper"/> <see cref="Type"/>s.</returns>
public IEnumerable<Type> Resolve(string name)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException(
Resources.TagHelperTypeResolver_TagHelperAssemblyNameCannotBeEmptyOrNull,
nameof(name));
}
var assemblyName = new AssemblyName(name);
var libraryTypes = GetLibraryDefinedTypes(assemblyName);
var validTagHelpers = libraryTypes.Where(IsTagHelper);
// Convert from TypeInfo[] to Type[]
return validTagHelpers.Select(type => type.AsType());
}
// Internal for testing, don't want to be loading assemblies during a test.
internal virtual IEnumerable<TypeInfo> GetLibraryDefinedTypes(AssemblyName assemblyName)
{
try
{
var assembly = Assembly.Load(assemblyName);
return assembly.DefinedTypes;
}
catch (Exception ex)
{
throw new InvalidOperationException(
Resources.FormatTagHelperTypeResolver_CannotResolveTagHelperAssembly(assemblyName.Name,
ex.Message));
}
}
private static bool IsTagHelper(TypeInfo typeInfo)
{
return typeInfo.IsPublic &&
!typeInfo.IsAbstract &&
!typeInfo.IsGenericType &&
!typeInfo.IsNested &&
ITagHelperTypeInfo.IsAssignableFrom(typeInfo);
}
}
}

2
src/Microsoft.AspNet.Razor/Parser/TagHelpers/TagHelperRegistrationVisitor.cs
View File

@ -40,7 +40,7 @@ namespace Microsoft.AspNet.Razor.Parser.TagHelpers.Internal
throw new InvalidOperationException(
RazorResources.FormatTagHelpers_CannotUseDirectiveWithNoTagHelperDescriptorResolver(
SyntaxConstants.CSharp.AddTagHelperKeyword,
nameof(TagHelperDescriptorResolver),
nameof(ITagHelperDescriptorResolver),
nameof(RazorParser)));
}

3
src/Microsoft.AspNet.Razor/Properties/AssemblyInfo.cs
View File

@ -3,4 +3,5 @@
using System.Runtime.CompilerServices;
[assembly: InternalsVisibleTo("Microsoft.AspNet.Razor.Test")]
[assembly: InternalsVisibleTo("Microsoft.AspNet.Razor.Test")]
[assembly: InternalsVisibleTo("Microsoft.AspNet.Razor.Runtime.Test")]

11
src/Microsoft.AspNet.Razor/RazorEngineHost.cs
View File

@ -113,6 +113,11 @@ namespace Microsoft.AspNet.Razor
/// </summary>
public virtual RazorCodeLanguage CodeLanguage { get; protected set; }
/// <summary>
/// The <see cref="ITagHelperDescriptorResolver"/> used to resolve <see cref="TagHelperDescriptor"/>s.
/// </summary>
public virtual ITagHelperDescriptorResolver TagHelperDescriptorResolver { get; protected set; }
/// <summary>
/// Boolean indicating if instrumentation code should be injected into the output page
/// </summary>
@ -161,12 +166,6 @@ namespace Microsoft.AspNet.Razor
return null;
}
// TODO: Document this as part of https://github.com/aspnet/Razor/issues/99
public virtual ITagHelperDescriptorResolver CreateTagHelperDescriptorResolver()
{
return new TagHelperDescriptorResolver();
}
/// <summary>
/// Gets an instance of the code parser and is provided an opportunity to decorate or replace it
/// </summary>

3
src/Microsoft.AspNet.Razor/RazorTemplateEngine.cs
View File

@ -271,11 +271,10 @@ namespace Microsoft.AspNet.Razor
{
var codeParser = Host.CodeLanguage.CreateCodeParser();
var markupParser = Host.CreateMarkupParser();
var tagHelperDescriptorResolver = Host.CreateTagHelperDescriptorResolver();
return new RazorParser(Host.DecorateCodeParser(codeParser),
Host.DecorateMarkupParser(markupParser),
tagHelperDescriptorResolver)
Host.TagHelperDescriptorResolver)
{
DesignTimeMode = Host.DesignTimeMode
};

13
src/Microsoft.AspNet.Razor/TagHelpers/ITagHelperDescriptorResolver.cs
View File

@ -5,10 +5,19 @@ using System.Collections.Generic;
namespace Microsoft.AspNet.Razor.TagHelpers
{
// TODO: Document this class as part of https://github.com/aspnet/Razor/issues/99
/// <summary>
/// Contract used to resolve <see cref="TagHelperDescriptor"/>s.
/// </summary>
public interface ITagHelperDescriptorResolver
{
/// <summary>
/// Resolves <see cref="TagHelperDescriptor"/>s matching the given <paramref name="lookupText"/>.
/// </summary>
/// <param name="lookupText">
/// A <see cref="string"/> used to find tag helper <see cref="Type"/>s.
/// </param>
/// <returns>An <see cref="IEnumerable{TagHelperDescriptor}"/> of <see cref="TagHelperDescriptor"/>s matching
/// the given <paramref name="lookupText"/>.</returns>
IEnumerable<TagHelperDescriptor> Resolve(string lookupText);
}
}

5
src/Microsoft.AspNet.Razor/TagHelpers/TagHelperDescriptorComparer.cs
View File

@ -8,7 +8,7 @@ using Microsoft.Internal.Web.Utils;
namespace Microsoft.AspNet.Razor.TagHelpers
{
/// <summary>
/// Defines a an <see cref="IEqualityComparer{TagHelperDescriptor}"/> that is used to check equality between
/// An <see cref="IEqualityComparer{TagHelperDescriptor}"/> used to check equality between
/// two <see cref="TagHelperDescriptor"/>s.
/// </summary>
public class TagHelperDescriptorComparer : IEqualityComparer<TagHelperDescriptor>
@ -18,7 +18,8 @@ namespace Microsoft.AspNet.Razor.TagHelpers
/// </summary>
public static readonly TagHelperDescriptorComparer Default = new TagHelperDescriptorComparer();
private TagHelperDescriptorComparer()
// Internal for testing
internal TagHelperDescriptorComparer()
{
}

18
src/Microsoft.AspNet.Razor/TagHelpers/TagHelperDescriptorResolver.cs
View File

@ -1,18 +0,0 @@
// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
using System.Collections.Generic;
using System.Linq;
namespace Microsoft.AspNet.Razor.TagHelpers
{
// TODO: Implement this class as part of https://github.com/aspnet/Razor/issues/99
public class TagHelperDescriptorResolver : ITagHelperDescriptorResolver
{
public IEnumerable<TagHelperDescriptor> Resolve(string lookupText)
{
return Enumerable.Empty<TagHelperDescriptor>();
}
}
}