There are various methods available to create a login system but here I'm introducing a way to design complete signup and login system using dependencies in asp.net core with SQL database.

What is a dependency?
The term dependency means to depend on anyone else which means if an object is dependent on other objects that is called a dependency. Dependency is a relationship between a component or class that can be thought of as a uses relationship generally the parameterized constructor that provides an object for a needed class. If you have more than one class that class is dependent on each other that is dependency. The dependency is injected into a parameterized constructor.

Step 1
Create a database from MSSQL.
create database dependencylogin
use dependencylogin;
create table users(id int primary key, Name varchar(50), Email varchar(50), Password varchar(50));
select * from users

Step 2
Create a table from the database and id is the primary key as well as identity with autoincrement.

Step 3
Open visual studio 2022 and click create a new project.

Step 4
Select ASP.Net core web App project and click on the Next button.

Step 5
Write the name of the project and click on the Next button.

Step 6
Click on the Create button for creating a project.

Step 7
Now my project is ready for use.

Step 8
Here create a new folder on solution explorer. Right-click on the project name in solution explorer and select Add option then select the new folder option then write the name of the folder.

Write the folder name as Models.

Step 9
In Models, folder right-click to choose to Add option and move to the class option, create a class with the class name as a connection.

Step 10
To make a property connection string name then create a constructor and pass the connection string.
namespace signuploginproject.Models
{
    public class connection
    {
        public string ConnectionString { get; set; }
        public connection()
        {
            this.ConnectionString = @"Data Source=LAPTOP-2L6RE54T;Initial Catalog=dependencylogin;Integrated Security=True";

        }
    }
}

Step 11
To install the System.Data.SqlClient package from NuGet Package Manager.

Step 12
Similar to creating another class on the Models folder the class name is DAL. Make a connection class object and pass  under the constructor.
using System.Data.SqlClient;
namespace signuploginproject.Models
{
    public class DAL
    {
        connection conn;
        public DAL(connection conn)
        {
            this.conn = conn;

        }
        public string GetValue(string query)
        {
            SqlConnection sqlconnection = new SqlConnection(conn.ConnectionString);
            SqlCommand cmd = new SqlCommand();
            cmd.Connection = sqlconnection;
            cmd.CommandText = query;
            sqlconnection.Open();
            var res = cmd.ExecuteScalar();
            sqlconnection.Close();
            return res.ToString();
        }
        public void SetValue(string query)
        {
            SqlConnection sqlconnection = new SqlConnection(conn.ConnectionString);
            SqlCommand cmd = new SqlCommand();
            cmd.Connection = sqlconnection;
            cmd.CommandText = query;
            sqlconnection.Open();
            cmd.ExecuteNonQuery();
            sqlconnection.Close();

        }
    }
}

Step 13
Similarly create one more class on the Models folder. The class name is Logics. Here create a DAL class object and pass a Logics class constructor. A Logic class makes two different functions for login and signup.
namespace signuploginproject.Models
{
    public class Logics
    {
        DAL DL;
        public Logics(DAL dl)
        {
            DL = dl;
        }
        public bool Login(string email, string password)
        {
            string query = $"select password from users where email='{email}'";
            var res = DL.GetValue(query);
            return res == password;
        }
        public string submitdata(string name, string email, string password)
        {
            string query = $"insert into users (name,email,password) values ('{name}','{email}','{password}')";
            DL.SetValue(query);
            return "Data submitted";

        }
    }
}

Step 14
Design an Index page for the Login page.
@page
@model IndexModel
@{
    ViewData["Title"] = "Home page";
}
<div class="container" style="width:30%">
  <center>
    <h2>Login</h2>
  </center>
  <form method="post">
    <div class="mb-3">
      <label class="form-label">Email</label>
      <input type="email" name="email" class="form-control">
    </div>
    <div class="mb-3">
      <label class="form-label">Password</label>
      <input type="password" name="password" class="form-control">
    </div>
    <div class="btn-group" style="margin-top:15px;">
      <button type="submit" class="btn btn-success">Submit</button>
    </div>
  </form>
  <center>
    <p>if you don't have an account to click <a href="/Signup"> Signup</a>
    </p>
  </center>
</div>

Login page

Step 15
Write a code on the Index model page.
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using signuploginproject.Models;
namespace signuploginproject.Pages {
    public class IndexModel: PageModel {
        private readonly ILogger < IndexModel > _logger;
        public IndexModel(ILogger < IndexModel > logger, Logics logic) {
            _logger = logger;
            this.logi = logic;
        }
        public void OnGet() {}
        Logics logi;
        public IActionResult OnPost(string email, string password) {
            bool res = logi.Login(email, password);
            if (res == true) {
                return Redirect("/dashboard");
            } else {
                return Redirect("/error");
            }
        }
    }
}

Step 16
Create a new razor page for signup and design a signup form.
@page
@model signuploginproject.Pages.signupModel
@{
}
<div class="container" style="width:30%">
  <center>
    <h2>Signup</h2>
  </center>
  <form method="post">
    <div class="mb-3">
      <label class="form-label">Name</label>
      <input type="text" name="name" class="form-control">
    </div>
    <div class="mb-3">
      <label class="form-label">Email</label>
      <input type="email" name="email" class="form-control">
    </div>
    <div class="mb-3">
      <label class="form-label">Password</label>
      <input type="password" name="password" class="form-control">
    </div>
    <div class="btn-group" style="margin-top:15px;">
      <button type="submit" class="btn btn-success">Submit</button>
    </div>
  </form>
  <center>
    <p>Have an account to click <a href="/Index"> Login</a>
    </p>
  </center>
</div>

Signup Page

Step 17
Write code on the signup model page.
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using signuploginproject.Models;
namespace signuploginproject.Pages {
    public class signupModel: PageModel {
        public signupModel(Logics logic) {
            this.logi = logic;
        }
        public void OnGet() {}
        Logics logi;
        public IActionResult OnPost(string name, string email, string password) {
            var rees = logi.submitdata(name, email, password);
            return Redirect("/index");
        }
    }
}

Step 18
Create a new razor page for the dashboard page and write the code.
@page
@model signuploginproject.Pages.dashboardModel
@{
}
<h1>Dashboard</h1>

Dashboard Page

Step 19
Add the services to the program.cs file for providing a class object when needed. To click on the program.cs file and write the code on container services.

To build and execute the project.

In this article, I am explaining how to implement custom JWT token authentication in ASP.NET Core 3.1 API. For this, I have created the demo application which has two controllers “AthenticateController” and “UserController”.

AthenticateController has one endpoint “AuthenticateUser”, which will authenticate the user based on the user id and password and if user is valid then it will generate the JWT Token.

