We are still using asp.net mvc WebForms (legacy code) with a lot of our own frameworks.
one of our features is gathering the static content on run time and creating the min and optimize versions. (we found out it was faster).
Yet Razor rendering pipeline is different then WebForms, so the content is rendered out of order.
For example we have a view to render lets call it Home, Home has several calls to X.Css("css_x");
we gather them into a 'list' Home has partial view to render which inside also has X.Css invocation.
After Home is rendered into the output buffer stack the _Layout is rendered again with X.Css being called. assume that now we need to render all of the css files but the order is wrong.
How is it possible to synchronize view and layout with the order i need (first layout then views and partials)
Any one got an idea.
(if i am not understood please let me know and i'll try to elaborate more)
I am interested into looking at SPA's with MVC. I realized I can use Kendo UI controls with this as well, which is great.
So I am following a post at http://a.shinynew.me/post/78038782111/a-kendo-ui-asp-net-mvc-spa-template which is interesting.
The issue is that I am experienced with mvc and razor, and it looks like this template takes the html route, which seems like a bit of a steeper learning curve, and won't be as easy to leverage my existing code. I can't figure out how to hook up new views to the MVC methods, everything hits the Home / Index method.
Then I read [link in comments because I need 10 rep to post 2 links] but the template that you download doesn't seem to have anything under Script/App or App. The project seems completely different now, irritatingly. But then, I noticed this:
You have two options for SPA views that will be loaded into the SPA:
standard HTML (.html) or ASP.NET MVC Razor (.cshtml) pages. Because
this article is intended for .NET developers—and a lot of enterprises
have server-side libraries and frameworks they’d like to continue
using in their views—I’ll go with the latter option of creating Razor
views.
So my question is, how could I convert the http://a.shinynew.me/post/78038782111/a-kendo-ui-asp-net-mvc-spa-template template to use Razor views instead of .html
So I just started at a new company and I'm trying to understand their code and it is quite complex. I am trying to debug a page and I know which view it is and I can set a break point in the view but I can't figure out which controller returned this view. How can I do this?
Recap: I can break in a view and I need to figure out what controller it came from.
If the application is using the Razor view engine (.cshtml files) you can use the following inside your view/layout to display the controller and action names:
#ViewContext.RouteData.Values["controller"].ToString()
#ViewContext.RouteData.Values["action"].ToString()
If it is using the WebForms view engine (.aspx files) you can do something similar with:
<%= RouteData.Values["controller"]%>
<%= RouteData.Values["action"]%>
The controller class will usually be named as in the route data plus "Controller". The action names will usually match a method name in the controller.
You may also consider getting a branch of the project just for you, and then install glimpse via Nuget. That may help you understand better the application.
Views usually are named after Controller action names. And views are placed in folders named after controllers.
Check this one for folder structure: http://www.codeproject.com/Articles/492833/ASP-NET-MVC-4-Part-2-Project-Items
Also you can set breakpoints in controllers and see which one is hit.
And I recommend watching free pluralsight course on MVC. I helped me a lot when I started with MVC.
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:
ASPX
Razor
Spark
NHaml
NDJango
Hasic
Brail
Bellevue
Sharp Tiles
String Template
Wing Beats
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
I am using Asp.Net MVC 3.0 and I have my _layout.cshtml in Shared folder. Problem is I want to generate menus in this .cshtml which should be loaded from database. But as I understand _layout.cshtml won't have any action etc associated where I can write logic and I don't want to write all this code in cshtml itself. Are there any options to write logic for cshtml within Shared folder?
You can setup a Controller and a view to render the menu and call it inside the _layout.cshtml.
#{ Html.RenderAction("Index", "Menus"); }
Eranga is correct, but let me expand on his answer, to answer your question specifically.
What you can do is create a new controller ("menus" for example), and create an action called default. Have this action return a view, calling it whatever you would like. Now go to your shared folder and add the view using the name you just specified.
Now for the cool part. By default, the MVC framework will look in the controllername/viewname path first, and if it fails it will then look at your shared/viewname path, which is where the view you just created resides! Neat, huh? ;p
Check out http://www.aspnetmvcninja.com/views/view-search-paths for more info on MVC search paths.
#Eranga has given you a good head start on implementing the feature you requested. I think the below two articles will be helpful as well:
Html.RenderAction and Html.Action:
http://haacked.com/archive/2009/11/18/aspnetmvc2-render-action.aspx
A sample implementation of Html.Action method with caching:
http://www.tugberkugurlu.com/archive/donut-hole-caching-in-asp-net-mvc-by-using-child-actions-and-outputcacheattribute