Razor pages vs MVC
Tags: razor, mvc, webdev, aspdotnet
Published: 2024-05-29 08:39:30

## What is ASP.NET?
ASP.NET is a type of software framework/infrastructure that was developed by Microsoft. ASP.NET is used for developing, running, and deploying the applications same as console applications, window services, and web applications. It is a web application of .NET framework that is used to create dynamic web pages.

It does not require any license for developing web applications. Microsoft ASP.NET Provides open-source for all users. That was used for web development and Windows-based app development. ASP stands for (Active Server Pages). Most of the developers prefer Asp.Net Technology because it is too easy to create and maintain the existing project source code and HTML. ASP .NET languages can be built to be language-independent.

## What are Razor Pages?
The Razor Page is similar to the HTML page but it loads data easily. A Razor Page is almost the same as ASP.NET MVC’s view component. It has basically the syntax and functionality the same as MVC. Now, what is the [difference between MVC and Razor pages](https://www.ifourtechnolab.com/blog/razor-pages-vs-mvc-in-asp-net)?

The basic difference between Razor pages and MVC is that the model and controller code is also added within the Razor Page itself. You do not need to add code separately.

It is similar to MVVM (Model-View-View-Model) framework. That provides two-way data binding and a simpler development experience with isolated concerns.

The ASP.NET MVC has been extremely popular nowadays for web application development, and it definitely has lots of advantages. In fact, the ASP.NET Web Forms was particularly designed as an MVVM solution in MVC.

But, the new ASP.NET Core Razor Pages is the next development of ASP.NET Web Forms.

## Razor Pages vs ASP.NET CORE MVC: Key features
Let’s go through the basics like what is razor pages and what features they support.

### What is Razor pages vs MVC?
Each one of these frameworks has its own benefits and is suited for different purposes.

MVC offers impeccable flexibility and scalability which best fits large-scale projects with complex requirements while Razor pages provide simplicity and efficiency in creating basic pages.

#### Features of Razor Pages:

- Supports cross-platform development.
- No controllers used.
- Basic structure includes CSHTML Razor file and .cshtml.cs code-behind file.
- Each page handles its model and specific actions.
- Utilizes anti-forgery token validation.
- Model declaration is called AboutModel.
- Default routing configuration in the Pages folder based on request.
- Can be deployed on Windows, UNIX, and Mac.

#### Features of ASP.NET MVC (Model-View-Controller):

- Uses controllers to bridge model and view components.
- Requires AddMvc() in Startup.cs for Core web apps.
- Sends commands to update the model and handles user interaction.
- Takes more time for coding dynamic routes and naming conventions.
- Complex routing structures, more effort is needed compared to Razor Pages.
- Requests routed based on controller names and actions.
- Ability to route any request to any controller with additional work.

## ASP.NET MVC vs Razor Pages — The Similarities
When you get into detail on MVC vs Razor, you may discover a lot of similarities. Some of the critical ones are:

- They use the same technology stack, including the Razor view engine for UI rendering.
- They make use of the same server-side runtime, enabling the use of the same language, tools, and libraries for ASP.NET application development.
- Follow the MVC (Model-View-Controller) architectural pattern, breaking applications into three interconnected components: model, view, and controller.

Razor vs MVC framework: Both offer a way to organize code logically and maintainably.
- Employ routing to map incoming requests to specific code.
- Support dependency injection for injecting dependencies into controllers or pages.

ASP.NET razor vs MVC framework: Both provide extensibility and customization:

- DOT NET developers may seamlessly create custom filters, tag helpers, and middleware to modify or extend behavior of your application framework.

Thus, all these similarities between MVC vs Razor pages make it easy for .NET developers to switch between the two frameworks or employ them in the same application.

Now, you might be thinking if these are similarities then what are the differences between MVC and Razor pages in ASP.NET? Let’s look into it in detail.

## What is Razor Syntax in MVC?
There are two types of Razor syntax.

- Single statement block: It starts with @.
- Multi statement block: It needs to be always written between this @ {.……}
The semicolon “;” must be wont to end statements. Here variable and function starts with the @ symbol.

## Single block Statements
A single statement block is used when you want to work with a single line of code written on the MVC view page.

Example

To display current Date-time. Create Index.CSS HTML View and add the below code.

```
 @{  
    ViewBag.Title = "Index";  
}<div>  
            <label>Current-Date: @DateTime.Now.ToString()</label>
  
            <label>Current-Long Date: @DateTime.Now.ToLongDateString()
</label></div> 

```
Inspect browser and search for “DateTime.Now.ToString()” on browser. You can't see the c# code on the browser side as you did.

If you inspect the browser and search for “DateTime.Now.ToString()” on the browser.

We can only see the HTML code. This is the job of View Engine. It converts C# code into pure Html format in the browser.

## Multi statement block

We also define a multiline statement block as a single-line statement block. In this block, we can define more than one line of code statements and do processes. A multiline block is between opening and closing curly braces like that {....}, but the opening brace will have the one “@" special character in the same line if we define the "@" and opening curly braces in different lines then it will display an error.

Example:

```
<div>
@{
    Var c++ = 200;
    Var Rubi = 800;
    Var Ionic = 100;
    Var sum = (c++ + Rubi + Ionic);
  }
addition of @ c++ and @Rubi and @Ionic is</div>

```

Now, see how to write Razor code:

## Basic Structure of Razor Pages and MVC
Razor pages do not have any type of structure like MVC. But all Razor pages inbuilt under the Pages folder with a very simple structure. You have to see the below screenshot for more understanding. Further, you can organize your project structure based on your requirements.

Understand Razor pages vs MVC structure from the below image.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/xghklxe1drsuzo5sx76h.png)
Razor Structure


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/mp30g51olj9x68tgdwpy.png)
MVC Structure