UserController has two endpoints “GetUsers” and “GetUserById”.

GetUsers
I have implemented Authorization filter to secure the endpoint and this endpoint accepts HTTP GET requests and returns a list of all the users in the application if the HTTP Authorization header contains a valid JWT token. If there is no auth token or the token is invalid, then a 401 Unauthorized response is returned.

Similarly, GetUserById returns user details by id if the HTTP Authorization header contains a valid JWT token.

Project Architecture
Below is the project Architecture,

Follow below steps for project set up and generate JWT token:

Step 1
Create the ASP.NET Core 3.1 Web API Application. I am giving application name as “JWTTokenPOC”

Step 2
Install “Microsoft.AspNetCore.Authentication.JwtBearer” using NuGet Package manager. I have installed 3.1.26 version.

Step 3
Create new folder “Entities” inside the solution and create an entity class “User”
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Text.Json.Serialization;
namespace JWTTokenPOC.Entities {
    public class User {
        public int Id {
            get;
            set;
        }
        public string FirstName {
            get;
            set;
        }
        public string LastName {
            get;
            set;
        }
        public string Username {
            get;
            set;
        }
        [JsonIgnore]
        public string Password {
            get;
            set;
        }
    }
}

Step 4
Create new folder Models inside the solution and create two models AuthenticateRequest and AuthenticateResponse.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.ComponentModel.DataAnnotations;
namespace JWTTokenPOC.Models {
    public class AuthenticateRequest {
        [Required]
        public string UserName {
            get;
            set;
        }
        [Required]
        public string Password {
            get;
            set;
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using JWTTokenPOC.Entities;
namespace JWTTokenPOC.Models {
    public class AuthenticateResponse {
        public int Id {
            get;
            set;
        }
        public string FirstName {
            get;
            set;
        }
        public string LastName {
            get;
            set;
        }
        public string Username {
            get;
            set;
        }
        public string Token {
            get;
            set;
        }
        public AuthenticateResponse(User user, string token) {
            Id = user.Id;
            FirstName = user.FirstName;
            LastName = user.LastName;
            Username = user.Username;
            Token = token;
        }
    }
}

Step 5
Create new folder “Helper” inside the solution and create two helper classes “AppSettings” and “AuthorizeAttribute” in that folder.
namespace JWTTokenPOC.Helper {
    public class AppSettings {
        public string Key {
            get;
            set;
        }
        public string Issuer {
            get;
            set;
        }
    }
}
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;
using JWTTokenPOC.Entities;
namespace JWTTokenPOC.Helper {
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
    public class AuthorizeAttribute: Attribute, IAuthorizationFilter {
        public void OnAuthorization(AuthorizationFilterContext context) {
            var user = context.HttpContext.Items["User"];
            if (user == null) {
                // user not logged in
                context.Result = new JsonResult(new {
                    message = "Unauthorized"
                }) {
                    StatusCode = StatusCodes.Status401Unauthorized
                };
            }
        }
    }
}

Step 6
Add below appsetting in appsettings.json file.
"AppSettings": {
    "Key": "986ghgrgtru989ASdsaerew13434545435",
    "Issuer": "atul1234"
}

Step 7
Create new folder “Service” inside the solution and create two service classes “AuthenticationService” and “UserService” in that folder.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using JWTTokenPOC.Entities;
namespace JWTTokenPOC.Service {
    public interface IUserService {
        User GetById(int id);
        IEnumerable < User > GetAll();
    }
    public class UserService: IUserService {
        // List of user
        private List < User > _users = new List < User > {
            new User {
                Id = 1, FirstName = "mytest", LastName = "User", Username = "mytestuser", Password = "test123"
            },
            new User {
                Id = 2, FirstName = "mytest2", LastName = "User2", Username = "test", Password = "test"
            }
        };
        public IEnumerable < User > GetAll() {
            return _users;
        }
        public User GetById(int id) {
            return _users.FirstOrDefault(x => x.Id == id);
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.IdentityModel.Tokens;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using Microsoft.Extensions.Options;
using System.Text;
using JWTTokenPOC.Entities;
using JWTTokenPOC.Helper;
using JWTTokenPOC.Models;
namespace JWTTokenPOC.Service {
    public interface IAuthenticationService {
        AuthenticateResponse Authenticate(AuthenticateRequest model);
    }
    public class AuthenticationService: IAuthenticationService {
        // here I have  hardcoded user for simplicity
        private List < User > _users = new List < User > {
            new User {
                Id = 1, FirstName = "mytest", LastName = "User", Username = "mytestuser", Password = "test123"
            }
        };
        private readonly AppSettings _appSettings;
        public AuthenticationService(IOptions < AppSettings > appSettings) {
            _appSettings = appSettings.Value;
        }
        public AuthenticateResponse Authenticate(AuthenticateRequest model) {
            var user = _users.SingleOrDefault(x => x.Username == model.UserName && x.Password == model.Password);
            // return null if user not found
            if (user == null) return null;
            // authentication successful so generate jwt token
            var token = generateJwtToken(user);
            // Returns User details and Jwt token in HttpResponse which will be user to authenticate the user.
            return new AuthenticateResponse(user, token);
        }
        //Generate Jwt Token
        private string generateJwtToken(User user) {
            var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_appSettings.Key));
            var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);
            // Here you  can fill claim information from database for the users as well
            var claims = new [] {
                new Claim("id", user.Id.ToString()),
                    new Claim(JwtRegisteredClaimNames.Sub, "atul"),
                    new Claim(JwtRegisteredClaimNames.Email, ""),
                    new Claim("Role", "Admin"),
                    new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
            };
            var token = new JwtSecurityToken(_appSettings.Issuer, _appSettings.Issuer, claims, expires: DateTime.Now.AddHours(24), signingCredentials: credentials);
            return new JwtSecurityTokenHandler().WriteToken(token);
        }
    }
}

Step 8
Now inside Helper folder create a JwtMiddleware class. This class will be used to validate the token and it will be registered as middleware.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Options;
using Microsoft.IdentityModel.Tokens;
using JWTTokenPOC.Service;
using System.IdentityModel.Tokens.Jwt;
using System.Text;
namespace JWTTokenPOC.Helper {
    public class JwtMiddleware {
        private readonly RequestDelegate _next;
        private readonly AppSettings _appSettings;
        public JwtMiddleware(RequestDelegate next, IOptions < AppSettings > appSettings) {
            _next = next;
            _appSettings = appSettings.Value;
        }
        public async Task Invoke(HttpContext context, IUserService userService) {
            var token = context.Request.Headers["Authorization"].FirstOrDefault()?.Split(" ").Last();
            if (token != null)
                //Validate the token
                attachUserToContext(context, userService, token);
            await _next(context);
        }
        private void attachUserToContext(HttpContext context, IUserService userService, string token) {
            try {
                var tokenHandler = new JwtSecurityTokenHandler();
                var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_appSettings.Key));
                tokenHandler.ValidateToken(token, new TokenValidationParameters {
                    ValidateIssuerSigningKey = true,
                        ValidateAudience = true,
                        ValidateLifetime = true,
                        IssuerSigningKey = key,
                        ValidIssuer = _appSettings.Issuer,
                        ValidAudience = _appSettings.Issuer,
                        // set clockskew to zero so tokens expire exactly at token expiration time.
                        ClockSkew = TimeSpan.Zero
                }, out SecurityToken validatedToken);
                var jwtToken = (JwtSecurityToken) validatedToken;
                var userId = int.Parse(jwtToken.Claims.First(x => x.Type == "id").Value);
                // attach user to context on successful jwt validation
                context.Items["User"] = userService.GetById(userId);
            } catch (Exception) {
                // do nothing if jwt validation fails
                // user is not attached to context so request won't have access to secure routes
            }
        }
    }
}

Step 9
Now open the statrtup.cs file. In the ConfigureServices method, add CORS policy and add the services as below.
public void ConfigureServices(IServiceCollection services) {
    services.AddCors();
    services.AddControllers();
    // configure to get Appsetting section from appsetting.json
    services.Configure < AppSettings > (Configuration.GetSection("AppSettings"));
    services.AddScoped < IUserService, UserService > ();
    services.AddScoped < IAuthenticationService, AuthenticationService > ();
}

Step 10
In the Configure method, set CORS policy and register the JWT middleware as below.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env) {
    app.UseRouting();
    // set global cors policy
    app.UseCors(x => x.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader());
    // Custom jwt auth middleware to authenticate the token
    app.UseMiddleware < JwtMiddleware > ();
    app.UseEndpoints(endpoints => {
        endpoints.MapControllers();
    });
}

