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.

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:

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.

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 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.

ASP.NET Core MVC

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.

ASP.NET Core WebAPI

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.

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 asp.net 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)
{
    app.UseMiddleware<CustomLoggingMiddleware>();
    //...
}

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.