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

Beginning modern application development with .NET Core – Part 0: What is .NET core?

This is the first 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/

.NET Core is an exciting open source project from Microsoft that brings the power of the .NET development environment to all platforms without having to make use of a third party tool (like Mono). It is relatively new, with version 1 released in June 2016, and is fully supported by Microsoft as one of their first-class products.

The release of .NET Core brings with it a re-architected platform for creating modern applications that consists of the following components:

  • CoreCLR – the core compiler and base types for .NET programming languages (mostly written in C++).
  • CoreFX – the standard libraries, consisting of the main packages used in most applications.
  • DotNET CLI – a command line interface that brings powerful development tools to your favorite shells such as Bash and Powershell.
  • Roslyn – .NET compilers and code analysis platform that allows IDEs other than Visual Studio to provide a better development experience.

What’s different from the regular .NET Framework on Windows machines?

Well, to start with, .NET core runs on nearly all modern operating systems (including Mac, Linux, BSDs and Windows); so you can easily develop your software on Windows and deploy it to a Linux server (or vice-versa).

Secondly, .NET core applications are package based – so you pull in the libraries you need from a package manager and you don’t have to worry about installing the full .NET framework. Everything you need to run your application is shipped with it, making deployments easier to predict and making it simpler to keep all environments the same.

Finally, every component from the compiler to the standard library is open sourced; meaning if you face an issue you can very quickly raise it with Microsoft and community developers.

I’ve heard a lot about different “target platforms” – what are they?

When you develop a .NET core application or library you have the ability for it to target different platforms. There are three main ones, and each has a slightly different meaning or benefit to it than the others.

  • .NET Framework target – this targets the full .NET framework (i.e. .NET 4.6/7) that is only available on Windows operating systems and will therefore only run on environments where that runtime is present.
  • .NET Core target – this targets those applications that run on the .NET Core runtime.
  • .NET Standard target – (libraries only) this targets any runtime that is .NET standard compliant – if you’re using the most up to date frameworks, then you’ll be able to use projects that target this platform anywhere.

For example, if you created a .NET Core class library, you would only be able to use it in other projects that also target the .NET core platform.

However, if you created a .NET Standard class library, you would be able to use it within all projects that target a platform which complies with the .NET Standard.

I thought .NET core had migrated to using JSON files instead of .csproj files?

In the first few versions of .NET Core, the project setup and structure was indeed described within a project.json file. However, as .NET Core was adopted more widely within the eco-system, Microsoft needed a way for all platforms to work together, sharing one project file layout.

It was therefore decided that instead of modifying the tooling for all of these platforms to work with the new JSON format, the ones currently using it would be rolled back to utilise a modified .csproj XML format: one where the pain points experienced by many had been removed.

What will I miss if I migrate to .NET core?

There are a number of major items that are not available in .NET core.

  • WinForms – there is no WinForms support in .NET Core, so you will not be able to update your existing projects.
  • WPF – there is no WPF support in .NET Core, so you will not be able to update your existing projects.
  • WCF – it is currently not possible to create WCF services within a .NET Core application. You can still consume them using the WCF client libraries (https://github.com/dotnet/wcf), but if you want to build them you will need to target the full .NET Framework.
  • SignalR – neither the client or server libraries for SignalR are available in .NET Core (though they are scheduled for release with .NET Core 2.1).
  • AppDomains – AppDomains were discontinued as part of .NET Core.

How do I get started?

This post is the first of many in a series of how to begin modern application development with .NET. Follow along, and you too can build cross-platform applications with the newest framework from Microsoft.

Follow the series by bookmarking this tag. Alternatively, follow me on Twitter, where I will tweet whenever a new post goes live.