Step 11
Now build and run the application.

Step 12
Open Postman tool and generate the JWT token as below:

    Click on the New icon as shown in the below image and create a New Http Request. I have given Http Request name as “AuthToken”.
    Change the http request method to "GET" with the dropdown selector on the left of the URL input field.
    In the URL field enter the address to the route of your local API http://localhost:60119/Authenticate/authenticate.
    Select the "Body" tab below the URL field, change the body type radio button to "raw", and change the format dropdown selector to "JSON (application/json)".
    Enter a JSON object containing the test username and password in the "Body" text
    {
        "username": "mytestuser",
        "password": "test123"
    }

Click the "Send" button, you should receive a "200 OK" response with the user details including a JWT token in the response body, make a copy of the token value because we'll be using it in the next step to make an authenticated request.

Middleware is a newly introduced concept in asp.net core. I have split this topic into two parts. In the first part we will cover,

    HTTP Request Pipeline
    What is Middleware?
    How to configure Middleware
    Run() Method
    Use() Method
    Next() Method
    Map() Method

This article can be used by beginners, intermediates, and professionals.

Before we start with Middleware, we should have a good understanding of the HTTP Pipeline hence we will discuss the HTTP pipeline first and then move to Middleware.
HTTP Request Pipeline

Let’s say, we have an MVC application, and we got a request from the browser.

Please see the below diagram for the HTTP request pipeline of the above scenario.

As per the above diagram, the flow of the execution would be,

    The browser sent a request to the HTTP request pipeline.
    HTTP pipeline will execute.
    Once HTTP pipeline execution will be completed, the request goes to the MVC application.
    MVC Application executes the request and sends the response back to the HTTP Request pipeline -> Browser.

Now we will discuss Middleware.
What is Middleware?

Middleware is a core functionality of Asp.net Core. It is nothing but a class or component that will execute on each request.

If you worked on Asp.net before, you might be aware of HTTPhandler and HTTPModular which were part of the HTTP Request Pipeline. Middleware is like that only in the Asp.net Core HTTP request pipeline.

Let’s see the below image to get a better understanding of Middleware.

As we can see in the above diagram, There will be multiple middlewares in the asp.net core application and each middleware will be called one after the others in the pre-defined sequence. Please note that the order of the middleware matters a lot in the HTTP pipeline execution.

Each middleware will complete the task before and after the next middleware in the pipeline. It will also decide whether to pass the request to the next middleware or not.

We can have multiple middlewares in Asp.net Core Applications and it can be added through
    NuGet packages
    Custom Middleware – Project/Application specific.

How to configure Middleware
Middleware can be configured using Run(),Use() and Map() extension Methods.
Let's discuss the below code before we start a discussion on middleware,
public void Configure(IApplicationBuilder app, IWebHostEnvironment env) {
    if (env.IsDevelopment()) {
        app.UseDeveloperExceptionPage();
    } else {
        app.UseExceptionHandler("/Home/Error");
        // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
        app.UseHsts();
    }
    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseRouting();
    app.UseAuthorization();
    app.UseEndpoints(endpoints => {
        endpoints.MapControllerRoute(name: "default", pattern: "{controller=Home}/{action=Index}/{id?}");
    });
}

We have created the Asp.net core MVC application. Open StartUp.cs file -> Configure method.
Now we will add new middleware in the above code,
In Asp.Net core 5.0, we can configure middleware in the configure method of the startup class using IApplicationBuilder and Run/Use/Map extension methods.
In Asp.Net core 6.0, We don’t have to configure the method hence we can add the same middleware code after the builder.build() method.

We have used Asp.net core 5.0 in the below example,
public void Configure(IApplicationBuilder app, IWebHostEnvironment env) {
    app.Run(async (context) => {
        await context.Response.WriteAsync("Hello world!");
    });
    if (env.IsDevelopment()) {
        app.UseDeveloperExceptionPage();
    } else {
        app.UseExceptionHandler("/Home/Error");
        // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
        app.UseHsts();
    }
    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseRouting();
    app.UseAuthorization();
    app.UseEndpoints(endpoints => {
        endpoints.MapControllerRoute(name: "default", pattern: "{controller=Home}/{action=Index}/{id?}");
    });
}

In the above code, we have created simple Middleware using the Run() method. We will execute the code and see the output,

Output

You must notice that only the first middleware executes, and is then completed, other middlewares are not executed after the first middleware. This happened because we have used the Run () extension method to add middleware in the pipeline.

Let's discuss extension methods to configure middleware in the Request Pipelines.

