What is view engine? What does it actually do?

I started learning ASP.NET MVC3.

So, while reading tutorials online and in books, I came across this term "view engine" quite frequently. I don't know what it is.

What does it actually do?

Why should it matter to me at all?

The view engine is responsible for creating HTML from your views. Views are usually some kind of mixup of HTML and a programming language. The pattern behind most of these is called two-step view.

For example, ASP.NET comes with its own view engine out of the box. That is the one where views have lots of tags like <% %> and <%: %>. It uses the .aspx file extension.

With ASP.NET MVC3, another out-of-the-box view engine was added, Razor, which has a more appealing syntax, e.g. <div>@Model.UserName</div>.

The choice of view engine is important, because the feature sets of view engines are quite different. Some support rendering to PDF files, for instance; some can't be used outside a web context (this is true for the old ASP.NET view engine), while others can (e.g. Razor). 'Offline' rendering of views comes in handy when you want to create HTML emails the same way you build your views and those emails should be sent from a background worker rather than a web application.

There's a nice comparison of asp.net view engines here on SO.

The good news is that you can use multiple view engines in parallel in ASP.NET MVC, though I wouldn't recommend it unless necessary.

There are some very nice extension points in the Razor engine already. For example, you can provide a custom view base class, a powerful concept that makes it easy to add a lot of functionality in the right place without having to mess with all the gritty details that you'd have to cope with otherwise.

I'd currently go for Razor.

The view engine is what's responsible for rendering your view, and converting your code into glorious HTML. As such, they are directly responsible for HOW you need to write code in your views.

There's basically two ones you need to care about: ASPX and Razor. Razor is, in my opinion, much sleeker and easier to use, at the cost of only being supported in MVC3.

For example, a code block in ASPX might look like this:

<% foreach(var item in Model) { %>
    <tr>
        <td><%: item.Name %></td>
    </tr>
<% } %>

Whereas the Razor equivalent will look like this:

@foreach(var item in Model) {
    <tr>
        <td>@item.Name</td>
    </tr>
}

A view engine is what MVC uses to find and render the views you are requesting from the controller. If you are satisfied with the default routing you probably wont need to change anything, but lets say you wanted to have your shared files usually located in root/views/shared to instead be located in root/common, a custom viewengine is what you will need to create to be able to do that.

Here you can see how to build a viewengine:

<http://coderjournal.com/2009/05/creating-your-first-mvc-viewengine/>

The view engine is also responsible for rendering the view, but as you are just learning MVC you will probably not need to alter the rendering functionality just yet

In MVC, View engine is the one that works between your View and browser to provide valid HTML output to your browser by compiling the code inside your View. There are many view engines available and some of them are following:

1. ASPX

2. Razor

3. Spark

4. NHaml

5. NDJango

6. Hasic

7. Brail

8. Bellevue

9. Sharp Tiles

10. String Template

11. Wing Beats

12. SharpDOM

Currently most developers prefer to use Razor view engine as it provides very convenient way of programming. All of these view engines may not support ASP.NET MVC.

For more details you can visit this article.

A template/view engine enables you to use static template files in your application. At runtime, the template engine replaces variables in a template file with actual values, and transforms the template into an HTML file sent to the client. This approach makes it easier to design an HTML page.

View Engine works inside the application for rendering HTML page to the browser or to the user. It can contain HTML tags, server controls and some programming language.

Razor is preferred view engine for MVC4 framework.

In ASP.Net MVC, View engine is the one that works between your view and browser to provide valid HTML output to your browser by considering output provided by your view.There are many types of view engines.

1)ASPX

2)Razor

3)Spark

4)NHaml

5)NDJango

6)Hasic

7)Brail

I read a descriptive post at http://questionbox.in/view-engine-asp-net-mvc-razor-view-engine-asp-net-mvc-web-form-aspx-view-engine-asp-net-mvc/

View engine gives the ability to render the HTML from your view to the browser.

There are many view engines supported by ASP.NET MVC but the most widely used view engines are

• Web form / ASPX view engine.
• Razor view engine.

Web form view engine / ASPX view engine:

• Web Form View Engine / ASPX View Engine is the default view engine for the Asp.net MVC project. It is available from MVC 1.0
• The namespace for Web Form Engine is Web.Mvc.WebFormViewEngine
• File Extension for this View Engine is similar to Web Form as:

.aspx, for Views just like Web Form pages. .ascx, for Partial Views & Editor Template just like User Controls. .master, for Layout and Master Pages just like Master Pages in Web Forms.

• No support for TDD (Test Driven Development).
• Web Form Engine does not prevent XSS attacks means any script saved in the database will be fired while rendering the page
• Syntax : <%: Html.ActionLink(“Home”, “Index”) %>

Razor View Engine:

• The Razor View Engine is an advanced view engine, available with MVC 3.0 and later versions

• Namespace for ASPX view Engine is Web.Razor.

• File Extension for this View Engine is .cshtml (Razor C#), for Views, Partial Views, Editor Template and Layout Pages. .vbhtml (Razor VB.NET), for Views, Partial Views, Editor Template and Layout Pages.

• Supports TDD (Test Driven Development).

• Razor Engine is little bit slow as compared to Web form Engine.

• Razor Engine prevents XSS attacks(Cross-Site Scripting Attacks) means it encodes the script or html tags like <,> before rendering to view.

• Razor syntax is easy to understand and much clean than Web Form syntax. Razor uses @ symbol to make the code like as:

  @Html.ActionLink(“Home”, “Index”)

View Engine renders the view into HTML form to the browser. If we talk about an MVC application in the .Net Framework, it supports the following 2 view engines:

1. Razor View Engine 2. Web Form/ASPX View Engine

Differences : 1. Razor View Engine uses Layouts but ASPX view engine uses Master pages.

2. Razor View Engine uses partial page but ASPX view engine uses Web User Control.

3. Razor view engine is not a language, It is Markup syntax.

4. @’ symbol uses in Razor Engine to write the code. @Html.ActionLink("Login", "LoginView") ‘<%:’ delimiters use as starting point and ‘ %>’ use as ending point. You can write the code between them in ASPX Engine.

5. Razor View Engine has .cshtml (with C#) and .vbhtml (with VB) extension for views, Layout and Partial views. ASPX View Engine has a similar extension as in a simple web application like .aspx for the views, .acsx for UserControls and .master for Master Pages.

So far every response is related to ASP.NET. If you are looking for a view engine for nodejs, then some of the following are options:

Jade (Pug)
express-handlebars
ejs
React

There's a whole list of them that I found at https://github.com/expressjs/express/wiki#template-engines but the above ones seem to be the ones I hear about the most.

Two View Engines:

ASPX

ASPX view engine, the server side script is wrapped between [% %] .ASPX is its extention.

Razor

Razor we use @. Switching between HTML and code is Possible. Razor View extention .CSHTML and .VBHTML