Beginning modern application development with .NET Core – Part 1: Getting started and writing some code

This is the second post in a free series of tutorials on “Beginning modern application development with .NET Core”. To view the series, click here: https://elsyms.com/tag/beginning-modern-application-development-with-net-core/

All of the source code used within this tutorial is available within a publically browsable Gitlab repository, located here: https://gitlab.com/elsymds/modern-application-development-with-dotnet-core

Introduction

Welcome to the second post in the series of tutorials on “Beginning modern application development with .NET Core”. This post is going to cover your first step towards writing a modern application: the setting up of your development environment and writing your first, small piece of software. You’ll learn how to download and install the .NET Core SDK, you’ll install a code editor and you’ll get your first bit of code running; exciting stuff!

Installing the required tools

First things first, you need to install some software on your machine. Don’t worry: these are all developed by and downloaded from Microsoft; so no need to worry about viruses making their way onto your system.

1. Installing the .NET Core SDK

In order to run, build, compile or test any .NET core code, you will need to install the SDK. This is freely available on the Microsoft website, and has great instructions on how to get the SDK installed on your operating system.

https://www.microsoft.com/net/download/

2. Installing an editor: Visual Studio Code

Next, you need some software called a code editor. You could use regular ol’ Notepad, but using a tool specifically for the job of programming will help you in more ways than you could imagine once you start writing more complicated code (syntax highlighting, snippets, intellisense).

We’re going to use an editor called Visual Studio Code. It’s a relatively new, free editor from Microsoft and is a great tool for programming in the .NET Core languages.

So, go ahead and download it from here: https://www.microsoft.com/net/download/.

Once you have installed the editor, there is one last thing you need to do and that is to install an extension within Visual Studio Code that helps you with programming in C# (the .NET Core based programming language we’re going to be using).

To install this extension, open Visual Studio Code and click the extensions icon in the sidebar.

Then, in the extensions search bar, search for ‘csharp’, and install the extension provided by Microsoft. It should have over 3.5 million downloads, so it’s not difficult to spot what is the correct extension. If you are struggling to find it, then you can sort by ‘Most popular’ by clicking the ellipsis icon and then selecting the relevant menu item.

Once you have installed this extension, reload Visual Studio Code when prompted and you are ready to go!

3. Checking the .NET Core SDK installed correctly

