Chapter 3 Command Line Interface

There are other interesting but less used sections available. Table 3-5 shows a complete overview for completeness.

Table 3-5.  Overview of NuGet.config sections

Dotnet Build

Dotnet build builds (what a shock!) your project and all of its dependencies. It’s a straightforward command with a limited set of options. Listing 3-7 shows its options.

Listing 3-7.  Options for dotnet build

Usage:

dotnet [options] build [<PROJECT | SOLUTION>...]

Arguments:

<PROJECT | SOLUTION> The project or solution file to operate on. If a file is not specified, the command will search the current directory for one.

Options:

--use-current-runtime Use current runtime as the target runtime.

46

47

Dotnet build triggers the same workflow as Build Solution does in Visual Studio; whenever you click Build Solution in Visual Studio, it launches dotnet build under the hood. It takes your code and its dependencies and compiles it into DLLs, executables, symbols, and so on.

Before we can build an application, we need to make sure that all dependencies are restored. This can be done by running dotnet restore which we’ve seen earlier in this chapter. However, we don’t have to run dotnet restore every time before building a project; it runs implicitly when executing dotnet build. Unless we use dotnet build --no-restore.

Dotnet build uses msbuild to do the actual compiling of the code. MSBuild options can be passed in through parameters like -l for logging. MSBuild can be called directly from the dotnet tool by using dotnet msbuild <arguments>. We won’t dive into the msbuild options in this book. The dotnet build command is basically the same as msbuild -restore although the output looks different.

Two important parameters for the dotnet build command are configuration and runtime. Configuration specifies the configuration used for this build, while the runtime parameter specifies what version of the .NET runtime we’re building against.

The default configurations in .NET are Release and Debug. If we don’t specify a configuration, the Debug configuration will be used by default. Depending on the selected configuration, the build output will by default appear in bin\<config>\net6.0. These configurations differ in the way they optimize code for either debugging purposes or performance. Listing 3-8 shows how we can switch configurations.

Listing 3-8.  Running a build in the Release configuration

dotnet build -c release

48

Chapter 3 Command Line Interface

Runtimes are specified using a runtime identifier (RID). RIDs are used to define on the type of system architecture the application will run. An application needs to be compiled differently for a 64-bit Intel processor compared to a 64-bit ARM processor

and for the different operating systems and their versions. An RID follows the pattern as shown in Listing 3-9.

Listing 3-9.  RID pattern

<os>.<version>-<architecture>-<additional>

For example, let’s build an application for use on ARM64, which is an architecture that Windows can run on and try to run the application. Figure 3-6 shows the build and the attempt to run the application.

Figure 3-6.  Running an ARM application on x64

The .NET runtime contains a runtime.json file. In this file is a runtime graph; it specifies what operating systems and what versions/architectures are available or what the fallback is. Listing 3-10 shows an example entry from runtime.json.

49

Chapter 3 Command Line Interface

Listing 3-10.  Example entry in runtime.json

"alpine.3.13": { "#import": [

"alpine.3.12"

]

}

Listing 3-10 shows the entry for Alpine Linux, a lightweight Linux distribution. The entry specifies Alpine version 3.13 but imports 3.12; when .NET tries to restore NuGet packages for a project targeting Alpine Linux, it will try to find packages targeting Alpine 3.13. Should there be a package that does not target this version, it will look for a fallback to Alpine 3.12 support. The complete runtime.json file can be found on GitHub https:// github.com/dotnet/runtime/blob/main/src/libraries/Microsoft.NETCore. Platforms/src/runtime.json.

Listing 3-11.  dotnet runtimes

Listing 3-11 lists the most common runtimes for .NET:

50

Chapter 2 of this book dives deeper into runtimes, platforms, and extensibility packs.

51