ASP.NET Core is a framework made by Microsoft that provides a consistent approach for creating web-based applications. ASP.NET Core offers a flexible and efficient framework. Its main aim is to simplify the development process and provide developers with valuable features and tools.



  1. Cross-platform capability: ASP.NET Core is a framework that can run on macOS Linux and Windows.
  2. Improved performance and smaller deployment size: ASP.NET Core offers better performance compared to the older .NET Framework. It is a smaller and more lightweight platform, resulting in faster application performance. Additionally, ASP.NET Core allows developers to include only the necessary dependencies, reducing the overall deployment size.
  3. Unified model: ASP.NET Core introduces a unified model that combines MVC and Web API. This reduces overlap and provides a smoother development experience. Developers can build web applications and APIs using a consistent approach.
  4. Versatility and rich feature set: ASP.NET Core offers many features and tools for building various types of applications. It supports web applications, APIs, microservices, real-time applications with SignalR, and server-side rendered UI with Blazor. The framework includes concepts such as Razor Pages, MVC, routing, dependency injection, and middleware, which enable developers to build robust and scalable applications.
  5. Open source and extensible: ASP.NET Core is an open source framework. It provides extension points and customization options through the middleware pipeline and built-in IoC container, enabling us to tailor the framework to their specific needs.

What is ASP.NET Core?

ASP.NET Core is a free open-source and cross platform framework for building modern and internet connected applications. We can build applications that can run on Windows, Linux, and MacOS, thus increasing our potential reach and flexibility.

It offers lot of features that make it an appealing choice for developers, including its speed, the ability to host it on multiple platforms, it's lean and modular nature that allows us to only include the necessary dependencies and its built-in dependency injection.

Let's compare ASP.NET Core to its predecessor to understand the upgrades and improvements.

Difference between .NET Core and .NET Framework

While both .NET Core and .NET Framework are development platforms developed by Microsoft for building applications (ASP.NET works on top of them), However, there are several differences between the two platforms.

  1. Platform support: .NET (the latest release omitted the word “Core” and become .NET + the version number like .NET 8.0) is cross-platform, meaning that it can be used to build softwares that run on Windows, macOS, and Linux. While the .NET Framework is a Windows-only platform.
  2. Deployment: .NET applications can be deployed as self contained applications or as side by side applications. Self-contained applications are complete applications that include everything they need to run, including the .NET runtime.
  3. Performance: .NET applications are generally faster than .NET Framework applications. This is because .NET Core is a smaller and more lightweight platform
  4. Overall, .NET is a more modern and flexible platform than the .NET Framework. However, the .NET Framework is more stable and mature. The best platform for you will depend on your specific needs.

Here we have a table that summarizes the key differences between .NET (core) and .NET Framework:

Feature .NET .NET Framework
Source Code Open Source Closed Source
Platform support Cross-platform Windows-only
Deployment Self contained or side by side Side by side
Performance Faster Slower
Feature support Less feature-rich More feature-rich
Maturity Less mature More mature

So, .NET (.NET Core) offers improved performance, smaller deployment sizes, and the ability to target more platforms, such as Linux, Mac, and Docker.


While ASP.NET is a mature framework with a rich ecosystem. Its latest version ASP.NET Core has been re-imagined to provide more modern, lean, and modular features.

ASP.NET was released as part of the .NET Framework with web forms, then added improvements over the years with the introduction of MVC, Web Pages, and ASP.NET Web API. However, these technologies evolved separately leading to overlapping functionalities. But runs just on a Windows environment.

On the other hand, ASP.NET Core comes with unified models. This means that MVC and Web API are bundled together, reducing the overlap and providing a smoother experience. And runs on OSs other than Windows like Linux, and macOS.

ASP.NET Core Versions

Since its first release ASP.NET Core has seen a number of versions each one adding more features performance improvements and bug fixes. The ASP.NET Core latest version is ASP.NET Core 8.

ASP.NET Core 8.0 introduces several significant changes, including new features for SignalR and Minimal APIs, and native ahead-of-time (AOT) compilation, and much more. You can read the ASP.NET Core official documentation for more details.

ASP.NET Core Fundamentals

ASP.NET Core provides several features and concepts that form the bedrock of the framework. These include Razor Pages, MVC, Web API, Blazor, routing, dependency injection, middleware, and more. These building blocks allow developers to build robust and scalable web applications.

ASP.NET Core Razor Pages

Razor Pages is a feature of ASP.NET Core that makes coding page-focused scenarios easier and more productive. Razor Pages are similar to views in an ASP.NET Core MVC application, but they have a simpler structure and come with built-in conventions that handle the controller part of the MVC.

ASP.NET Core Razor Pages combine HTML markup, C# code, and Razor syntax to create dynamic content. They provide a straightforward approach to building web applications without the need for explicit controllers.


MVC stands for Model-View-Controller, separates an application into three interconnected components: the Model (data and business logic), the View (user interface), and the Controller (handles user input and updates the model). MVC promotes code organization, modularity, and separation of concerns.

In ASP.NET Core, MVC helps to build applications with separation of concerns.


Web APIs in ASP.NET Core are HTTP services that can be accessed using any client like browsers, mobile devices, desktop apps, or IoT devices. In ASP.NET Core, the unified MVC and Web API frameworks provide a single, consistent way of building web applications and APIs.