Run() Method
Run() method is used to complete the middleware execution.

Syntax
using Microsoft.AspNetCore.Http;
namespace Microsoft.AspNetCore.Builder {
    //
    // Summary:
    //     Extension methods for adding terminal middleware.
    public static class RunExtensions {
        //
        // Summary:
        //     Adds a terminal middleware delegate to the application's request pipeline.
        //
        // Parameters:
        //   app:
        //     The Microsoft.AspNetCore.Builder.IApplicationBuilder instance.
        //
        //   handler:
        //     A delegate that handles the request.
        public static void Run(this IApplicationBuilder app, RequestDelegate handler);
    }
}

We have used the same method to create middleware in the last example.

Use() Method
Use() method is used to insert a new middleware in the pipeline.

Syntax
using Microsoft.AspNetCore.Http;
using System;
using System.Threading.Tasks;
namespace Microsoft.AspNetCore.Builder {
    //
    // Summary:
    //     Extension methods for adding middleware.
    public static class UseExtensions {
        //
        // Summary:
        //     Adds a middleware delegate defined in-line to the application's request pipeline.
        //
        // Parameters:
        //   app:
        //     The Microsoft.AspNetCore.Builder.IApplicationBuilder instance.
        //
        //   middleware:
        //     A function that handles the request or calls the given next function.
        //
        // Returns:
        //     The Microsoft.AspNetCore.Builder.IApplicationBuilder instance.
        public static IApplicationBuilder Use(this IApplicationBuilder app, Func < HttpContext, Func < Task > , Task > middleware);
    }
}

Let's see the below code to get a better understanding,
public void Configure(IApplicationBuilder app, IWebHostEnvironment env) {
    app.Use(async (context, next) => {
        await context.Response.WriteAsync("Hello World From 1st Middleware!");
    });
    if (env.IsDevelopment()) {
        app.UseDeveloperExceptionPage();
    } else {
        app.UseExceptionHandler("/Home/Error");
        // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
        app.UseHsts();
    }
    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseRouting();
    app.UseAuthorization();
    app.UseEndpoints(endpoints => {
        endpoints.MapControllerRoute(name: "default", pattern: "{controller=Home}/{action=Index}/{id?}");
    });
}

Output

Next Method
The next () method is used to pass the execution to the next middleware.

We will use the next method to call the next middleware. We will add one more middleware in the previous example and call the next method.

Let’s see the below code of the same,
public void Configure(IApplicationBuilder app, IWebHostEnvironment env) {
    app.Use(async (context, next) => {
        await context.Response.WriteAsync("Hello World From 1st Middleware!");
        await next();
    });
    app.Run(async (context) => {
        await context.Response.WriteAsync("Hello World From 2st Middleware!");
    });
    if (env.IsDevelopment()) {
        app.UseDeveloperExceptionPage();
    } else {
        app.UseExceptionHandler("/Home/Error");
        // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
        app.UseHsts();
    }
    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseRouting();
    app.UseAuthorization();
    app.UseEndpoints(endpoints => {
        endpoints.MapControllerRoute(name: "default", pattern: "{controller=Home}/{action=Index}/{id?}");
    });
}

You might notice the Next() method in the middleware. This method is responsible to invoke the next middleware component from the current Middleware.

public void Configure(IApplicationBuilder app, IWebHostEnvironment env) {
    app.Use(async (context, next) => {
        await context.Response.WriteAsync("Hello World From 1st Middleware!");
        await next();
    });
    app.Run(async (context) => {
        await context.Response.WriteAsync("Hello World From 2st Middleware!");
    });
    if (env.IsDevelopment()) {
        app.UseDeveloperExceptionPage();
    } else {
        app.UseExceptionHandler("/Home/Error");
        // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
        app.UseHsts();
    }
    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseRouting();
    app.UseAuthorization();
    app.UseEndpoints(endpoints => {
        endpoints.MapControllerRoute(name: "default", pattern: "{controller=Home}/{action=Index}/{id?}");
    });
}

Output

As we have used the next method hence both middlewares is called.
Map()

Map() method is used to map the middleware to a specific URL

Syntex
using Microsoft.AspNetCore.Http;
using System;
namespace Microsoft.AspNetCore.Builder {
    //
    // Summary:
    //     Extension methods for the Microsoft.AspNetCore.Builder.Extensions.MapMiddleware.
    public static class MapExtensions {
        //
        // Summary:
        //     Branches the request pipeline based on matches of the given request path. If
        //     the request path starts with the given path, the branch is executed.
        //
        // Parameters:
        //   app:
        //     The Microsoft.AspNetCore.Builder.IApplicationBuilder instance.
        //
        //   pathMatch:
        //     The request path to match.
        //
        //   configuration:
        //     The branch to take for positive path matches.
        //
        // Returns:
        //     The Microsoft.AspNetCore.Builder.IApplicationBuilder instance.
        public static IApplicationBuilder Map(this IApplicationBuilder app, PathString pathMatch, Action < IApplicationBuilder > configuration);
        //
        // Summary:
        //     Branches the request pipeline based on matches of the given request path. If
        //     the request path starts with the given path, the branch is executed.
        //
        // Parameters:
        //   app:
        //     The Microsoft.AspNetCore.Builder.IApplicationBuilder instance.
        //
        //   pathMatch:
        //     The request path to match.
        //
        //   preserveMatchedPathSegment:
        //     if false, matched path would be removed from Request.Path and added to Request.PathBase.
        //
        //   configuration:
        //     The branch to take for positive path matches.
        //
        // Returns:
        //     The Microsoft.AspNetCore.Builder.IApplicationBuilder instance.
        public static IApplicationBuilder Map(this IApplicationBuilder app, PathString pathMatch, bool preserveMatchedPathSegment, Action < IApplicationBuilder > configuration);
    }
}

Let's discuss the below example for more understanding of the Map extension method.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env) {
    app.Map("/testMap", testExample);
    if (env.IsDevelopment()) {
        app.UseDeveloperExceptionPage();
    } else {
        app.UseExceptionHandler("/Home/Error");
        // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
        app.UseHsts();
    }
    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseRouting();
    app.UseAuthorization();
    app.UseEndpoints(endpoints => {
        endpoints.MapControllerRoute(name: "default", pattern: "{controller=Home}/{action=Index}/{id?}");
    });
}
private void testExample(IApplicationBuilder app) {
    app.Run(async (context) => {
        await context.Response.WriteAsync("\n" + "Hello World From TestExample!");
    });
}

In the above example,
    app.map method, “/testMap” is a path and the second parameter (“testExample”) is a function name.
    Once you will pass “testMap in the requested path, it will try to match and call the testExample function in case of matching.

