This is another in a series of posts I’m doing that cover some of the new ASP.NET MVC 3 features: Introducing Razor (July 2nd) New @model keyword in Razor (Oct 19th) Layouts with Razor (Oct 22nd) Server-Side Comments with Razor (Nov 12th) Razor’s @: and <text> syntax (Dec 15th) Implicit and Explicit code nuggets with Razor (Dec 16th) Layouts and Sections with Razor (Today) In today’s post I’m going
to go into more details about how
Layout pages work with Razor. In particular, I’m going
to cover how you can have multiple, non-contiguous, replaceable “sections” within a
layout file – and enable views based on layouts
to optionally “fill in” these different sections at runtime. The Razor syntax for doing this is clean and concise. I’ll also show how you can dynamically check at runtime whether a particular
layout section has been defined, and how you can provide alternate content (or even an alternate layout) in the event that a section isn’t specified within a view template. This provides a powerful and easy way
to customize the UI of your site and make it clean and DRY from an implementation perspective. What are Layouts? You typically want
to maintain a consistent look and feel across all of the pages within your web-site/application. ASP.NET 2.0 introduced the concept of “master pages” which helps enable this when using .aspx based pages or templates. Razor also supports this concept with a feature called “layouts” – which allow you
to define a common site template, and then inherit its look and feel across all the views/pages on your site. I previously discussed the basics of how
layout files work with Razor in my ASP.NET MVC 3: Layouts with Razor blog post. Today’s post will go deeper and discuss how you can define multiple, non-contiguous, replaceable regions within a
layout file that you can then optionally “fill in” at runtime. Site
Layout Scenario Let’s look at how we can implement a common site
layout scenario with ASP.NET MVC 3 and Razor. Specifically, we’ll implement some site UI where we have a common header and footer on all of our pages. We’ll also add a “sidebar” section
to the
right of our common site
layout. On some pages we’ll customize the SideBar
to contain content specific
to the page it is included on: And on other pages (that do not have custom sidebar content) we will fall back and provide some “default content”
to the sidebar: We’ll use ASP.NET MVC 3 and Razor
to enable this customization in a nice, clean way. Below are some step-by-step tutorial instructions on how
to build the above site with ASP.NET MVC 3 and Razor. Part 1: Create a New Project with a
Layout for the “Body” section We’ll begin by using the “File->New Project” menu command within Visual Studio
to create a new ASP.NET MVC 3 Project. We’ll create the new project using the “Empty” template option: This will create a new project that has no default controllers in it: Creating a HomeController We will then right-click on the “Controllers” folder of our newly created project and choose the “Add->Controller” context menu command. This will bring up the “Add Controller” dialog: We’ll name the new controller we create “HomeController”. When we click the “Add” button Visual Studio will add a HomeController class
to our project with a default “Index” action method that returns a view: We won’t need
to write any Controller logic
to implement this sample – so we’ll leave the default code as-is. Creating a View Template Our next step will be
to implement the view template associated with the HomeController’s Index action method.
To implement the view template, we will right-click within the “HomeController.Index()” method and select the “Add View” command
to create a view template for our home page: This will bring up the “Add View” dialog within Visual Studio. We do not need
to change any of the default settings within the above dialog (the name of the template was auto-populated
to Index because we invoked the “Add View” context menu command within the Index method). When we click the “Add” Button within the dialog, a Razor-based “Index.cshtml” view template will be added
to the \Views\Home\ folder within our project. Let’s add some simple default static content
to it: Notice above how we don’t have an <html> or <body> section defined within our view template. This is because we are going
to rely on a
layout template
to supply these elements and use it
to define the common site
layout and structure for our site (ensuring that it is consistent across all pages and URLs within the site). Customizing our
Layout File Let’s open and customize the default “_Layout.cshtml” file that was automatically added
to the \Views\Shared folder when we created our new project: The default
layout file (shown above) is pretty basic and simply outputs a title (if specified in either the Controller or the View template) and adds links
to a stylesheet and jQuery. The call
to “RenderBody()” indicates where the main body content of our Index.cshtml file will merged into the output sent back
to the browser. Let’s modify the
Layout template
to add a common header, footer and sidebar
to the site: We’ll then edit the “Site.css” file within the \Content folder of our project and add 4 CSS rules
to it: And now when we run the project and browse
to the home “/” URL of our project we’ll see a page like below: Notice how the content of the HomeController’s Index view template and the site’s Shared
Layout template have been merged together into a single HTML response. Below is what the HTML sent back from the server looks like: Part 2: Adding a “SideBar” Section Our site so far has a
layout template that has only one “section” in it – what we call the main “body” section of the response. Razor also supports the ability
to add additional "named sections”
to layout templates as well. These sections can be defined anywhere in the
layout file (including within the <head> section of the HTML), and allow you
to output dynamic content
to multiple, non-contiguous, regions of the final response. Defining the “SideBar” section in our
Layout Let’s update our
Layout template
to define an additional “SideBar” section of content that will be rendered within the <div id=”sidebar”> region of our HTML. We can do this by calling the RenderSection(string sectionName, bool required) helper method within our
Layout.cshtml file like below: The first parameter
to the “RenderSection()” helper method specifies the name of the section we want
to render at that location in the
layout template. The second parameter is optional, and allows us
to define whether the section we are rendering is required or not. If a section is “required”, then Razor will throw an error at runtime if that section is not implemented within a view template that is based on the
layout file (which can make it easier
to track down content errors). If a section is not required, then its presence within a view template is optional, and the above RenderSection() code will render nothing at runtime if it isn’t defined. Now that we’ve made the above change
to our
layout file, let’s hit refresh in our browser and see what our Home page now looks like: Notice how we currently have no content within our SideBar <div> – that is because the Index.cshtml view template doesn’t implement our new “SideBar” section yet. Implementing the “SideBar” Section in our View Template Let’s change our home-page so that it has a SideBar section that outputs some custom content. We can do that by opening up the Index.cshtml view template, and by adding a new “SiderBar” section
to it. We’ll do this using Razor’s @section SectionName { } syntax: We could have put our SideBar @section declaration anywhere within the view template. I think it looks cleaner when defined at the top or bottom of the file – but that is simply personal preference. You can include any content or code you want within @section declarations. Notice above how I have a C# code nugget that outputs the current time at the bottom of the SideBar section. I could have also written code that used ASP.NET MVC’s HTML/AJAX helper methods and/or accessed any strongly-typed model objects passed
to the Index.cshtml view template. Now that we’ve made the above template changes, when we hit refresh in our browser again we’ll see that our SideBar content – that is specific
to the Home Page of our site – is now included in the page response sent back from the server: The SideBar section content has been merged into the proper location of the HTML response : Part 3: Conditionally Detecting if a
Layout Section Has Been Implemented Razor provides the ability for you
to conditionally check (from within a
layout file) whether a section has been defined within a view template, and enables you
to output an alternative response in the event that the section has not been defined. This provides a convenient way
to specify default UI for optional
layout sections. Let’s modify our
Layout file
to take advantage of this capability. Below we are conditionally checking whether the “SideBar” section has been defined without the view template being rendered (using the IsSectionDefined() method), and if so we render the section. If the section has not been defined, then we now instead render some default content for the SideBar: Note: You want
to make sure you prefix calls
to the RenderSection() helper method with a @ character – which will tell Razor
to execute the HelperResult it returns and merge in the section content in the appropriate place of the output. Notice how we wrote @RenderSection(“SideBar”) above instead of just RenderSection(“SideBar”). Otherwise you’ll get an error. Above we are simply rendering an inline static string (<p>Default SideBar Content</p>) if the section is not defined. A real-world site would more likely refactor this default content
to be stored within a separate partial template (which we’d render using the Html.RenderPartial() helper method within the else block) or alternatively use the Html.Action() helper method within the else block
to encapsulate both the logic and rendering of the default sidebar. When we hit refresh on our home-page, we will still see the same custom SideBar content we had before. This is because we implemented the SideBar section within our Index.cshtml view template (and so our
Layout rendered it): Let’s now implement a “/Home/About” URL for our site by adding a new “About” action method
to our HomeController: The About() action method above simply renders a view back
to the client when invoked. We can implement the corresponding view template for this action by right-clicking within the “About()” method and using the “Add View” menu command (like before)
to create a new About.cshtml view template. We’ll implement the About.cshtml view template like below. Notice that we are not defining a “SideBar” section within it: When we browse the /Home/About URL we’ll see the content we supplied above in the main body section of our response, and the default SideBar content will rendered: The
layout file determined at runtime that a custom SideBar section wasn’t present in the About.cshtml view template, and instead rendered the default sidebar content. One Last Tweak… Let’s suppose that at a later point we decide that instead of rendering default side-bar content, we just want
to hide the side-bar entirely from pages that don’t have any custom sidebar content defined. We could implement this change simply by making a small modification
to our
layout so that the sidebar content (and its surrounding HTML chrome) is only rendered if the SideBar section is defined. The code
to do this is below: Razor is flexible enough so that we can make changes like this and not have
to modify any of our view templates (nor make change any Controller logic changes)
to accommodate this. We can instead make just this one modification
to our
Layout file and the rest happens cleanly. This type of flexibility makes Razor incredibly powerful and productive. Summary Razor’s
layout capability enables you
to define a common site template, and then inherit its look and feel across all the views/pages on your site. Razor enables you
to define multiple, non-contiguous, “sections” within
layout templates that can be “filled-in” by view templates. The @section {} syntax for doing this is clean and concise. Razor also supports the ability
to dynamically check at runtime whether a particular section has been defined, and
to provide alternate content (or even an alternate layout) in the event that it isn’t specified. This provides a powerful and easy way
to customize the UI of your site - and make it clean and DRY from an implementation perspective. Hope this helps, Scott P.S. In addition
to blogging, I am also now using Twitter for quick updates and
to share links. Follow me at: twitter.com/scottgu
