The View is said to be UI part of a web application. In simple, it can be called HTML Template which is used to generate final HTML. It is important to note that Razor code is executed server side to generate final HTML of a page with Help of Razor Engine. ASP.NET Core MVC Views has a .cshtml extension (for C# ) and by default, these files are stored in Views folder. Generally,  a controller has its own folder with views for related controller action methods.

By use, there following main types of views:
  • Action Specific Views
  • Partial Views
  • Layouts
  • Special View

Action Specific Views

Action Specific View are called from some action method and they generally stored  in the view folder related controller and by default have  the same name as of action method. We can call views of different name by specifying view name and from the different folder by specifying full path from an action method. Generally full qualified path is like “~/Views/FolderPath/ViewName.cshtml” or with relative path “../FolderPath/ViewName.cshtml”. Please refer to ASP.NET Core 1.0 MVC Controller for more details about Controllers.

Partial views

Partial View said to be reusable components and very similar to web control in ASP.Net Web Forms. They can also be used to decompose complex structures into smaller parts. But the main purpose of them is re-usability. Partial View is rendered within another view. Partial views has the same extension like view .cshtml and it is not required but a practice to start partial view with an underscore (_). Technically, the partial view is same as a normal view but we make its Layout null. Furthermore, special views like _ViewStart are not executed for partial views.
We can add a partial view into a view with @Html.Partial(“_ViewName”), while partial view can have relative or full qualified path.  And if we have strongly typed partial view, then we may add partial view with @Html.Partial(“_ViewName”, dataModel).It is important to note that partial views can be nested. So we can add a partial view in another partial view. Within each view or partial view, relative paths are always relative to that view, not the root or parent view. We are not allowed to have partial views loop cycle (circular nesting).


Layout Views are said to be main structure and they are very similar to Master Page in ASP.NET Web Forms. Layout View defines the main structure of a web application and may contain header, menu, footer and page content area as per requirements. They facilitate us to define and handle all these at one place. It is common to have at least one layout view, but we can have more than one layout views to meet different requirements. For example, we can have different layouts for front office and back office. Or to have the different layout for popups. It is customary to have layout view as “_Layout.cshtml” in Shared Folder of Views. We set the layout of a page with the following statement in view or in _ViewStart.cshtml.

  Layout = “_Layout”; 

Layout view contains special tag @RenderBody() in which main called view is added and @RenderSection() which specifies a section to be rendered in the view. We will discuss sections in detail in future sessions

Special View

Like Layout view, ASP.NET has couple of other special views:
  • _ViewImports.cshtml
  • _ViewStart.cshtml


_ViewImports view is used to perform activities like importing namespaces or performing dependency injection, shared directive. Generally, we have _ViewImports  at the root Views folder, but we can have as many as required. For example, we can add _ViewImports view in each folder. In this case, current folder settings are added to settings from an upper folder. And in the case of conflict settings from nearest _ ViewImports view get preference. The _ViewImports file supports the following directives:
  • @addTagHelper
  • @removeTagHelper
  • @tagHelperPrefix
  • @using
  • @model
  • @inherits
  • @inject


_ViewStart.cshtml is used to execute common tasks like setting Layout View. The statements listed in _ViewStart.cshtml are run before every view except layouts and partial views. Generally, _ViewStart.cshtml is located in the Views folder. Like _ViewImports.cshtml every folder can have _ViewStart.cshtml. These are executed from parent to child in sequence.

View Discovery

View Discovery in the process to identify the viewed called by an action method or a partial view during rendering of final Html. If a view name is not specified or name without path is specified then this process determines which view file will be used based on predefined steps. For example, when an action returns the View without view name then action name is used as the view name. Similarly, runtime looks for a controller-specific view first, then looks for matching view name in the Shared folder. And when a view is specified with a full qualified path then only specific view file is used.

View Categorization based on Model

We can categorize views on bases of Model or data manipulation as following:

  • Loosely Typed or Type Less Views
  • Strongly Typed Views
  • Dynamic Views

Loosely Typed or Type Less Views

We can pass data to views using loosely typed data collections: ViewData and ViewBag.


ViewData is a dictionary object accessed through string keys. We can store and retrieve objects in it, and we may need to cast them to a specific type. We can use ViewData to pass data from a controller to views, as well as within views (and partial views and layouts). String data can be stored and used directly, without the need for a cast.

In Action Method  
 public IActionResult About() 
   ViewData["Message"] = "Your application description page."; 
   return View(); 
In View 
   ViewData["Title"] = "About"; 


The ViewBag property is a wrapper around ViewData that provides a dynamic view over that collection. It is not a separate collection. The ViewBag objects provide dynamic access to the objects stored in ViewData. This can be more convenient to work with since it doesn’t require casting.

In Action Method  
 public IActionResult Contact() 
   ViewBag.Message = "Your contact page."; 
   return View(); 
 In View 
   ViewBag.Title = "Contact"; 

Which One to Use

Although ViewBag is just a wrapper on ViewData collection and we can mix and match between ViewData and ViewBag without any issue, yet it is better to use one approach in a project.

Strongly Typed Views

Strongly Typed View has a specific a model type in the view, and it is mapped to an instance of this type passed to the view from the action as a parameter. We can specify a model for a view using the @model directive then the instance sent to the view can be accessed in a strongly-typed manner using @Model as an object of specified type.It is highly practiced and is most recommended option to pass data as it gives the lot of benefits like robustness, compilation protection over other approaches.

Although we can use any type as a model, but it's recommend to use Plain Old CLR Object (POCO) ViewModels. Please refer to ASP.NET Core 1.0 MVC Model for more details about Model and ViewModel,

Dynamic Views

Dynamic Views are hybrid of both Strongly Typed and Loosely-Typed Views. In this kind of view, a model is not declared but have a model instance passed to them. But @model and it's properties  can be used in view dynamically. In this case, we don't have compilation protection or IntelliSense. If the property doesn’t exist, then an application crashes at runtime.

Additional Features

There are many other features related to Views like following, but we may discuss them in different sessions in future:
  • Tag Helper
  • HTML Helper
  • View Scaffolding
  • Razor Engine

Further Reading

For further details, please refer to the official documentation at