Output

That’s all for this article. We will discuss this more in the next article.

Key Takeaways
    NCache is an open-source distributed in-memory cache developed natively in .NET and .NET Core that helps such applications to process fast and scale out with ease.
    Caching is a proven technique used to hold and readily use frequently accessed data.
    This article presents a discussion and implementation of how we can work with NCache IDistributedCache provider using .NET 6.

Introduction
In this post, we'll look at how to implement distributed caching in ASP.NET Core using NCache as the cache provider. A cache is a type of high-speed memory that applications use to store frequently accessed data. It reduces the unnecessary database hits since the data being requested is readily available in the cache. Caching is a well-known approach for boosting application performance.

What is distributed caching
A distributed cache is a cache that is shared by several app servers and is frequently managed as a separate service from the app servers that use it.

A distributed cache can go beyond the memory restrictions of a single computer by connecting multiple computers, which is known as a distributed architecture or a distributed cluster, for increased capacity and processing power.

An ASP.NET Core project's efficiency and scalability can be improved by using a distributed cache, especially if the application is hosted by a cloud service or a server farm. In high-data-volume and high-load applications, distributed caches are extremely useful. The distributed design allows for gradual expansion and scalability by adding more computers to the cluster, allowing the cache to expand in sync with the data growth.

The advantages of distributed cache are:
    Cached data is consistent across all web servers. The user gets the same results regardless of which web server serves their request.
    Web server restarts and deployments do not affect cached data. Individual web servers can be added or removed with no effect on the cache.
    Doesn't use local memory.

What is NCache?
NCache is a free, open-source distributed in-memory cache written in.NET and.NET Core. NCache is a distributed cache that saves application data while avoiding costly database trips. It's lightning-fast and linearly scalable. NCache can be utilized to reduce performance constraints caused by data storage and databases, as well as to enable your.NET Core applications to manage high-volume transaction processing (XTP). It can be used both locally and as a distributed cache cluster for ASP.NET Core apps hosted on Azure or other platforms.

Distributed Caching in ASP.NET Core
Using the IDistributedCache interface provided by dotnetcore, we can connect our ASP.NET Core apps to any distributed cache cluster and utilize it for caching as needed. Almost all major cache providers provide implementations for IDistributedCache, which we can register in the IoC container using IServiceCollection.

IDistributedCache Interface
This is the interface required to access the distributed cache objects, which includes synchronous and asynchronous methods. Items can be added, retrieved, and removed from the distributed cache implementation using this interface.

To perform actions on the actual cache, the IDistributedCache Interface provides the following methods.
    Get, GetAsync: Takes a string key and retrieves the cached item from the cache server if found.
    Set, SetAsync: Add items to the cache using a string key.
    Refresh, RefreshAsync: Resets the sliding expiry timeout of an item in the cache based on its key (if any).
    Remove, RemoveAsync: Deletes the cache data based on the key.

Connecting to an NCache cache
First, we need to install NCache on our machine. You can find a step-by-step tutorial on how to set up NCache on your windows machine here.

Once, the setup is complete, we are ready to use the NCache server in our .NET 6 app.  Let's create a .NET 6 project to learn the caching operations with NCache.

First, let's install the following NuGet package:

Install-Package NCache.Microsoft.Extensions.Caching.

This package uses NCache to implement the IDistributedCache interface.

We need to add the cache to the ASP.NET dependencies container in the Program.cs file after installing the NuGet package.
// Program.cs
using Alachisoft.NCache.Caching.Distributed;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
// Add NCache implementation here...
builder.Services.AddNCacheDistributedCache(configuration => {
    configuration.CacheName = "myClusteredCache";
    configuration.EnableLogs = true;
    configuration.ExceptionsEnabled = true;
});
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
var app = builder.Build();
if (app.Environment.IsDevelopment()) {
    app.UseSwagger();
    app.UseSwaggerUI();
}
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.Run();

We can also configure the cache settings in the appsettings.json file. To achieve this, we can use another overload of the same method.
builder.Services.AddNCacheDistributedCache(Configuration.GetSection("NCacheSettings"));

// appsettings.josn
{
    "NCacheSettings": {
        "CacheName": "myClusteredCache",
        "EnableLogs": true,
        "EnableDetailLogs": false,
        "ExceptionsEnabled": true,
        "OperationRetry": 0,
        "operationRetryInterval": 0
    }
}

So far, we've finished the connectivity part. We have our NCache server running on our machine with a cluster cache named myClusterCache. A cluster cache with the name demoCache is created automatically when you install NCache on your machine. Learn about how to create a cluster cache manually here.

Let's create a new extension generic method that will make our life a bit easier to get or set records from the cache server. It contains two methods: SetRecordAsync, which stores the data in the cache, and GetRecordAsync, which retrieves the data. In the DistributedCacheEntryOptions, we can pass configuration values. This determines how long the items will be stored in the cache.

public static class DistributedCacheExtensions {
    public static async Task SetRecordAsync < T > (this IDistributedCache cache, string recordId, T data, TimeSpan ? absoluteExpireTime = null, TimeSpan ? unusedExpireTime = null) {
        var options = new DistributedCacheEntryOptions {
            AbsoluteExpirationRelativeToNow = absoluteExpireTime ?? TimeSpan.FromSeconds(60),
                SlidingExpiration = unusedExpireTime
        };
        var jsonData = JsonSerializer.Serialize(data);
        await cache.SetStringAsync(recordId, jsonData, options);
    }
    public static async Task < T > GetRecordAsync < T > (this IDistributedCache cache, string recordId) {
        var jsonData = await cache.GetStringAsync(recordId);
        if (jsonData is null) {
            return default (T);
        }
        return JsonSerializer.Deserialize < T > (jsonData);
    }
}

AbsoluteExpirationRelativeToNow
This method gets or sets an absolute expiry time relative to the current date and time.

SetSlidingExpiration

This works in the same way as Absolute Expiration. If it is not requested for a specified duration of time, the cache will expire. It is important to note that Sliding Expiration should always be set lower than absolute expiration.

Now, let's inject IDistributedCache into the StudentController to access the configured cache.
using DistributedCache_NCache.Extensions;
using DistributedCache_NCache.Models;
using DistributedCache_NCache.Services;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Caching.Distributed;
namespace DistributedCache_NCache.Controllers {
    [Route("api/[controller]")]
    [ApiController]
    public class StudentController: ControllerBase {
        private readonly IStudent < Student > _studentService;
        private readonly IDistributedCache _cache;
        public StudentController(IStudent < Student > studentService, IDistributedCache cache) {
                _studentService = studentService;
                _cache = cache;
            }
            [HttpGet]
        public async Task < IActionResult > Get() {
            string cacheKey = "StudentList_" + DateTime.Now.ToString("yyyyMMdd_hhmm");
            var student = await _cache.GetRecordAsync < List < Student >> (cacheKey);
            if (student is null) {
                student = (List < Student > ) await _studentService.ListAllAsync();
                await _cache.SetRecordAsync(cacheKey, student);
            }
            return Ok(student);
        }
    }
}

In the above snippet, we set the cache key first, so that when we call the method, it checks if the data is present with that cache key in the cache server. If the data is present, then it returns the data from the cache otherwise, it fetches the data from the database, set the data to the cache, and then returns the data.

The second time when we call this method again, the data will be returned from the cache without hitting the database and the response will be much faster.

Let's test our implementation via postman now. Run the application and hit the endpoint "/api/student".

The below screenshot shows that the request took 2.78 seconds for the response.

When I hit the endpoint for the second time, the data is returned from the cache, as it was added to the cache server on the first call. This is a cache hit and the response time is much faster compared to the first call.

The cache hit can also be seen on the NCache Web Manager portal, which allows us to keep track of the cache cluster's health and traffic in real-time.

Caching is a proven technique used to hold and readily use frequently accessed data. This has excellent benefits, as we can save the expensive database trips and increase the response time significantly and save a lot of resources and money.

While in-memory caching provides a decent start, distributed caching takes things a step further and is best suited to distributed systems and cloud-native solutions.

Along with Redis, Memcached, and other popular caching solutions, NCache is one of the most popular. It includes features like real-time cluster management, Pub/Sub design pattern, and a large library for ASP.NET Core integration.

.NET MAUI is one of the latest additions to Microsoft's .NET ecosystem. If you are new to .NET MAUI, this artilce is for you. Here you will learn what .NET MAUI is and why Microsoft actually developed .NET MAUI. MAUI stands for Multi-platform App UI that is a UI framework to build UI applications using C#, .NET, and XAML. .NET MAUI can be used to build apps for Windows, MacOS, Web, and Mobile (iOS, Android). That means, you can develop one project and deploy that on multiple platfforms that will work on various devices including Desktops, Mac, laptops, tablets, and smartphones.

When I think of the .NET ecosystem, one phrase comes to mind: Code Re-use. It's amazing how much we can do within one .NET codebase, and this is especially true with the introduction of .NET Core, and technologies like Xamarin (and subsequently Xamarin.Forms).

These days, people switch between many devices throughout the day in order to stay maximally productive. It's becoming increasingly important that the applications we write are accessible, regardless of the devices our users are in front of. This point makes the web very powerful, and there are many pros to writing your application for the web browser. But, when we do this, we lose out on the native platform controls and performance offered to us by the OS vendors, making the application relatively unnatural to use, and to look at.

Xamarin.Forms to the rescue!
Xamarin Native (e.g. Xamarin.Android) abstracts away the underlying platform API, allowing us to use the fantastic .NET platform to write native applications on different devices. Xamarin.Forms takes this a step further, allowing us to write one UI for multiple platforms. We write the UI once, and this UI will then be translated to the appropriate native controls for each device.
.NET 5 and 6

Microsoft's goal with .NET 5 is to begin to unify all the various scattered technologies we know and love within .NET. The goal is to bring together technologies such as .NET Core, Mono, and Xamarin into one unified ecosystem. With .NET 6, this unifying will only continue further, with the introduction of .NET MAUI.

What is MAUI?
MAUI stands for Multi-platform App UI, which is a UI framework in .NET 6 for making Windows, iOS, Android, and macOS applications with one project, one codebase. It is an evolution over Xamarin.Forms and takes code reusability to the next level. Instead of having separate projects to target indiviual platforms, we will only need a single project, and we can just choose which platform we want to deploy on (whether it be emulators or physical devices.)

This is even more powerful than it might seem at first. Resources and assets such as fonts, images, etc will only need to be included once within the one project, and .NET MAUI will take care binding these assets to each platform.

Of course, just like in Xamarin, we will have access to the underlying native platform APIs if we need to open the hood and do some platform-specfic work. In fact, in .NET MAUI, this process will be even easier and more streamlined.

.NET 6 is all about developer productivity. Part of this productivity means not being locked-in to any individual architectural patterns you might not be comfortable with. Developers in .NET MAUI can choose to use the traditionally-accepted MVVM architectural pattern for writing multi-platform UIs, or the MVU (Model-View-Update) pattern which is a code-first UI experience.

The key benefits of .NET MAUI include:

• C# and .NET developers can build all kinds of apps using a single programming language and framework. No need to learn different programming languages, frameworks, and libraries. Same code is compiled into libraries to target Windows, macOS, iOS, and Android. This is big for tech teams. They don't need to learn different programming languages and frameworks.
• Businesses don’t need to hire multiple teams for different platforms. Also, no need to maintain multiple technologies and teams. The cost of hiring and maintain different tech stack teams are often costly. Imagine a startup launching a website and mobile apps for iOS and Android. The startup needs to maintain three different teams with different tech stacks.

What about my Xamarin projects?
In .NET MAUI, we will be using the same XAML controls we know and love from Xamarin.Forms, and Microsoft intends to make the migration process from Xamarin.Forms to MAUI as easy as possible. They will provide migration guides as well as tooling to convert your existing projects.
Sounds great, but what will happen to Xamarin?

Xamarin Native technologies (Xamarin.iOS, Xamarin.Android) are bindings to the native platform technologies offered by the OS vendors. This concept is fundamental to Xamarin.Forms, and .NET MAUI. These technologies will continue to exist, but will be merged into .NET 6 as first-class citizens. (".NET for Android" and ".NET for iOS")

After the release of .NET 6, the Xamarin team will release final versions of the Xamarin SDKs as they exist today, and continue servicing these SDKs and Xamarin.Forms for a year. After that, support will be shifted entirely to .NET MAUI, .NET for Android, and .NET for iOS.
Conclusion

I am very excited about .NET MAUI and all the productivity it will bring. The Idea of integrating Xamarin.Forms as a first-class technology in .NET makes sense, and I look forward to watching this technology come to life.

Thanks for reading! Feedback is always welcome.

What is Unit Testing?
Unit testing is a type of Software Testing in which the smallest isolated individual piece of code is tested. This testing aims to validate each unit so that the software works as expected. Unit testing is done during the development phase of the software by the software developers. Tests that rely on external systems are not unit tests. Unit tests help to identify and fix the bugs in the development phase.

