The Ultimate CLI Guide for .NET Core Applications: Build, Run, and Deploy

The command line interface (CLI) is a powerful tool for developers, allowing for efficient management of the entire lifecycle of a .NET Core application, from creation to deployment. This guide will provide a comprehensive walkthrough of using the .NET CLI for building, running, and deploying .NET Core applications, making it an essential resource for developers who prefer command line tools over integrated development environments (IDEs).

Getting Started with .NET CLI

Before diving into the .NET CLI, ensure you have .NET Core SDK installed on your system. The SDK includes the .NET CLI, necessary for creating, building, running, and deploying .NET Core applications. To verify the installation, open your command line or terminal and run:

Advertisement

dotnet --version

This command should return the version of the .NET Core SDK installed on your machine.

Creating a New .NET Core Application

Start by creating a new .NET Core application. The .NET CLI supports various types of applications, including console apps, web apps, and more. To create a new console application, use the following command:

dotnet new console -n MyFirstDotNetApp

This command creates a new directory named MyFirstDotNetApp with a simple “Hello World” console application.

Building the Application

Navigate to the application directory and build the application using the .NET CLI:

cd MyFirstDotNetApp
dotnet build

This command compiles the application and checks for any compile-time errors, ensuring your code is ready to run.

Running the Application

To run the application, use the following command:

dotnet run

This command runs the application, and you should see the output, typically “Hello World,” in the console.

Understanding .NET Core Application Structure

A .NET Core application consists of several files, but two main files are worth noting:

• Program.cs: This file contains the entry point of the application, where the execution begins.
• .csproj file: This is the project file for your application. It includes information like the SDK version, dependencies, and other configurations.

Adding Dependencies

To add a package or dependency to your application, use the dotnet add package command followed by the package name. For example, to add Newtonsoft.Json, you would use:

dotnet add package Newtonsoft.Json

This command modifies the .csproj file to include the newly added package as a dependency.

Deploying the Application

Deployment often involves publishing your application to a directory with all the necessary files to run the application. To publish a .NET Core application, use:

dotnet publish -c Release

This command compiles the application in release mode (optimized for performance), and places the output in the bin/Release directory, or a subdirectory based on the target framework. You can then deploy this output to your hosting environment.

To set a custom deployment directory use -o with the new directory location: For example:

dotnet publish -c Release -o /var/apps/helloworld

Deployment Considerations

• Environment Variables: Ensure any environment-specific variables are correctly set in your deployment environment.
• Configuration Files: Review appsettings.json or other configuration files for environment-specific settings.
• Dependencies: Ensure all dependencies are resolved and appropriately packaged during the publish step.

Conclusion

The .NET CLI is a versatile and efficient tool for managing .NET Core applications. By mastering the CLI commands, developers can effectively handle the creation, development, and deployment processes of their applications. This guide has covered the basics to get you started, but the .NET CLI offers much more. Explore the official .NET documentation to dive deeper into the capabilities of the .NET CLI and unlock its full potential in your development workflow.