.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:
consolespecifies the type of application to create.-n MyFirstAppsets 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.