Download code from GitHub
This is Day 01 of our seven day journey to learn C#. Today, we will begin with an introduction of a new world of programming and will discuss all the basic concepts required to learn this programming language. We will also discuss the .NET Framework and the .NET Core framework by covering important concepts of the framework. We will also get a basic understanding of managed and unmanaged code. At the end of the day, we will start with a simple Hello World program.
Today, we will learn the following topics:
- What is programming?
- What is .NET Core?
- What is .NET standard?
There might be various definitions or various thoughts to define the word programming. In my view, programming is writing a solution in such a way that a machine (computer) can understand to depict the solution, which you can identify manually.
For example, let’s say you have a problem statement: find the total count of vowels from this book. If you want to find the solution to this statement, what will you do?
The probable steps for the solution to this problem are as follows:
- First, get the right book. I am assuming that you know the vowels (a, e, i, o, and u).
- How many vowels did you find in a book?--0 (zero).
- Open the current page (initially, our current page is 1) and start reading to find vowels.
- If the letter matches a, e, i, o, or u (please note that the case doesn’t matter, so the letters might as well be A, E, I, O, and U), then increase the vowel count by one.
- Is the current page completed?
- If the answer of step 5 is yes, then check if this is the last page of the book:
- If yes, then we have the total vowel count in hand, which is nothing but n, where n is the total number of vowels found in the current chapter. Move to step 8 for the result.
- If this is not the last chapter, move to the next chapter by adding 1 to the current chapter number. So, we should move to 1 + 1 = 2 (Chapter 2).
- In the next chapter, repeat steps 4 to 6 and until you reach the last chapter of the book.
- Finally, we have the total vowel count, that is, n (n is the total number of vowels found).
The preceding steps just described how we reached a perfect solution for our problem statement. These steps showed how we manually found the answer to our problem of counting all the vowels in the book's chapters.
In the programming world, such steps are collectively known as an algorithm.
When we write the preceding step(s)/algorithm in such a way that a machine/computer will be able to follow the instructions, it is called programming. These instructions should be written in a language understood by the machine/computer, and this is what is called a programming language.
In this book, we will use C# 7.0 as the programming language and .NET Core as the framework.
While we are referring to .NET (pronounced as dot NET), it is .NET Full, as we have .NET Core in place and we are using .NET Core in our book examples with C# 7.0 as the language. Before moving ahead, you should know about .NET because there is a .NET Standard available with the .NET Core, that is API servers for both .NET Framework as well .NET Core. So, if you created a project using .NET Standard it is valid for both .NET Framework and .NET Core.
.NET is nothing but a combination of languages, runtime, and libraries, by using which we can develop managed software/applications. The software written in .NET is managed or is in a managed environment. To understand managed, we need to dig into how binary executables are available for operating systems. This comprises three broader steps:
- Writing the code (source code).
- Compiler compiles the source code.
- The operating system executes the binary executable immediately:
Broader steps – how binary executable is available?
The preceding process is a standard process depicting how compilers compile the source code and create executable binaries, but in the case of .NET, the compiler (C# compiler for our code) does not directly provide a binary executable; it provides an assembly and this assembly consists of metadata and intermediate language code, also known as Microsoft Intermediate Language (MSIL) or Intermediate Language (IL). This MSIL is a high-level language and this can’t be understood directly by the machine, as MSIL is not machine-specific code or byte code. For proper execution, it should be interpreted. This interpretation from MSIL or IL to the machine language happens with the help of JIT. In other words, JIT compiles MSIL, IL into the machine language, also called native code. For more information, refer to https://msdn.microsoft.com/en-us/library/ht8ecch6(v=vs.90).aspx.
For 64-bit compilation, Microsoft has announced RyuJIT (https://blogs.msdn.microsoft.com/dotnet/2014/02/27/ryujit-ctp2-getting-ready-for-prime-time/). In the coming versions, 32-bit compilation will also be handled by RyuJIT (https://github.com/dotnet/announcements/issues/10). After this, we can now have a single code base for both CoreCLR.
In our seven days of learning, we will not focus on the framework, but we will be more focused on the C# language with the use of .NET Core. In the coming sections, we will discuss important things of .NET Core in such a way that while we work with a C# program, we should understand how our program talks with the operating system.
.NET Core is a new general-purpose development environment introduced by Microsoft to meet cross-platform requirements. .NET Core supports Windows, Linux, and OSX.
.NET Core is an open source software development framework released under MIT License and maintained by the Microsoft and .NET community on the GitHub (https://github.com/dotnet/core) repository.
Here are some important features of .NET Core, that make .NET Core an important evolution step in software development:
- Cross-platform: Currently, .NET Core can be run on Windows, Linux, and macOS; in the future, there may be more. Refer to the roadmap (https://github.com/dotnet/core/blob/master/roadmap.md) for more info.
- Having easy command-line tools: You can use command-line tools for exercise with .NET Core. Refer to CLI tools for more at https://docs.microsoft.com/en-us/dotnet/articles/core/tools/index.
- Having compatibility: With the use of the .NET standard library, .NET Core is compatible with the .NET Frameworks, Xamarin and Mono.
- Open source: .NET Core platform is released under MIT License and is a .NET Foundation project (https://dotnetfoundation.org/).
.NET Core is a combination of coreclr, corefx, and cli and roslyn. These are the main components of .NET Core composition.
- Coreclr: It is a .NET runtime and provides assembly loading, garbage collector, and many more. You can check coreclr for more info at https://github.com/dotnet/coreclr.
- Corefx: It is a framework library; you can check corefx for more info at https://github.com/dotnet/corefx.
- Cli: It is nothing but a command-line interface tool and roslyn is the language compiler (the C# language in our case). Refer to cli (https://github.com/dotnet/cli) and Roslyn for more info at https://github.com/dotnet/roslyn.
The .NET Standard is a set of APIs that resolves the problems of code sharing while you’re trying to write cross-platform applications. Currently, Microsoft is working on .NET Standard 2.0 to make it streamlined, and these standards will be implemented by all, that is, .NET Framework, .NET Core, and Xamarin. With the use of .NET Standard (that is a set of APIs), you are ensuring that your program and class library will be available for all targeted .NET Frameworks and .NET Core. In other words, .NET Standard will replace Portable Class Libraries (PCL). For more information, refer to https://blogs.msdn.microsoft.com/dotnet/2016/09/26/introducing-net-standard/.
Note
The .NET Standard 2.0 repository is available at https://github.com/dotnet/standard.
Till now, you've got an idea of .NET Core and a few other things that help build cross-platform applications. In the coming sections, we will prepare the environment in order to start learning the C# language using Visual Studio 2017 (preferably the community edition).
Integrated Development Environment (IDE) is nothing but software facilitating the development of applications. On the other hand, editors are basically meant to add/update predefined or new content. When we talk about the C# editor, we are referring to an editor that helps write C# programs. Some editors come with a lot of add-ons or plugins and can compile or run the programs.
We will use Visual Studio 2017 as our preferred C# IDE; however, there are a few more C# IDEs and editors you can go with:
- Visual Studio Code: VS Code is an editor, and you can start by downloading it from https://code.visualstudio.com/. To start with VS Code, you need to install the C# extension from https://marketplace.visualstudio.com/items?itemName=ms-vscode.csharp.
- Cloud9: It is a web browser-based IDE. You can start it for free by signing up at https://c9.io/signup.
- JetBrain Rider: This is a cross-platform IDE by JetBrains. For more information, visit https://www.jetbrains.com/rider/.
- Zeus IDE: This is an IDE designed for the Windows platform. You can start using Zeus from https://www.zeusedit.com/index.html.
- Text editor: This is the way you can go without any installation; just use a text editor of your choice. I use Notepad++ (https://notepad-plus-plus.org/download/v7.3.3.html) and the Command Line Interface (CLI) to build code. Refer to https://docs.microsoft.com/en-us/dotnet/articles/core/tools/ to know more about how to start with the CLI.
There may be more alternative IDEs and editors, but they are not as important to us.
In this section, we will see step by step how to initiate the installation of Visual Studio 2017 (preferably, the community edition) on Windows 10:
- Go to https://www.visualstudio.com/downloads/ (you can also get the benefits of Dev Essentials from https://www.visualstudio.com/dev-essentials/).
- Download
Visual Studio Community(https://www.visualstudio.com/thank-you-downloading-visual-studio/?sku=Community&rel=15):
- Start the Visual Studio setup.
- From
Workloads, select the options you want to install. For our book, we need.NET desktop developmentand .NET Core:
- Click on
Installto start the installation:
- Click
Launchonce the installation is completed. - Sign up for Visual Studio using your Live ID.
- Select
Visual C#as your development setting. - You will see the start page as follows:
We are all set to start with our first step.
