Deep Dive Into .NET Core

So as I have installed a new version of .net it’s setting up my packages as shown below.


Figure 13: Creating new C# console application

Once this step is complete we are ready to go. We check our files which got created when we run dotnet new as shown below.


Figure 14: Project files.

So now we have Program.cs which contains the actual C# program, project.json file consists of all the dependencies which our program is using in order to run.

So our first console application contains the following code.


Figure 15: Simple Hello world Program.

In our primary .net framework when we run our program the clr used to load some base class libraries which used to stay on .net framework folder in windows as shown below.


Figure 16: .NET Framework v 64

While in .net core all the bunch of libraries which we need gets installed on
C:\Program Files\dotnet\shared\Microsoft.NETCore.App\1.1.0


Figure 17: .NET core location.

So here there is no dependency with the Microsoft.net framework folder as in the case of .net framework. Here all the shared libraries are downloaded and those libraries come around using nuget packages which are a package manager to download the libraries via web.

Let’s have look on our other file Project.json.


Figure 18: Project.json file.

Here we can see it’s a json format and all the attributes are self-explanatory.

Microsoft.NETCore.App specifies we are trying to make a core application which will run cross platform.

• Version specifies the version being used
• Build option for building your app
• Dependencies – The dependencies your project is using with .net

Now the first time we run our program we need to restore the package for project.json as shown below.

• Dotnet restore
  
  
  Figure 19: Running dotnet restore.

We have logs called writing to lock the file, which means that .net creates a json file called project.lock.json which acts as lock file containing all the dependencies needed to run our application with the version.

Building our program

In order to build your program, you need to type the below command.

Dotnet build

This command will compile your program, as shown below.


Figure 20: Running dotnet build.

Running our Program

Dotnet run

This command will run your program, as shown below.


Figure 21: Running dotnet run to run the program.

3.0 Visual Studio Code

“Visual Studio Code is a code editor redefined and optimized for building and debugging modern web and cloud applications. Visual Studio Code is free and Open Source.”

Via- https://code.visualstudio.com/

You can download VS code from here.

VS code has proven itself to be best text editor available in the market with support from Microsoft and getting support for various languages. It has a good extension for developers to speed up the development time for developer eg C#, C# extension for VS Code, MONO debug etc.

• After installing Vs code open Vs code as a new window
• You can create a new directory or open the already created project shown above in demos.
• Select explorer window and select the folder where your project exists.

Figure 22: Explorer window of VS code.

Figure 23: Select the project folder.


Figure 24: Project structure in Vs Code.

Now you can create your own folder or files as per your project requirement

• In order to open vs code from the current project from the command prompt

We will write,


Figure 25: An Opening project in VS code using CMD.

This is how VS Code looks after that.


Figure 26: Displaying the project structure.

Once it figures out the type of application you are running it will download the extension required for speeding up development workflow.


Figure 27: VS Code prompting to add new assets to the project.

So now the question arises how I am gonna build and run my application. Download the below extension for easy and rapid development in Vs Code as shown below.

• C#
• MONO debug
• C# extensions

Go to extension and search for the required extension and then install the same. As shown below,


Figure 28: Installing new extension in VS code.

Once you install the above mentioned extension, in order to compile your application, you will type

Ctrl+shift+b


Figure 29: Building your C# application using VS code.

For running your application in Debug mode.

F5


Figure 30: Debugging C# application in VS code.

Running without debugging

Ctrl+f5

How about if we want to run cmd commands using VS code:

We can also run cmd in VS code with simple tricks as shown below and run your application via cmd

• Type ctrl+~ In VS Code window
• The Cmd terminal will open.

Figure 31: Opening CMD in VSCODE.

Now, you can write your cmd command to run your app as we did earlier.


Figure 32: Running CLI commands dotnet from VS code.

We can run any cmd command to perform the task you want to perform. Isn’t is useful and fascinating? I love this part about working on cmd from VS code.

4.0 Dotnet Watch

As a C# developer, I have been using Visual Studio sometimes if we want to change something like our code in our view or C#. We just make a change, build the project, and refresh the window to check the updated changes in our code. How great would it be if we had a feature where we can make a change and hit refresh. So there should some tool that would watch all of that code that we are changing there when Dotnet watch comes into the picture. Dotnet watch watches the code and if it finds any change in the code it will recompile the code.

So in order to use the same we will search dotnet watch or goto https://github.com/aspnet/DotNetTools


Figure 33: Dot net watch.

Select dotnet-watch and follow the readme section.

“dotnet-watch is a file watcher for .net that restarts the specified application when changes in the source code are detected. “

Via: https://github.com/aspnet/DotNetTools/tree/dev/src/Microsoft.DotNet.Watcher.Tools

So we are going to add,

"Microsoft.DotNet.Watcher.Tools": "1.0.0-preview4-final"

In our project.json file restore the package using dotnet restore as shown below.

Go to project.json and in the tool section.


Figure 34: Adding dotnet watch configuration in Project.json .

Restore the dotnet.

dotnet restore

So now in order to check the same we will run our application using

dotnet watch run


Figure 35: Dotnet watch waiting forthe file to get changed.

Once we run our application using dotnet watch run, dotnet watch will watch for the file to change and rebuild an application as shown below.


Figure 36: Dotnet watch restarting dotnet automatically once the file gets changed.

So if we will change anything in our code, .NET watch will trace that file and rebuild our program to execute it again. See how great this tool is and how useful it will be when we are working with web technologies, changing the code, and hitting refresh?

Acknowledgments

We found how easy it is to write your simple application using the command line or Vs code. Vs code is improving day by day. It’s a great tool for developers who use Mac or Unix to unleash the power of .NET core or to check out VS code as a text editor. I hope this article will be useful to start with the basics of .net Core. Stay tuned for Asp.net MVC 6 using Vs code.