.NET Core CLI is an invaluable tool for any .NET developer. It allows developers to create, build, run, and publish applications using simple command-line commands. By utilizing the CLI, you can quickly navigate projects, manage dependencies, and execute various .NET tasks without the need for a fully-fledged IDE.

Understanding the Basic CLI Commands

Let’s dive into some of the key CLI commands that are a part of the .NET Core toolkit.

1. dotnet new

The dotnet new command is used to create a new .NET project. It offers various templates including console applications, web applications, class libraries, and more.

Example: To create a new console application, you can execute the following command:

dotnet new console -n MyFirstApp

In this command:

• console specifies the type of application to create.
• -n MyFirstApp sets the name of the project.

When you run this command, it sets up a new folder named MyFirstApp with the basic structure of a console application—including the necessary files to get started.

2. dotnet build

After you've created your project and started coding, you'll need to compile your application. The dotnet build command compiles the application's code and prepares it for execution.

Example: To build the previously created console application, navigate to the project directory and run:

cd MyFirstApp
dotnet build

This command processes all the code files and outputs the compiled binaries, ready for execution.

3. dotnet run

Once your project is built, you can run it directly from the command line using dotnet run. This command not only builds the application but also executes it in one step.

Example: To run your console application, simply type:

dotnet run

This will execute your application, and you will see any output that your application generates in the console.

4. dotnet add package

When developing applications, managing dependencies is crucial. The dotnet add package command allows you to add NuGet packages to your project.

Example: If you want to include the popular Newtonsoft.Json library for JSON manipulation, you can add it using:

dotnet add package Newtonsoft.Json

After running this command, the specified package will be added to your project’s .csproj file, making it available for use.

5. dotnet publish

When you’re ready to deploy your application, you can use the dotnet publish command. This prepares the application for deployment, including all dependencies and configuration settings.

Example: To publish your application, run:

dotnet publish -c Release

Here, -c Release specifies that you want to publish the release configuration of your application. This command generates a set of files in the bin\Release\netcoreappx.x\publish folder (where x.x is the version number).

6. dotnet restore

The dotnet restore command is used to restore the dependencies and tools of a project. It reads the project’s configuration files and downloads the required packages.

Example: To restore packages for your project, navigate to your project directory and run:

dotnet restore

This ensures you have all the necessary dependencies that your project needs to build and run correctly.

Summary of Common Commands

Command	Description
dotnet new	Create a new .NET project
dotnet build	Compile the application
dotnet run	Run the application
dotnet add package	Add a NuGet package to the project
dotnet publish	Prepare the application for deployment
dotnet restore	Restore project dependencies

Learning and mastering .NET Core CLI commands is essential for effective development in the .NET space. As you continue to work with .NET Core, practicing these commands will enhance your productivity and allow you to leverage the full power of the .NET ecosystem.