There are several Unit Testing frameworks available that can be used for Unit testing like MSTest, NUnit, xUnit, etc. A test suite is the collection of tests and a unit test runner is a program that verifies tests and reports the test results.

What is Test-Driven Development (TDD)?
Test-Driven Development is a development methodology in which a Test case is written before writing the actual piece of code. This methodology is also known as the “Red-Green-Refactor” approach. In this approach, First, the test case fails (red), then get the test case to Pass (Green) and then optimize the code (Refactor).
How to set up a unit test project with NUnit?

For demonstration, I am using Visual Studio 2019 and already have a class library project using .Net Core. Below is the structure of the Project.
And the code which is written in Calculate.cs is shown in the below image.

And the code which is written in Calculate.cs is shown in the below image.

In the above code, we have a method named as addTwoNumber which will add and return the result as the response. Now let’s add a Class Library project for writing the NUnit Test cases.

Install NUnit, NUnit3TestAdapter, and Microsoft.NET.Test.Sdk in Calculator.Test project from the Nuget Package Manager.

Now add the Calculator Class Library’s project reference in the Unit Test Project.

In the Unit Test project, add a class CalculateTest. Use the [TestFixture] attribute on CalculateTest class which denotes that the class contains the unit tests. [Test] attribute indicates that method is a test method. In the checkAddTwoNumber() method, I created an object of Calculate class and Assert the expected and actual value using the AreEqual() method.

Open Test Explorer through the Test menu as shown in the below image.

In case the expected and actual values matched then the test case is passed and shown with a green tick symbol.

In case the test case is failed then the message and the stack trace details will help to find the issue.

I was working on ASP.NET Core SignalR client application to receive the message from the SignalR hub. This is the scenario where my SignalR server and client were two separate .NET Core applications. In the client application, I got the below error message while trying to receive the message from SignalR Hub(server). This error may arise and the solution is almost similar for both cases using SignalR Javascript client and .NET Client.

Exact Error Message: “Error: Failed to complete negotiation with the server: Error: Not Found: Status code ‘404’ Either this is not a SignalR endpoint or there is a proxy blocking the connection.”

Below is my earlier code:
var connection = new signalR.HubConnectionBuilder().withUrl("http://localhost:39823/event-hub)

Then to resolve the above error I found that we need to add the below code in HubConnectionBuilder.

skipNegotiation: true,
transport: signalR.HttpTransportType.WebSockets

Note that: The negotiation should be skipped only when the transport property is set to ‘signalR.HttpTransportType.WebSockets‘.

Solution
Below is the previous code with which I got an error.
var connection = new signalR.HubConnectionBuilder().withUrl("http://localhost:4023/yourevent)

Complete code to resolve the issue.

var connection = new signalR.HubConnectionBuilder().withUrl("http://localhost:4023/yourevent", {
    skipNegotiation: true,
    transport: signalR.HttpTransportType.WebSockets
})

Note: This solution is applicable for both cases either using the SignalR .NET client or SignalR JavaScript client.

I hope you have got an idea of how to resolve this error.

In this tutorial, we will learn how to call a Power Automate flow from .NET, using an HTTP post. For this purpose, we will use an example to send an email.

This is the flow created in Power Automate:

Power Automate Flow

1. .NET Development
In the first instance, we must refer to the endpoint of our Power Automate flow:

private string uri = "HTTP POST URL";

Then we can define a method in a service for example to be able to call it from somewhere in our application, and this will receive as parameters the username, toAddress, and the emailSubject. The idea with this method is to be able to prepare the request for the HTTP post, and that the Power Automate flow can be triggered:

public async Task SendEmailAsync(string username, string toAddress, string emailSubject)
{
    try
    {
        HttpClient client = new HttpClient();
        client.BaseAddress = new Uri(uri);
        client.DefaultRequestHeaders.Accept.Clear();
        client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

        HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, client.BaseAddress);
        var body = $"{{\"emailAddress\": \"{toAddress}\",\"emailSubject\":\"{emailSubject}\",\"userName\":\"{username}\"}}";
        var content = new StringContent(body, Encoding.UTF8, "application/json");
        request.Content = content;
        var response = await MakeRequestAsync(request, client);
        Console.WriteLine(response);

    }
    catch (Exception e)
    {
        Console.WriteLine(e.Message);
        throw new Exception();
    }
}

Finally, we can count on an additional method to be able to perform the HTTP post request, according to the previously established request:

public async Task<string> MakeRequestAsync(HttpRequestMessage getRequest, HttpClient client)
{
    var response = await client.SendAsync(getRequest).ConfigureAwait(false);
    var responseString = string.Empty;
    try
    {
        response.EnsureSuccessStatusCode();
        responseString = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
    }
    catch (HttpRequestException)
    {
        // empty responseString
    }

    return responseString;
}

2. Test the code in a web app with ASP.NET
To perform the tests, let's see an example in a web application from ASP.NET that calls this deployed Power Automate service, when a user is added from a form, and notified by email with this flow:

await new PowerAutomateService().SendEmailAsync(student.FirstName, student.Email, "Greetings from ASP.NET / DotVVM web application.");

Thanks for reading.
I hope you liked the article. If you have any questions or ideas in mind, it'll be a pleasure to be able to communicate with you and together exchange knowledge with each other.

What is Blazor?
Blazor is a UI framework, it allows developers to design and develop interactive rich UI components with C#, HTML, CSS, plus it is open sourced and free. So technically now you can create web pages directly in C# instead of JavaScript.

Blazor web application is nothing but a collection of web pages or to be precise razor pages, then each razor page will host bunch of blazor components and get this, this blazor web application could run on both server or on client. Isn't that cool?

In traditional architecture, server is designed with high level languages such as Java, C# and client is dominated by dynamic programming language such as javascript, now with blazor you can design both your server and client application in C#.
What is Blazor Server?

Have a look at the image below, you'd notice there is a server present somewhere on cloud or in office premises and it is communicating with a browser with something called SignalR. You can learn more about signalR here, but let me explain with a simple example.

    You might have played online games, those games run on a client machine or on a client browser but the data is coming from the server. So if you kill 3 enemies the counter is stored on the server, the moment you kill the 4th enemy counter increases to 4, that communication between server and client is so fast the user can hardly notice any lag. And this is enabled by SignalR in the blazor server app. So for every user interaction on browser signalR sends UI components and data from server to browser and then browser simply renders those changes.

In Blazor server app, UI components (razor components) are stored on the server. Every UI updates, event calls are handled by SignalR which sends the updated data/component to the browser on demand. In order to run app smoothly browser need to have consistent connection with server. The browser has script, blazor.server.js which establishes the SignalR connection with the server.

Perks of using Blazor server app:

    Size: Application that runs on the browser is smaller in size as it is requested from the server and since the browser doesn't have to deal with the entire application at once it is faster.
    loosely coupled architecture: With the support of server, you can now create a thin client app. Here the server communicates with the browser for all of the client's needs. This loosely coupled architecture is easy to scale the application. But it has its disadvantages as well.

Disadvantages:

    Latency: Every time a user interacts with the browser, the browser sends a request to the server and the UI component reacts based on the server's response. Human eye wouldn't catch the latency as SignalR performs high-frequency updates at a faster pace but you'll observe the delay when you'd have to bind 1 million rows fetched from the server to bind to the data grid.
    Active connection to server: If connection is lost then the communication to the server is lost. now you're no longer able to run the application.

What is Blazor Assembly A.K.A. Blazor WASM?

WebAssembly is nothing but compact bytecode feeded to the browser.

Blazor webAssembly executes UI components directly from the client side with the help of .Net runtime. Blazor-WASM works same way as any other UI frameworks Angular or React but instead of JavaScript it uses C#. Blazor-WASM allows browsers to download the application so you run it directly from the browser. Meaning DLLs are loaded into the browser.

In 3 simple steps let's understand what is happening in the image below.
    You can develop code in C#, HTML, CSS which is encapsulated in razor files which get compiled by .NET assemblies.
     When you run the Blazor-WASM, .NET runtime and these compiled assemblies are downloaded into the browser.
    Now .NET runtime uses JavaScript interop to handle DOM manipulation to render the logical structure of razor components.
     

Advantages

• Can work offline: As there is no server dependency, the client can work without being dependent on the server. so it doesn't matter if you lose the connection with the server.

Disadvantages

• Size of app: The more complex your application gets, the bigger the size of application will be, it's gonna take a toll on performance of the app. However there is a solution to this disadvantage. You don't need to load entire app's dll's to the browser at once you can load as they requested. This is where component based architecture helps.

I hope this clears the confusion once and for all.

Before starting the article, I would like to share with you all that after a small break I have come back to write articles and I hope all my upcoming articles will be interesting and useful for all my readers. After this .NET 6.0 intro article, I plan to publish a series of .NET 6.0 and Angular articles.

 In this article, we will see why we need to move our existing projects from .NET 5.0 to .NET 6.0 also for all our new projects why we need to start with .NET 6.0 instead of .NET 5.0.

In March 2022 Microsoft announced as from May 10 2022 Microsoft will stop all the support which also includes security support and technical support. Check this article for more details from the official Microsoft announcement https://devblogs.microsoft.com/dotnet/dotnet-5-end-of-support-update/.

Microsoft also stated in the above blog that the existing users can still run the .NET 5.0 for their current project but at the same time if the users need any security support or technical support then it's not possible after May 10, 2022.

Do we need to move or start with .NET 6.0?
Yes, we need to migrate from .NET 5.0 to .NET 6.0.

The main reason why I recommend this is that, more than technical support, Microsoft is also stopping the security support of .NET 5.0. Security support is more important than technical support as in the future if we found any vulnerability in .NET 5.0 then Microsoft can not support on any security issues. Considering the security and technical support it is good and advisable to migrate or create all our future projects from .NET 5.0 projects to .NET 6.0

In this article, we will see in detail about getting start with .NET 6.0 by installing the Visual Studio 2022.

Visual Studio 2022
If you have not yet installed Visual Studio 2022 then you can download the Visual studio 2022 from this link  and install it on your computer.

Download and install the Visual Studio 2022.

Note: The Community version is free for all and you can download the community version if you don’t have the Installation Key. If you have the Installation key or have the MSDN subscription then you can download the Professional or Enterprise version. As a Microsoft MVP, I have the MSDN subscription and I have installed the Professional version.

Getting started with .NET 6.0
.NET 6.0 has more advantages than working with the .NET 5.0 as .NET 6.0 has more improvement on the performance which also includes some major advantage as it has intelligent code editing and also it is called the fastest full-stack web framework. The .NET 6.0 also provides better performance in the File Stream.

We will see a demo on creating console application in .NET 6.0 and also, we will see what advantage the Console application has in .NET 6.0 with an example of intelligent code editing.

Create .NET 6.0 Console Application
After installing all the prerequisites listed above and clicking Start >> Programs >> Visual Studio 2022 >> Visual Studio 2022 on your desktop. Click New >> Project.

Click on Console App and Click Next

Enter your project name and click Next.

Now we can see the Framework is .NET 6.0(Long term support). Click on the Create button to create our first .NET 6.0 Console application.

When we create the new console application, we can see very simple code in our program.cs file.

.NET 5.0 and previous versions of .NET
In the .NET 5.0 and previous versions for any console application, we can see the main method, class, namespace, and the using header files. Without any of the below code the program cannot be executed.

.NET 6.0 Console Application
We can see that there is no main method, class, and using headers in the program.cs file. But don’t panic, yes now in the .NET 6.0 the codes are made simpler and the intelligent code supports seem to be more advanced and now it’s easier and reduces the time on working our codes and projects.
Top-Level statements

This is called the Top-Level statements as the main method is not needed from the C# 9. The main aim of the Top-Level statement is to reduce the code and improve the performance. The main method and the class will be created by the compiler as we don't need to write separate code for it.

After the Top-Level statements introduced from C# 9.0 now, it seems easier for programming and easy to learn C#. Yes, now it seems like Small Basic programming and it makes it easier for the programmers to get started and work on codes.

When we run the program or press the F5 button from the application, we can see the .NET 6.0 can run without any errors even though the main method is missing

.NET 6.0 Intelligent Code Editing
In the same application, I will add the code to get the name and display the name in command prompt. For this, I have declared the string as myname and using the Console.ReadLine() method the input from the user and display the results.

You can see when I enter the Console and press the Tab the code is automatically generated and also the intelligent code has automatically added the string as myname to be displayed. This reduces the coders workload 😊, also I'm happy to work with Intelligent Code editing as it's also fun to work with the codes.

When we run the program and enter the name in command prompt and press enter.

Working with Simple Methods in .NET 6.0
Here we will see two ways of creating the functions in .NET 6.0 as in the first method for all the single like statements its more easy to follow the method format with the  => codes and for all the multiple statements we can use the {} brackets as we do earlier.

I hope this article helps you to understand why we need to migrate or started working with .NET 6.0. Also explained a few basic advantages of .NET 6.0. As I mentioned in this article mainly for the security updates and concerns we need to move from .NET 5.0 to .NET 6.0.