Inside of Visual Studio Code, click ‘View’ in the toolbar and then ‘Integrated Console’. Alternatively, press Ctrl + `. You should see a terminal window open where you are able to type commands. A terminal window is a place where you are able to execute commands against the system.

Inside of this terminal window, type the following:

$ dotnet --version

If you see something like the below (even with a different version number), then the .NET Core SDK has installed successfully and you’re ready to write your first piece of .NET code. Congratulations! If you see an error, first make sure you have installed the SDK correctly and then reboot your machine.

$ dotnet --version
2.0.2

Exploring the CLI and creating a new project

The CLI (short for command-line interface) is your new friend when it comes to programming in .NET core. It contains helpful functions that allow you to create, compile, test and publish your applications with no more than a few keystrokes.

Taking a look around the command line interface

If you’ve followed the tutorial so far you should have Visual Studio Code open with a terminal window visible. If you don’t: get that ready again, if you do: great.

Most command line interfaces come with a ‘help’ command embedded within them that advises you on what the CLI can do for you. Let’s run the .NET Core CLI’s help command (dotnet --help) and have a look over what the CLI can do for us.

$ dotnet --help
.NET Command Line Tools (2.0.2)
Usage: dotnet [runtime-options] [path-to-application]
Usage: dotnet [sdk-options] [command] [arguments] [command-options]

path-to-application:
The path to an application .dll file to execute.

SDK commands:
new Initialize .NET projects.
restore Restore dependencies specified in the .NET project.
run Compiles and immediately executes a .NET project.
build Builds a .NET project.
publish Publishes a .NET project for deployment (including the runtime).
test Runs unit tests using the test runner specified in the project.
pack Creates a NuGet package.
migrate Migrates a project.json based project to a msbuild based project.
clean Clean build output(s).
sln Modify solution (SLN) files.
add Add reference to the project.
remove Remove reference from the project.
list List reference in the project.
nuget Provides additional NuGet commands.
msbuild Runs Microsoft Build Engine (MSBuild).
vstest Runs Microsoft Test Execution Command Line Tool.

Common options:
-v|--verbosity Set the verbosity level of the command. Allowed values are q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic].
-h|--help Show help.

Run 'dotnet COMMAND --help' for more information on a command.

sdk-options:
--version Display .NET Core SDK version.
--info Display .NET Core information.
-d|--diagnostics Enable diagnostic output.

runtime-options:
--additionalprobingpath <path> Path containing probing policy and assemblies to probe for.
--fx-version <version> Version of the installed Shared Framework to use to run the application.
--roll-forward-on-no-candidate-fx Roll forward on no candidate shared framework is enabled.
--additional-deps <path> Path to additonal deps.json file.

As you can see, there is a great amount of functionality within the CLI that we can use. As you become more experienced with development in .NET Core, you’ll use more and more of these commands.

Creating a new project

The command we’re interested in for now, however, is the ‘new’ command.

new Initialize .NET projects.

As the description alludes to, the ‘new’ command will generate a new .NET project for us based on a pre-determined template, meaning we spend less time on administrative tasks and more time programming. If you run the help command for dotnet new (by suffixing the option --help), you will see that there are a number of templates we can choose from.

To start with, let’s just create a regular console application. Run the command below (dotnet new console -n modern-app-dev-01) to start a new project based off of the ‘Console Application’ project template.

$ dotnet new console -n modern-app-dev-01
The template "Console Application" was created successfully.

Processing post-creation actions...
Running 'dotnet restore' on modern-app-dev-01/modern-app-dev-01.csproj...
Restoring packages for /home/liam/modern-app-dev-01/modern-app-dev-01.csproj...
Generating MSBuild file /home/liam/modern-app-dev-01/obj/modern-app-dev-01.csproj.nuget.g.props.
Generating MSBuild file /home/liam/modern-app-dev-01/obj/modern-app-dev-01.csproj.nuget.g.targets.
Restore completed in 219.68 ms for /home/liam/modern-app-dev-01/modern-app-dev-01.csproj.

 

Restore succeeded.

Then, open this newly created folder within Visual Studio Code by going to ‘File’ and then ‘Open Folder’. After doing this, you should see that the sidebar updates with the list of files in the newly created project directory.

Writing some code

By default, creating a new .NET Core Console project automatically creates a ‘Program.cs’ file with a ‘Hello World!’ statement in it. In most tutorial posts, this would constitute the end of the series and the author would announce that you are officially a programmer. Unfortunately, this isn’t your Grandmother’s programming tutorial, and this isn’t the final post of the series, so we’re going to dive straight in by first dissecting the program the CLI generated for us and then writing a small program that asks us for our name and then greets us, instead of the entire world.

Dissecting the current application

Open the ‘Program.cs’ file and look at what is in there currently.

using System; – A using statement within C# (or an import statement within VB), allows you to access types (classes, interfaces, structs etc) that do not exist within your current namespace (explained next).

namespace modern_app_dev_01 – A namespace groups sets of related types together within a wider assembly (or project). You can have many namespaces within an assembly, however for the purposes of this tutorial we’re going to stick with just one.

class Program – A class is essentially a grouping of variables, methods and events. Think of it as a bucket, where you put things that are related to each other to keep them organised.

static void Main(string[] args) – Is a method that is the entry point of the application, or what is called whenever the application is ran. The string[] args part within the parentheses is what is known as a method parameter. The first part of this parameter (string[]) tells us that the args parameter is an array of strings.

Console.WriteLine("Hello World!"); – This line calls a static method (meaning you do not have to declare an instance of the class) on the System.Console class. Having the using System; statement at the top of the file means we do not need to call this method by its fully qualified, namespaced name: System.Console.WriteLine.

Writing our introductory application

Remove the Console.WriteLine("Hello World!") line and prepare yourself to write some code. Then, write the code below, line by line. I have included comments which explain what each line does.

using System;

namespace modern_app_dev_01
{
    class Program
    {
        static void Main(string[] args)
        {
            // Writes a line out to the console.
            Console.WriteLine("Please enter your name and then press enter");

            // Reads input from the console into a variable.
            string myName = Console.ReadLine();

            // Writes an interpolated (i.e. putting variable string representations into a piece of text)
            // out to the console for the user to see. 
            Console.WriteLine($"Why hello there, {myName}. Press any key to exit the application.");

            // Waits for someone to press a key and then exits.
            Console.Read();
        }
    }
}

Running our introductory application

Once you’ve written the above code (you don’t have to include the comments, they’re just there for reference), open the terminal window in Visual Studio Code (if you’ve hidden it, go to ‘View and then ‘Integrated Terminal’ or use the hotkey Ctrl + `) and run the dotnet run command.

If everything has gone to plan, you should see your application run! Type your name when prompted and see your program come to life:

$ dotnet run
Please enter your name and then press enter
Liam Symonds
Why hello there, Liam Symonds. Press any key to exit the application.

Summary

Within this tutorial you have installed the .NET Core SDK, installed a code editor, learned about command line interfaces, dissected a generated program and wrote your own basic program. All for free, in the comfort of your own chair. Great work!

Get notifications for more tutorials on ‘Beginning modern application development with .NET Core’ by following me on Twitter (@liamsymonds). If you need any assistance with anything in this tutorial, feel free to tweet me your questions.

This is the second post in a free series of tutorials on “Beginning modern application development with .NET Core”. To view the series, click here: https://elsyms.com/tag/beginning-modern-application-development-with-net-core/

All of the source code used within this tutorial is available within a publically browsable Gitlab repository, located here: https://gitlab.com/elsymds/modern-application-development-with-dotnet-core