What is the advantage of using Tag Helpers in ASP.NET Core MVC

Question

I just come across a good write up for a new ASP.NET Core feature called Tag helpers.

From there, I understood that one can replace the following code:

@model MyProject.Models.Product

@using (Html.BeginForm())
{
    <div>
        @Html.LabelFor(m => p.Name, "Name:")
        @Html.TextBoxFor(m => p.Name)
    </div>
    <input type="submit" value="Create" />
}

with:

@model MyProject.Models.Product
@addtaghelper "Microsoft.AspNet.Mvc.TagHelpers"

<form asp-controller="Products" asp-action="Create" method="post">
    <div>
        <label asp-for="Name">Name:</label>
        <input asp-for="Name" />
    </div>

    <input type="submit" value="Save" />
</form>

There's some new syntax such as asp-controller, asp-for, etc. But what does it do? And what's the advantage of this new approach?

Answer 1

Sorry for adding another answer, but one more reason to stick to pure HTML is performance.

Html.TextBoxFor allocates a lambda, iterates a dictionary of attributes, uses reflection/expressionAPI to build the return string, allocates a TagBuilder etc etc (just view the source codes).

I just wrote a tiny benchmark for .NET 8:

@{
    var sw = new System.Diagnostics.Stopwatch();

    sw.Restart();
    for (int i = 0; i < 2000; i++)
    {
        @Html.TextBoxFor(m => m.Email)
    }
    sw.Stop();

    sw.Restart();
    for (int i = 0; i < 2000; i++)
    {
        <input type="text" name="Email" value="@Model.Email">
    }
    sw.Stop();
}

I wish I could write a proper benchmark using BenchmarkDotNet, but it does not work with Razor markup... But the result is:

00:00:00.0029322 vs 00:00:00.0000588

Which is two orders of magnitude slower

But tag helpers are slow too

Actually, tag-helpers have some overhead too. They are also slow, sometimes even slower that HtmlHelper extensions.

Verdict: stick to basic html when you can. Simple HTML code in a Razor file is just being written to a TextWriter that wraps the Response stream. You can't beat that.

Answer 2

From building a basic web app from the ground up in .NET 7/Razor pages, I haven't encountered a single instance where a tag helper has an advantage over simply coding the HTML. I don't come from an MVC background so maybe that is where the advantage lies but as seen before...Microsoft has released yet another version of wheel-reinvention that instead of making things easier for some simply adds more confusion to others.

Answer 3

I know the original question asks about advantages but for the sake of completeness I have to mention one disadvantage:

With tag-helpers enabled you cannot inject C# code inside tag attributes.

I.e. this code will break:

<!-- this won't work -->
<input class="@GetMyClass()">

<!-- this won't work too -->
<input type="checkbox" @(condition ? "checked" : "") >

To work around this problem you can use custom tag helpers or just disable tag helpers altogether like described in this answer: https://stackoverflow.com/a/65281018/56621

^{P.S. My humble opinion that can be safely ignored: tag helpers are "magic". And "magic" is always bad in programming. If something looks like an HTML tag, walks like a tag and quacks like a tag - then it should probably be an HTML tag. Without me knowning "oh, it's not *really* a tag".}

Answer 4

Accepted answer is correct but just a correction. Html Helpers cover dashes in attributes by use of underscore. for example if you want html like my-attr=value then you can use html helpers like @Html.TextBoxFor(m=>m.id, new { my_attr = value }) then it will convert accordingly.

Answer 5

A few things come to mind:

1. As @ChrisWalter points out, these tag helpers give HTML tags an Open/Closed quality. Rather than just letting you write extension methods for common HTML patterns, you can extend an HTML element. This lets you pick-and-mix multiple extensions per component, rather than having to choose between them.

2. HTML Helpers tend to not work super well for elements that need to have inner HTML provided as an argument. They came up with a clever pattern so you can say:

   @using (Html.BeginForm(...)){
   {
       <input ... />
   }
   

   But there's nothing about BeginForm() that would force you to put it in a using statement, and there's nothing to prevent you from using incorrect HTML structure. (<input> technically isn't allowed to be directly inside a <form> tag.)

3. This gives us a really easy transitional stepping stone into the Web Components world of HTML5. A component that you write today for jQuery or Bootstrap to pick up and enhance may make more sense as an Angular 2 or Polymer component in a few years. Using HTML syntax makes it possible to write your HTML the way you want it to look when it's a web component, and have it automatically translated into the structure it has to take on for now (or for specific browsers, later).

Answer 6

Not to mention, your Web Designers will have real HTML tags to edit that they recognize to re-design your pages. Designers shouldn't have to be coders and there's enough for these sharp folks to keep up with, studying the moving targets of HTML5 and CSS3 specs.

Answer 7

The most important improvement I've seen so far is the control it guarantees over your HTML elements. While convenient, the Html helpers used by MVC create problems when you try to do things they weren't built for.

A simple example can be seen when using the TextBox in MVC5:

 @Html.TextBoxFor(m => p.Name)

The resulting HTML markup looks like:

<input class="form-control" id="Name" name="Name" type="text" value="">

Nice and simple. But what if you want to add a placeholder attribute? What if you want to use bootstrap's validation states? What if you have some 3rd party super cool javascript library which needs custom attributes. None of these things were possible in the initial release of MVC5. Though they were eventually added via update in the form of htmlAttributes. Even now adding custom attributes is kludgey at best.

@Html.TextBoxFor(m => p.Name, 
    new {@class="form-control has-error", placeholder="Enter Name", 
    superCoolFeature="Do something cool"})

While you could argue this is still less code that straight HTML, it is no longer a significant advantage. Worse, this solution still doesn't cover dashes in attributes which are fairly common. If you need them you are stuck with a workaround such as ActionLink htmlAttributes

I've gone down the route of fixing these deficiencies with custom editors, and tried building my own TextBox controls. It became obvious pretty quickly that replacing the included TextBox templates would require a lot of work. Worse, your templates have to have knowledge of any extensions you are adding to use them.

It seems like the inclusion of Bootstrap and other 3rd party tools into MVC have made it more obvious that the current design has problems with extending HTML which need to be fixed. Hopefully the tag helpers implementation is complete enough that we can avoid them in the future.