1. net-core-cross-platform-development

Cross-platform development - .NET Core Tutorial

Cross-platform development is becoming increasingly popular in today's software development world. Developers want to write code that can work across different platforms, including Windows, Linux, and macOS. .NET Core is a free and open-source, cross-platform, and optimized version of the .NET Framework. In this tutorial, we will explore cross-platform development using .NET Core.


Before we begin, make sure that you have the following installed on your machine:

  • .NET Core SDK
  • An IDE of your choice (Visual Studio Code, Visual Studio, JetBrains Rider)

Creating a .NET Core Project

To create a .NET Core project, follow these steps:

  1. Open your command prompt or terminal and create a new directory for your project.

  2. Navigate to the directory and run the following command:

    dotnet new console -n MyProject

    This creates a new .NET Core console app project named MyProject.

  3. After the project is created, navigate to its directory and run the following command:

    dotnet run

    This should build and run the project, and you should see the "Hello World!" message on your console output.

Writing Cross-Platform Code

When writing cross-platform code, it is important to consider the differences in file paths, environment variables, and other system-specific factors. The .NET Core platform provides a simple way to handle these differences. You can use the Path.Combine() method to combine file paths in a platform-independent way.

Here's an example of how to use it:

string path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "Documents", "MyFile.txt");

This creates a file path that points to MyFile.txt in the user's "Documents" folder, regardless of which platform the code is running on.

Compiling and Running Cross-Platform Code

To compile and run your .NET Core code, you can use the dotnet command-line tools. Here are some useful commands:

  • dotnet build - This command builds the project.
  • dotnet run - This command builds and runs the project.
  • dotnet test - This command runs the tests in your project.

Using .NET Core with Docker

Docker is a platform that allows developers to build, deploy, and run applications in a containerized environment. .NET Core supports Docker, which makes it easy to create and package cross-platform applications.

Here's an example of how to use .NET Core with Docker:

  1. Create a Dockerfile in your project directory that looks like this:

    FROM AS build-env
    WORKDIR /app
    # Copy the project file
    COPY *.csproj ./
    # Restore packages
    RUN dotnet restore
    # Copy the rest of the files
    COPY . ./
    # Build the app
    RUN dotnet publish -c Release -o out
    # Build the runtime image
    WORKDIR /app
    COPY --from=build-env /app/out ./
    # Start the app
    ENTRYPOINT ["dotnet", "MyProject.dll"]
  2. Build the Docker image:

    docker build -t myproject .

    This command builds an image from the Dockerfile in your project directory and tags it as myproject.

  3. Run the Docker container:

    docker run --rm myproject

    This command runs a container from the myproject image and removes the container automatically after the program has run.


In this tutorial, we learned how to create and run a .NET Core project, write cross-platform code, and use .NET Core with Docker. With .NET Core, you can write code that works seamlessly across different platforms and environments.

Published on: