When developing applications using .NET Core, developers have two main interfaces to work with: the .NET Core CLI (Command-Line Interface) and .NET Core GUI (Graphical User Interface) provided by tools like Visual Studio. Each offers distinct ways of interacting with the .NET Core development environment, and understanding the differences will help you choose the right tool for the job.

In this blog, we’ll dive into what the .NET Core CLI and GUI are, demonstrate how they work, and compare them side by side with examples.

What is CLI (Command-Line Interface)?

The Command-Line Interface (CLI) is a text-based way of interacting with your computer or development environment. You type commands into a terminal or command prompt, and the system responds by executing those commands.

What is .NET Core CLI (Command-Line Interface)?

The .NET Core CLI is a tool that allows you to interact with .NET Core from the command line. It's primarily used for creating, building, running, and publishing .NET Core applications without relying on an IDE like Visual Studio.

Think of it as a toolbox for working with your .NET Core projects, accessible directly from the command line or terminal.

Key Features of CLI:

• Text-based interaction: You input text commands, and the system responds with text output.
• Precision and control: You can run complex scripts, automate tasks, and manage systems with high precision.
• Resource efficiency: CLI requires fewer system resources (memory, CPU) compared to a GUI.
• Cross-platform: Available on Windows, macOS, and Linux.
• Command-driven: Use text commands to create and manage projects.
• Automation-friendly: Easily integrates into CI/CD pipelines for automated builds and deployments.
• Lightweight: Requires fewer resources compared to a GUI.
• Steep learning curve: Requires knowledge of specific commands and syntax.

Common Use Cases for CLI:

• Development: Managing projects, building, running, and publishing applications.
• Automation: Running batch scripts or automating tasks like backups or deployments.
• Remote management: Accessing remote servers via SSH (Secure Shell) for administrative tasks.

Here are some essential .NET Core CLI commands:

• dotnet new: Create a new project.
• dotnet run: Run a .NET Core application.
• dotnet build: Build the project.
• dotnet publish: Publish the application for deployment.
• dotnet test: Run tests for your project.
• dotnet add package: Add a NuGet package to your project.

Example: Using the .NET Core CLI

Here’s how you would create, build, run, publish a new .NET Core application(Console, Web, API etc.) using the CLI:

Command to Create a Console New Project

dotnet new console -n MyConsoleApp

• MyConsoleApp: specifies the name of your project.

Command to Create a New Web App:

dotnet new webapp -n MyWebApp

• webapp: is the template for a web application with Razor Pages.
• -n MyWebApp: specifies the name of your project.

This command generates the basic files and folders needed for a web application:

• Pages/: The Razor Pages for the app.
• wwwroot/: Static files (CSS, JavaScript, images).
• Program.cs and Startup.cs: The core configuration files.

Command to Create an Empty Web App:

dotnet new web -n MyEmptyWebApp

• This creates an empty project with minimal configuration. You can add controllers, views, and models as needed.

Command to Create a New Web API:

dotnet new webapi -n MyWebAPI

• webapi is the template for a REST API.
• -n MyWebAPI specifies the project name.

This command creates a project that follows RESTful conventions, with controller-based routing.

The Web API template generates files like:

• Controllers/WeatherForecastController.cs: A sample API controller.
• appsettings.json: Configuration settings.
• Program.cs and Startup.cs: Core configuration files.

Building the Application

Once your app project is created, you can build it using the CLI. Building compiles the code and prepares it for execution.

Command to Build the Project:

dotnet build

The dotnet build command compiles the project, checks for errors, and produces the output necessary to run the application. The dotnet build command is same for console, web app and API.

Running the Application

After building the project, you can run it directly using the CLI.

Command to Run the Project:

dotnet run

The dotnet run command is same for console, web app and API. 

For console application, you will see the output

Hello World!

For web application, the dotnet run command will start the built-in web server (Kestrel) and make your application available locally.

Once you run the command, you should see output similar to this:

Now listening on: https://localhost:5001
Now listening on: http://localhost:5000

This means the application is running, and you can access it by navigating to http://localhost:5000 or https://localhost:5001 in your browser.

For the Web API, Once the Web API is running, you'll be able to access it through routes defined in the controllers, like https://localhost:5001/weatherforecast.

Publishing the Application

Once you’ve developed and tested your web application or Web API, you can publish it for deployment. The dotnet publish command packages your application and its dependencies into a folder, ready to be deployed on a server.

Command to Publish the Application:

dotnet publish -c Release -o ./publish

• -c Release: Builds the project in Release mode, which optimizes the code for deployment.
• -o ./publish: Specifies the output directory for the published files.

The output folder will contain all the necessary files to deploy your application, including:

• Compiled DLLs
• Static assets (CSS, JavaScript)
• Configuration files

These can then be copied to a server (e.g., an IIS server, or deployed to Azure).

This is a simple, fast way to create, build, run  and publish a project without the need for an IDE.

The .NET Core CLI is a powerful tool for creating, building, running, and publishing web applications and Web APIs. By using the CLI, you can quickly set up a project, build it, and deploy it to different environments, all from the command line. This is especially useful for developers working on cross-platform systems or those looking to automate processes like continuous integration and deployment (CI/CD).

Issue-1

When you create a new project using the .NET Core CLI, it does not automatically generate a solution file (.sln) unless you explicitly ask for it. This behavior is intentional because the CLI allows you to create and manage individual projects without needing a solution file. In contrast, Visual Studio often creates a solution by default when setting up a project.

A solution file (.sln) is essentially a container that can hold multiple projects, making it easier to organize and manage related projects (like in large applications). However, for simpler, single-project scenarios, it’s not always necessary.

Why Does the CLI Not Create a Solution File?

Simplicity: The CLI assumes that you may be working on a single project, so creating a solution file may not be needed.

Project-centric: The .NET Core CLI is project-centric, meaning it focuses on the project itself (.csproj) rather than on solutions (.sln). It only creates the necessary files to run the project.

Modularity: You can choose to add a solution later if you need one, especially if you want to group multiple projects together.

How to Create a Solution File Using the CLI

If you want a solution file (.sln), you can explicitly create one and then add your project to it.

Step 1: Create a Solution File

You can create a solution using the following command:

dotnet new sln -n MySolution

• -n MySolution: This specifies the name of the solution file (you can name it whatever you want).

Step 2: Add Your Project to the Solution

After creating the solution, you can add the project to the solution:

dotnet sln add MyProject/MyProject.csproj

This command will add your project (.csproj file) to the solution. If your project is in a subfolder, make sure you provide the correct path to the .csproj file.

Benefits of Using a Solution File

·  Managing Multiple Projects: If you have a scenario with multiple projects (e.g., a Web API and a class library), using a solution file helps to organize them together.

·  Easier Build and Publish: You can build or publish all projects in the solution at once using the dotnet build or dotnet publish command on the solution.

·  IDE Integration: Visual Studio and other IDEs often rely on the solution file for features like build configurations, project management, and debugging.

Issue-2

When you run a .NET Core application using the dotnet run command, the process starts and will continue running, especially for web applications, which will keep the server active. The terminal remains "busy" because the application is still running.

To stop the application and return to the command prompt, you need to terminate the process.

Here are the steps to stop the running application:

1. Stop the Running Application (Terminate Process)

In most cases, you can stop the application by pressing Ctrl + C in the terminal. This will send a signal to the application to terminate, and you will regain control of the terminal.

• On Windows, Linux, and macOS, press Ctrl + C to stop the running .NET Core application.

Once the application is stopped, you'll see your command prompt (D:\Practice\cli\FirstWebApp>), and you can now run other commands.

2. Terminate Specific Processes (If Ctrl + C Doesn't Work)

If pressing Ctrl + C does not stop the process (which can happen occasionally), you can forcefully kill the process. Here’s how to do it:

On Windows:

1. Open the Task Manager (Ctrl + Shift + Esc).
2. Find the running process associated with your .NET application (usually listed as "dotnet").
3. Select it and click End Task.

On Linux/macOS:

1. Run the following command in the terminal to list the processes:

ps aux | grep dotnet

·  Find the process ID (PID) of the running dotnet process.

·  Kill the process by running:

kill -9 <PID>

Automate the Stop and Start Process

If you need to run multiple commands sequentially after running dotnet run (like in a script), consider using a tool like tmux or screen to run the application in the background.

For instance, on Windows using PowerShell, you can run the command in the background like this:

Start-Process -NoNewWindow -FilePath "dotnet" -ArgumentList "run"

This will run the application in the background and immediately return control to the terminal.

What is GUI (Graphical User Interface)?

The Graphical User Interface (GUI) is a visual-based method of interacting with software. It uses buttons, icons, and other visual elements that users can click or drag to perform tasks. GUIs are generally more user-friendly and accessible for non-technical users.

What is .NET Core GUI(Graphical User Interface)?

The .NET Core GUI typically refers to using Visual Studio or Visual Studio Code to manage your .NET Core applications. These integrated development environments (IDEs) provide a visual interface to manage projects, write code, debug, and run applications.

Key Features of GUI:

• Visual interaction: Uses icons, windows, and other graphical elements to simplify interactions.
• Ease of use: Intuitive and beginner-friendly, making it ideal for users who aren’t comfortable with text-based commands.
• More resource-intensive: GUIs typically require more system resources like memory and CPU.
• Less flexible for automation: Although GUIs can be scripted, it’s often more complex and less flexible than CLI automation.
• User-friendly: Intuitive and easy to use, especially for beginners.
• Graphical tools: Visual tools for managing projects, adding dependencies, and debugging.
• Integrated debugging: Set breakpoints, inspect variables, and step through code.
• Project templates: Easily create new projects with pre-configured settings.

Common Use Cases for GUI:

• Everyday use: Browsing the web, using office applications, or interacting with any software that has a graphical interface.
• Development environments: IDEs like Visual Studio or Visual Studio Code provide GUIs that simplify project management, code writing, debugging, and testing.

Example: Using Visual Studio to Create a .NET Core App

Step 1: Open Visual Studio and create a new project

• Select New Project from the start page or the File menu.

Step 2: Choose the project type

• Choose Console App (.NET Core) and click Next.

Step 3: Configure the project

• Name your project and choose a location to save it.

Step 4: Run the application

• Click the Run button (or press F5), and Visual Studio will build and run your console app.

5. Add a NuGet package:

• Right-click on the project, choose Manage NuGet Packages, and search for the package you need (e.g., Newtonsoft.Json).

Visual Studio provides a user-friendly way to manage all aspects of your project without needing to type any commands.

CLI vs GUI: A Direct Comparison

.NET Core CLI vs GUI: Direct Comparison

CLI vs GUI: When to Use Each

When to Use CLI:

• For Cross-Platform Development: The CLI is ideal when working on non-Windows systems like macOS or Linux.
• For Automation & Scripting: CLI commands are perfect for integrating into Continuous Integration (CI) and Continuous Deployment (CD) pipelines, allowing for automated builds, tests, and deployments.
• For Lightweight Development: If you prefer working with a lightweight text editor like VS Code or need to perform quick tasks without launching a full IDE, the CLI is the way to go.
• For Remote Development: CLI is great for working on remote servers via SSH, where a graphical interface might not be available.
• For Development Tasks: Developers use CLI for creating, building, and running projects. It’s faster for repetitive tasks like running builds or scripts.
• For System Administration: CLI is a staple for system admins who manage servers, especially in Linux-based environments or when working remotely via SSH.
• When Resource Constraints Matter: If you're working on a resource-limited machine, CLI is a lightweight alternative to using GUI-based software.

When to Use GUI:

• For Ease of Use: If you're new to a platform or tool, GUIs are more intuitive. Tasks like installing packages, managing databases, or writing code can be done with a few clicks.
• For Visual Tasks: GUIs are perfect for tasks that require visualization, such as designing user interfaces or viewing complex data structures.
• For Debugging and Testing: IDEs like Visual Studio provide a visual debugger, making it easier to set breakpoints, inspect variables, and manage testing.
• For Non-Technical Users: GUIs are generally more accessible to those who are not comfortable with coding or typing commands.

Conclusion: Choosing Between CLI and GUI

The choice between CLI and GUI depends on your needs:

• If you need speed, precision, and automation, CLI is the way to go.
• If you value ease of use, visual feedback, and don’t mind some extra resource usage, GUI is better suited.

Both tools have their place in the software development lifecycle, and understanding when to use each can make you a more efficient developer or user. In some cases, a combination of both is the best approach — using the GUI for project management and debugging while relying on the CLI for automation and advanced tasks.

From: Azharul Islam Sent: Saturday, October 5, 2024 12:42 PM To: azharul8269@gmail.com Subject: blg

When developing applications using .NET Core, developers have two main interfaces to work with: the .NET Core CLI (Command-Line Interface) and .NET Core GUI (Graphical User Interface) provided by tools like Visual Studio. Each offers distinct ways of interacting with the .NET Core development environment, and understanding the differences will help you choose the right tool for the job.

In this blog, we’ll dive into what the .NET Core CLI and GUI are, demonstrate how they work, and compare them side by side with examples.

What is CLI (Command-Line Interface)?

The Command-Line Interface (CLI) is a text-based way of interacting with your computer or development environment. You type commands into a terminal or command prompt, and the system responds by executing those commands.

What is .NET Core CLI (Command-Line Interface)?

The .NET Core CLI is a tool that allows you to interact with .NET Core from the command line. It's primarily used for creating, building, running, and publishing .NET Core applications without relying on an IDE like Visual Studio.

Think of it as a toolbox for working with your .NET Core projects, accessible directly from the command line or terminal.

Key Features of CLI:

• Text-based interaction: You input text commands, and the system responds with text output.
• Precision and control: You can run complex scripts, automate tasks, and manage systems with high precision.
• Resource efficiency: CLI requires fewer system resources (memory, CPU) compared to a GUI.
• Cross-platform: Available on Windows, macOS, and Linux.
• Command-driven: Use text commands to create and manage projects.
• Automation-friendly: Easily integrates into CI/CD pipelines for automated builds and deployments.
• Lightweight: Requires fewer resources compared to a GUI.
• Steep learning curve: Requires knowledge of specific commands and syntax.

Common Use Cases for CLI:

• Development: Managing projects, building, running, and publishing applications.
• Automation: Running batch scripts or automating tasks like backups or deployments.
• Remote management: Accessing remote servers via SSH (Secure Shell) for administrative tasks.

Here are some essential .NET Core CLI commands:

• dotnet new: Create a new project.
• dotnet run: Run a .NET Core application.
• dotnet build: Build the project.
• dotnet publish: Publish the application for deployment.
• dotnet test: Run tests for your project.
• dotnet add package: Add a NuGet package to your project.

Example: Using the .NET Core CLI

Here’s how you would create, build, run, publish a new .NET Core application(Console, Web, API etc.) using the CLI:

Command to Create a Console New Project

dotnet new console -n MyConsoleApp

• MyConsoleApp: specifies the name of your project.

Command to Create a New Web App:

dotnet new webapp -n MyWebApp

• webapp: is the template for a web application with Razor Pages.
• -n MyWebApp: specifies the name of your project.

This command generates the basic files and folders needed for a web application:

• Pages/: The Razor Pages for the app.
• wwwroot/: Static files (CSS, JavaScript, images).
• Program.cs and Startup.cs: The core configuration files.

Command to Create an Empty Web App:

dotnet new web -n MyEmptyWebApp

• This creates an empty project with minimal configuration. You can add controllers, views, and models as needed.

Command to Create a New Web API:

dotnet new webapi -n MyWebAPI

• webapi is the template for a REST API.
• -n MyWebAPI specifies the project name.

This command creates a project that follows RESTful conventions, with controller-based routing.

The Web API template generates files like:

• Controllers/WeatherForecastController.cs: A sample API controller.
• appsettings.json: Configuration settings.
• Program.cs and Startup.cs: Core configuration files.

• Building the Application

Once your app project is created, you can build it using the CLI. Building compiles the code and prepares it for execution.

Command to Build the Project:

dotnet build

The dotnet build command compiles the project, checks for errors, and produces the output necessary to run the application. The dotnet build command is same for console, web app and API.

• Running the Application

After building the project, you can run it directly using the CLI.

Command to Run the Project:

dotnet run

The dotnet run command is same for console, web app and API. 

For console application, you will see the output

Hello World!

For web application, the dotnet run command will start the built-in web server (Kestrel) and make your application available locally.

Once you run the command, you should see output similar to this:

Now listening on: https://localhost:5001
Now listening on: http://localhost:5000

This means the application is running, and you can access it by navigating to http://localhost:5000 or https://localhost:5001 in your browser.

For the Web API, Once the Web API is running, you'll be able to access it through routes defined in the controllers, like https://localhost:5001/weatherforecast.

• Publishing the Application

Once you’ve developed and tested your web application or Web API, you can publish it for deployment. The dotnet publish command packages your application and its dependencies into a folder, ready to be deployed on a server.

Command to Publish the Application:

dotnet publish -c Release -o ./publish

• -c Release: Builds the project in Release mode, which optimizes the code for deployment.
• -o ./publish: Specifies the output directory for the published files.

The output folder will contain all the necessary files to deploy your application, including:

• Compiled DLLs
• Static assets (CSS, JavaScript)
• Configuration files

These can then be copied to a server (e.g., an IIS server, or deployed to Azure).

This is a simple, fast way to create, build, run  and publish a project without the need for an IDE.

The .NET Core CLI is a powerful tool for creating, building, running, and publishing web applications and Web APIs. By using the CLI, you can quickly set up a project, build it, and deploy it to different environments, all from the command line. This is especially useful for developers working on cross-platform systems or those looking to automate processes like continuous integration and deployment (CI/CD).

• Issue-1

When you create a new project using the .NET Core CLI, it does not automatically generate a solution file (.sln) unless you explicitly ask for it. This behavior is intentional because the CLI allows you to create and manage individual projects without needing a solution file. In contrast, Visual Studio often creates a solution by default when setting up a project.

A solution file (.sln) is essentially a container that can hold multiple projects, making it easier to organize and manage related projects (like in large applications). However, for simpler, single-project scenarios, it’s not always necessary.

Why Does the CLI Not Create a Solution File?

Simplicity: The CLI assumes that you may be working on a single project, so creating a solution file may not be needed.

Project-centric: The .NET Core CLI is project-centric, meaning it focuses on the project itself (.csproj) rather than on solutions (.sln). It only creates the necessary files to run the project.

Modularity: You can choose to add a solution later if you need one, especially if you want to group multiple projects together.

How to Create a Solution File Using the CLI

If you want a solution file (.sln), you can explicitly create one and then add your project to it.

Step 1: Create a Solution File

You can create a solution using the following command:

dotnet new sln -n MySolution

• -n MySolution: This specifies the name of the solution file (you can name it whatever you want).

Step 2: Add Your Project to the Solution

After creating the solution, you can add the project to the solution:

dotnet sln add MyProject/MyProject.csproj

This command will add your project (.csproj file) to the solution. If your project is in a subfolder, make sure you provide the correct path to the .csproj file.

Benefits of Using a Solution File

·  Managing Multiple Projects: If you have a scenario with multiple projects (e.g., a Web API and a class library), using a solution file helps to organize them together.

·  Easier Build and Publish: You can build or publish all projects in the solution at once using the dotnet build or dotnet publish command on the solution.

·  IDE Integration: Visual Studio and other IDEs often rely on the solution file for features like build configurations, project management, and debugging.

• Issue-2

When you run a .NET Core application using the dotnet run command, the process starts and will continue running, especially for web applications, which will keep the server active. The terminal remains "busy" because the application is still running.

To stop the application and return to the command prompt, you need to terminate the process.

Here are the steps to stop the running application:

1. Stop the Running Application (Terminate Process)

In most cases, you can stop the application by pressing Ctrl + C in the terminal. This will send a signal to the application to terminate, and you will regain control of the terminal.

• On Windows, Linux, and macOS, press Ctrl + C to stop the running .NET Core application.

Once the application is stopped, you'll see your command prompt (D:\Practice\cli\FirstWebApp>), and you can now run other commands.

2. Terminate Specific Processes (If Ctrl + C Doesn't Work)

If pressing Ctrl + C does not stop the process (which can happen occasionally), you can forcefully kill the process. Here’s how to do it:

On Windows:

1. Open the Task Manager (Ctrl + Shift + Esc).
2. Find the running process associated with your .NET application (usually listed as "dotnet").
3. Select it and click End Task.

On Linux/macOS:

1. Run the following command in the terminal to list the processes:

ps aux | grep dotnet

·  Find the process ID (PID) of the running dotnet process.

·  Kill the process by running:

kill -9 <PID>

Automate the Stop and Start Process

If you need to run multiple commands sequentially after running dotnet run (like in a script), consider using a tool like tmux or screen to run the application in the background.

For instance, on Windows using PowerShell, you can run the command in the background like this:

Start-Process -NoNewWindow -FilePath "dotnet" -ArgumentList "run"

This will run the application in the background and immediately return control to the terminal.

What is GUI (Graphical User Interface)?

The Graphical User Interface (GUI) is a visual-based method of interacting with software. It uses buttons, icons, and other visual elements that users can click or drag to perform tasks. GUIs are generally more user-friendly and accessible for non-technical users.

What is .NET Core GUI(Graphical User Interface)?

The .NET Core GUI typically refers to using Visual Studio or Visual Studio Code to manage your .NET Core applications. These integrated development environments (IDEs) provide a visual interface to manage projects, write code, debug, and run applications.

Key Features of GUI:

• Visual interaction: Uses icons, windows, and other graphical elements to simplify interactions.
• Ease of use: Intuitive and beginner-friendly, making it ideal for users who aren’t comfortable with text-based commands.
• More resource-intensive: GUIs typically require more system resources like memory and CPU.
• Less flexible for automation: Although GUIs can be scripted, it’s often more complex and less flexible than CLI automation.
• User-friendly: Intuitive and easy to use, especially for beginners.
• Graphical tools: Visual tools for managing projects, adding dependencies, and debugging.
• Integrated debugging: Set breakpoints, inspect variables, and step through code.
• Project templates: Easily create new projects with pre-configured settings.

Common Use Cases for GUI:

• Everyday use: Browsing the web, using office applications, or interacting with any software that has a graphical interface.
• Development environments: IDEs like Visual Studio or Visual Studio Code provide GUIs that simplify project management, code writing, debugging, and testing.

Example: Using Visual Studio to Create a .NET Core App

Step 1: Open Visual Studio and create a new project

• Select New Project from the start page or the File menu.

Step 2: Choose the project type

• Choose Console App (.NET Core) and click Next.

Step 3: Configure the project

• Name your project and choose a location to save it.

Step 4: Run the application

• Click the Run button (or press F5), and Visual Studio will build and run your console app.

5. Add a NuGet package:

• Right-click on the project, choose Manage NuGet Packages, and search for the package you need (e.g., Newtonsoft.Json).

Visual Studio provides a user-friendly way to manage all aspects of your project without needing to type any commands.

CLI vs GUI: A Direct Comparison

.NET Core CLI vs GUI: Direct Comparison

CLI vs GUI: When to Use Each

When to Use CLI:

• For Cross-Platform Development: The CLI is ideal when working on non-Windows systems like macOS or Linux.
• For Automation & Scripting: CLI commands are perfect for integrating into Continuous Integration (CI) and Continuous Deployment (CD) pipelines, allowing for automated builds, tests, and deployments.
• For Lightweight Development: If you prefer working with a lightweight text editor like VS Code or need to perform quick tasks without launching a full IDE, the CLI is the way to go.
• For Remote Development: CLI is great for working on remote servers via SSH, where a graphical interface might not be available.
• For Development Tasks: Developers use CLI for creating, building, and running projects. It’s faster for repetitive tasks like running builds or scripts.
• For System Administration: CLI is a staple for system admins who manage servers, especially in Linux-based environments or when working remotely via SSH.
• When Resource Constraints Matter: If you're working on a resource-limited machine, CLI is a lightweight alternative to using GUI-based software.

When to Use GUI:

• For Ease of Use: If you're new to a platform or tool, GUIs are more intuitive. Tasks like installing packages, managing databases, or writing code can be done with a few clicks.
• For Visual Tasks: GUIs are perfect for tasks that require visualization, such as designing user interfaces or viewing complex data structures.
• For Debugging and Testing: IDEs like Visual Studio provide a visual debugger, making it easier to set breakpoints, inspect variables, and manage testing.
• For Non-Technical Users: GUIs are generally more accessible to those who are not comfortable with coding or typing commands.

Conclusion: Choosing Between CLI and GUI

The choice between CLI and GUI depends on your needs:

• If you need speed, precision, and automation, CLI is the way to go.
• If you value ease of use, visual feedback, and don’t mind some extra resource usage, GUI is better suited.

Both tools have their place in the software development lifecycle, and understanding when to use each can make you a more efficient developer or user. In some cases, a combination of both is the best approach — using the GUI for project management and debugging while relying on the CLI for automation and advanced tasks.

If you found this blog helpful, please share it with your peers and colleagues. Don't forget to subscribe to our 

If you found this blog helpful, please share it with your peers and colleagues. Don't forget to subscribe to our YouTube channel(Visit Codexoom on YouTube) for more tutorials on ASP.NET Core and professional software development tips!

Thank you for joining us, and as always, happy coding! Until next time, stay curious and keep building amazing things. Take care!

Watch this blog on this following video tutorial …….