The above screenshot will describe to you about differences between the project structure of .Net Razor pages and MVC.

## Code Comparison between MVC and Razor
As we already mentioned above that Razor pages and MVC look almost similar i.e. both having. cshtml as the file

If you will notice the 2 pages, one from Razor and another from MVC then you will notice the @page at the top of Razor pages.

In Razor Page use @Page is a directive and one more difference is the model declaration in Razor pages.

In Razor Pages, we can declare model is like below

For example, Demo.cshtml – @model DemoModel

```
For Index.cshtml – @model Indexmodel
@model RazorPageTest.Models.PageClass<form asp-action="pgmanage"><div id="pg”class="><h4>Client</h4>
<div asp-validation-summary="DEMOMODE" class="text - default "> </div>
            <input asp-for="MODEL" type="hidden"><div class="form-group"><div class="col-md-9">
            <input asp-for="Display" class="form-control"></div></div>
<div class="form-group"><div class="col-md-offset-1 col - md - 10">
            <input class="btn btn - denger" type="submit" value="SubmitData"></div></div></div></form>

```

There is the MVC controller. Our model is DemoClass which only have two properties with a simple example.

```
public class DemoController: Controller
    {
        public IConfiguration Configuration;
        public DemoController(IConfiguration conf)
        {
            Configuration = conf;
        }
        public async Task<iactionresult> ManagePage(int E_id)
        {
            PageClass p;
            using (var cn = new SqlConnection   (Configuration.GetConnectionString("cdb")))
            {
                await conn.OpenAsync();
                var pg= await conn.QueryAsync<pageclass>("select * FROM     PageData Where PageDataID = @pa1", new { pa1 = id });
Pg = pg.FirstOrDefault ();
            }
            return View(pg);
        }
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<iactionresult> ManagePage(int id, PageClass  pg)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    using (var cn = new SqlConnection   (Configuration.GetConnectionString("cndb")))
                    {
                        await conn.OpenAsync();
                        await conn.ExecuteAsync("UPDATE PageData SET Title     = @Title WHERE PageDataID = @PageDataID", new { page.PageDataID,       page.Title});
                    }
                }
                catch (Exception)
                {
                   return lgdata
                }
                return RedirectToAction("Demo", "Home");
            }
            return View(pg);
        }
    }
</iactionresult></pageclass></iactionresult>

```

You can add a new Razor Page to your application. First of all, go to visual studio and click on the file menu and select a new project, Add -> Razor Pages


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/zrv2hri1mxv8jmuktusw.png)

After that, given the appropriate name to the view and select your required options and then click on Add button.

Let's check default code- inside the Demo.cshtml

```
public class Demo: pgModell
    {
        public void OnGet()
        {
         @TempData= @dt;
        }
}

```

There is no code-behind in MVC.

## ASP.NET CORE MVC vs Razor pages – What to choose for your Project?
Razor Pages excel when dealing with structured and straightforward content, making them a preferred alternative for login or contact form kind of pages. Its convenience in making centralized code for specific pages while facilitating the separation of logic into external classes makes it an interesting option for web development. This promotes core organization keeping controllers uncluttered, and maintainable.

On the flip side, MVC shines in scenarios involving intricate databases and web applications characterized by dynamic server views, RESTful APIs, and frequent AJAX calls. It's more comprehensive and allows for efficient data handling and interactions.

Now that you understand the instances in which Razor pages and MVC work well together, you can decide which one to use based on your business requirements.

## Conclusion
The decision between Razor Pages and MVC should be based on the demands of your project. Razor Pages are a simple and organized solution for simpler, content-focused pages. When dealing with big applications that require substantial database interactions and dynamic features, however, MVC's flexibility and sturdy design make it the better choice. Finally, the selection is determined by the nature and scope of your web development project.

In this blog, we explored the principles of ASP.NET Razor pages, MVC fundamentals, and the similarities and differences in ASP.NET Razor pages vs MVC.