swirl
Home Software Blog Wallpapers Webtools
Publishing DotNET Core Apps
Friday 20, November 2020   |   Post link

Overview

As we all know, .NET Core follows the same strategy for compiling application into an intermediate form so that it can run on multiple platforms like Windows, Linux and MacOS without recompiling the source code just like Java.

Unlike Java however, .NET Core apps can be distributed in two ways. In order to run any Java application you must have the Java Runtime Environment installed on the target machines. With .NET Core, this is optional. DotNET Core can package the runtime along with the app. We'll see how this works with a classic 'Hello World' app using DotNetCore 3.1.

Create the console application

d:\temp>md HelloWorld
d:\temp>cd HelloWorld
d:\temp\HelloWorld>dotnet new console
d:\temp\HelloWorld>dotnet run
The last command will compile and run the app which displays Hello World! on the console.

Adding multiple targets

Microsoft uses the term 'runtime identifier' (RIDs) to target specific platforms. This page has a lot of information about how this works. I strongly suggest you go through this once. We'll add the RID for Linux (Ubuntu) to our project. Open the file HelloWorld.csproj in a text editor. The contents will look like this:

<Project Sdk="Microsoft.NET.Sdk">
	<PropertyGroup>
		<OutputType>Exe</OutputType>
		<TargetFramework>netcoreapp3.1</TargetFramework>
	</PropertyGroup>
</Project>

We need to add <RuntimeIdentifiers>win10-x64;linux-x64</RuntimeIdentifiers>. The project file should now look like:

<Project Sdk="Microsoft.NET.Sdk">
	<PropertyGroup>
		<OutputType>Exe</OutputType>
		<TargetFramework>netcoreapp3.1</TargetFramework>
		<RuntimeIdentifiers>win10-x64;linux-x64</RuntimeIdentifiers>
	</PropertyGroup>
</Project>

Publishing for a platform

We need to use the dotnet publish command to publish. The -r switch allows selecting a particular RID (platform). We'll first publish targetting the Windows platform:

dotnet publish -r win10-x64

This is the output we see:

Publish for Windows

If we open the bin\Debug\netcoreapp3.1\win10-x64\publish folder in Windows Explorer, we see whole lot of files, together, all these files are enough to run the app on another Windows 10 PC which does not even have the .NET Core runtime installed.

Let's do the same for Linux.

dotnet publish -r linux-x64

The output is similar:

Publish for Windows

Again, copying all the files present in the bin\Debug\netcoreapp3.1\linux-x64\publish\ to a Ubuntu Linux machine is enough to run the app on the target Linux machine. We can actually test this out on Windows itself. One thing to keep in mind is that the generated application assembly (dll) is itself platform neutral i.e. it is capable of running on any supported operating system. Its some of the other supporting files which are platform specific.

We need to install Windows Subsystem for Linux (WSL). Its quite easily done. Refer to this link to enable WSL. If you for some reason don't want to use WSL, you can always use a real Linux machine or a VM. This post uses WSL.

Start WSL and change the directory to the Linux publish folder and run the HelloWorld application:

Publish for Windows

Note, running the dotnet command produces an error because there is no .NET Core runtime or SDK installed on the Linux subsystem. However, when we run the actual app ./HelloWorld, it executes without any error.

Framework dependent publishing

The kind of publishing we saw till now was a self-contained publishing which is great to distributing the app on systems which don't have the .NET Core runtime installed but, what if you already have the runtime? Do we still need to copy all the files on the target system?

The answer is no, we can do with a much smaller set of files. We just need to use a specific flag when publishing. First we delete the bin\Debug\netcoreapp3.1\linux-x64 folder and then run the publish command again but specify the --self-contained false flag.

dotnet publish -r linux-x64 --self-contained false

The publish folder now contains only five files. If we now copy these files to a Linux system which has the .NET Core Runtime installed, we should be able to run the app using dotnet ./HelloWorld.dll command.

Running on Linux with runtime installed

The dotnet --list-runtimes command prints the runtime available on the system. Since the runtime is present, running dotnet ./HelloWorld.dll runs the app successfully. We however don't have the .NET Core SDK which is why running the dotnet --version command shows a message about not finding any SDKs.

You can also run the application another way. You can add an execute permission on the HelloWorld file by using the command chmod +x ./HelloWorld. You can now run the app by simply executing HelloWorld.

Running on Linux with runtime installed second way


Awesome isn't it?



Categories: .NET (3)

Comments

Posts By Year

2020 (9)
2019 (6)
2018 (8)
2017 (11)
2016 (6)
2015 (18)
2014 (2)
2013 (4)
2012 (2)

Posts By Category

.NET (3)
.NET Core (2)
ASP.NET MVC (4)
AWS API Gateway (1)
Android (1)
Architecture (1)
Azure (2)
Book review (3)
Business (1)
C# (3)
C++ (1)
Containers (3)
Corporate culture (1)
Database (3)
Database migration (1)
Desktop (1)
DotNet (2)
Entity Framework (3)
Git (2)
IIS (1)
JDBC (1)
Java (5)
Life (6)
Linux (1)
Lucene (1)
Multi-threading (1)
OData (1)
Office (1)
PHP (1)
PowerShell (2)
Programming (22)
Rants (5)
SQL (2)
SQL Server (1)
Software Engineering (1)
Software development (1)
Solr (1)
Sql Server (2)
Storage (1)
T-SQL (1)
TDD (1)
TSQL (5)
Tablet (1)
Technology (1)
Test Driven (1)
Unit Testing (1)
Unit Tests (1)
Utilities (2)
VC++ (1)
VMWare (1)
VSCode (1)
Visual Studio (2)
Wallpapers (1)
Windows (9)
XML (2)

Posts By Tags

.NET(5) API Gateway(1) ASP.NET(4) AWS(1) Adults(1) Advertising(1) Android(1) Anti-forgery(1) Azure(2) Backup(1) Beliefs(1) BlockingQueue(1) Book review(2) Books(1) Busy(1) C#(4) C++(3) CLR(1) CORS(1) CSRF(1) CTE(1) Callbacks(1) Checkbox(1) Cmdlet(1) Commons(1) Company culture(1) Complexity(1) Consumer(1) Consumerism(1) Containers(3) Core(2) DPI(1) Data-time(1) Database(4) Debugging(1) Delegates(1) Developer(2) Dockers(2) DotNetCore(3) EF 1.0(1) Entity framework(1) Events(1) File copy(1) File history(1) Font(1) Git(2) GradleApache(1) HierarchyID(1) IIS(1) Installing(1) Intelli J(1) JDBC(1) JSON(1) JUnit(1) Java(1) JavaScript(1) Linux(1) Localization(1) Log4J(1) Lucene(1) MVC(4) Management(2) Migration history(1) Mobile Apps(1) Modern Life(1) Money(1) NUnit(1) OData(1) OPENXML(1) Objects(1) Office(1) Organization(1) PHP(1) Paths(1) PowerShell(2) Producer(1) Programming(1) Python(1) Quality(1) REDIS(2) Runtimes(1) SD card(1) SQL(2) SQL Code-first Migration(1) SSH(1) Sattelite assemblies(1) School(1) Self reliance(1) Shell(1) Solr(1) Sony VAIO(1) Spirituality(1) Sql Express(1) System Image(1) TDD(1) TSQL(3) Table variables(1) Tables(1) Tablet(1) Url rewrite(1) VMWare(1) VSCode(1) Validation(2) Wallpaper(1) Wallpapers(1) Web Development(4) Windows(2) Windows 10(2) Windows 2016(2) Windows 8.1(1) Work culture(1) XML(1) Yii(1)