Unified MVC and Web API

Before ASP.NET Core, MVC and Web API were two separate frameworks for building web applications and HTTP APIs, respectively. They had similar concepts but different classes and interfaces, which led to a lot of duplication and inconsistency.

With ASP.NET Core, MVC and Web API have been unified. Now, controllers can return views (like in MVC) or data (like in Web API). This unified framework provides a consistent and streamlined approach to developing web applications and APIs.

ASP.NET Core Blazor

Blazor is a feature of ASP.NET Core that allows us to build interactive client-side web UI with .NET. It uses WebAssembly (a binary instruction format) to execute .NET code in the browser. So we don't need JavaScript and we can write client side code with .NET!

ASP.NET Core Routing

Routing is a process of directing an HTTP request to a particular action method of a controller in MVC. ASP.NET Core routing gives you control over the URLs used by your application. It provides a flexible way to define your routes using route templates and constraints, and it supports attribute routing, where you define the route directly on the action method.

ASP.NET Core Dependency Injection

Dependency Injection (DI) is a design-pattern that allows us to eliminate rigid dependencies among objects. ASP.NET Core has built-in support for DI and uses it to provide services to controllers, Razor Pages, and other components.

ASP.NET Core Middleware

Middleware in ASP.NET Core, assembled into an application pipeline to handle requests and responses. It's software that sits between the application and the network, handling tasks like logging, exception handling, serving static files, and more.

Each piece of middleware in the request pipeline is responsible for invoking the next piece in the chain, or short-circuiting the chain if its work is complete.

Why Use ASP.NET Core?

There are several reasons why .NET deveopers should consider using ASP.NET Core for their next web application project.

Development Tools for ASP.NET CORE

ASP.NET Core is supported by excellent developer tools. We can use Visual Studio and VS Code for free. These tools provide features like IntelliSense, debugging, Built-in Git support, extensions, and more.

Code Sharing in ASP.NET Core

This feature becomes increasingly important as businesses nowadays often need to develop applications that can run on various platforms, including Linux, macOS, and Windows.

For example, you might have a repository class accessing data:

public class Repository
    private readonly DbContext _context;
    public Repository(DbContext context)
        _context = context;

    public Task<List<Customer>> GetCustomersAsync()
        return _context.Customers.ToListAsync();

This class can be shared across multiple projects reducing code duplication and improving maintainability.

Extensibility in ASP.NET CORE

ASP.NET Core is designed to be an extensible framework. It has a number of extension points that developers can use to customize the behavior of the framework and include additional functionality.

This is done through the middleware pipeline, where developers can add custom middleware to handle specific requests. Also, the built-in IoC container allows developers to replace or add services as needed.

For instance if we want to add custom logging to our core application we can create a middleware for that:

public class CustomLoggingMiddleware
    private readonly RequestDelegate _next;
    private readonly ILogger _logger;

    public CustomLoggingMiddleware(RequestDelegate next, ILogger<CustomLoggingMiddleware> logger)
        _next = next;
        _logger = logger;

    public async Task Invoke(HttpContext context)
        _logger.LogInformation("Handling request: " + context.Request.Path);
        await _next.Invoke(context);
        _logger.LogInformation("Finished handling request.");

And register it in the “Configure” method of the “Startup” class:

public void Configure(IApplicationBuilder app, IHostingEnvironment env)

Asp.Net Core is Open Source

ASP.NET Core is an open-source framework. This means that its source code is publicly available. This fosters sense of community and allows the framework to benefit from the contributions of developers all over the world.

Being open source also means that ASP.NET Core is transparent. You are allowed to look at the source code to understand how the framework works find solutions to problems or even contribute your own improvements.

Asp.Net Core Cross-Platform

ASP.NET Core can run on different platforms. If your application is running on Windows Linux or macOS you can use ASP.NET Core to build and deploy your application.

This cross-platform capability is possible because ASP.NET Core is built on top of .NET (previously known as .NET Core). This means that we can write our code once and run it on any platform, thereby maximizing your reach and flexibility.

Fewer dependencies and Smaller Deployment

ASP.NET Core is designed to minimize the deployment footprint of applications. This is achieved through the modular nature of the framework. With ASP.NET Core you only include the libraries and dependencies that your application needs which reduces the size of the deployed ASP.NET Core application.

Asp.Net Core Application

ASP.NET Core is a versatile framework that has potential to build a wide range of applications. It supports the development of web applications, APIs, microservices, real-time applications with SignalR, and even server-side rendered UI with Blazor.

Moreover ASP.NET Core is cross-platform meaning you can develop and deploy your applications on Windows Linux and macOS. This versatility is one of the too many reasons why developers choose ASP.NET Core for their projects.


ASP.NET Core is a powerful versatile and high-performance framework for building modern web applications.

Its modular nature, extensibility, and rich set of features such as MVC, Razor Pages, Web API, Blazor, Routing, Dependency Injection, and Middleware make it truly ASP.NET Core awesome.

You can create a free account on, host your ASP.NET Core application and create a free SQL Server Database!

Let’s go ahead and read other detailed articles on .NET 8, .NET 7, and .NET 6 to learn more about the .NET ecosystem.