How to check the OS version at runtime, e.g. on Windows or Linux, without using a conditional compilation statement

Question

How do I determine what platform my C# code is running on? for example whether it is running on Linux or windows so that I can execute different code at runtime.

I have a C# Windows application that I want to build to target Windows and Linux platforms.

So far I have created two project files pointing to the same set of source code files. I then use a conditional compilation statement one of the projects called LINUX.

Where there are difference in the actual code I use conditional statements using the conditional compilation statement, for example,

#if (LINUX)
    ' Do something
#endif

Is there a better way of doing this? I don't really want to have two project files.

score 177 · Answer 1 · edited Jan 28 '20 at 15:38

177

I found this recommendation on one of Microsoft's blogs:

We recommend you to use RuntimeInformation.IsOSPlatform() for platform checks.

Reference: Announcing the Windows Compatibility Pack for .NET Core

IsOSPlatform() takes an argument of types OSPlatform which has three values by default: Windows, Linux and OSX. It can be used as follow:

if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
  // Do something
}

The API is part of .NET Standard 2.0, and therefore available in .NET Core 2.0 and .NET Framework 4.7.1.

edited Jan 28 '20 at 15:38

Peter Mortensen

30,738
21
105
131

answered Nov 20 '17 at 10:53

Alex Sanséau

8,250
5
20
25

https://www.nuget.org/packages/System.Runtime.InteropServices.RuntimeInformation/ for many more platforms. – Cameron Taggart May 24 '19 at 17:11
12

Don't forget `using System.Runtime.InteropServices;` – Eduardo Pignatelli Aug 23 '19 at 08:27
1

There is also a fourth option now, [`FreeBSD`](https://learn.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.osplatform.freebsd#System_Runtime_InteropServices_OSPlatform_FreeBSD). – Peter Mortensen Jan 28 '20 at 15:35
1

Worked for .NET 5. :) – Naveen Kumar V Mar 25 '21 at 18:57

score 87 · Accepted Answer · edited Jun 20 '20 at 09:12

[Editor's Note: This answer was applicable before .NET 4.7.1, or before the Windows Compatibility Pack for .NET Core was released. The current best answer is Alex Sanséau's to Stack Overflow question How to check the OS version at runtime, e.g. on Windows or Linux, without using a conditional compilation statement.]

You can detect the execution platform using System.Environment.OSVersion.Platform:

public static bool IsLinux
{
    get
    {
        int p = (int) Environment.OSVersion.Platform;
        return (p == 4) || (p == 6) || (p == 128);
    }
}

From the Mono FAQ:

How to detect the execution platform

The execution platform can be detected by using the System.Environment.OSVersion.Platform value. However correctly detecting Unix platforms, in every cases, requires a little more work. The first versions of the framework (1.0 and 1.1) didn't include any PlatformID value for Unix, so Mono used the value 128. The newer framework 2.0 added Unix to the PlatformID enum but, sadly, with a different value: 4 and newer versions of .NET distinguished between Unix and macOS, introducing yet another value 6 for macOS.

This means that in order to detect properly code running on Unix platforms you must check the three values (4, 6 and 128). This ensure that the detection code will work as expected when executed on Mono CLR 1.x runtime and with both Mono and Microsoft CLR 2.x runtimes.

That was 2011, today the correct answer is RuntimeInformation.IsOSPlatform(), as suggested by @Alex — patrikbeno, Dec 05 '18 at 22:36
Shorter: public static bool IsLinux => (int) Environment.OSVersion.Platform is 4 or 6 or 128; — Joscha Götzer, Jun 02 '21 at 10:08

score 24 · Answer 3 · answered Jun 30 '22 at 12:09

24

.NET 5+ has the OperatingSystem class, so now you can just:

if (OperatingSystem.IsWindows())
    DoSomething();

answered Jun 30 '22 at 12:09

Jony Adamit

3,178
35
44

score 16 · Answer 4 · edited Jan 28 '20 at 15:40

There isn't any such method, but you can use this method that checks it conditionally:

    public static OSPlatform GetOperatingSystem()
    {
        if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
        {
            return OSPlatform.OSX;
        }

        if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
        {
            return OSPlatform.Linux;
        }

        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
        {
            return OSPlatform.Windows;
        }

        throw new Exception("Cannot determine operating system!");
    }

score 12 · Answer 5 · edited Jan 28 '20 at 15:26

12

Use:

System.Environment.OSVersion

edited Jan 28 '20 at 15:26

Peter Mortensen

30,738
21
105
131

answered Feb 25 '11 at 12:04

Andreas Ågren

3,879
24
33

score 3 · Answer 6 · edited Sep 09 '16 at 12:18

3

You can use System.Environment.OSVersion to check what kind of platform you're on at runtime.

edited Sep 09 '16 at 12:18

AlG

14,697
4
41
54

answered Feb 25 '11 at 12:05

Samuel Otter

608
3
7

1

No, you can't, because it returns true for Unix/Linux if you're on Mac, and true for Mac if you're on Unix/Linux... – Stefan Steiger Mar 10 '19 at 21:05

score 2 · Answer 7 · edited Jan 28 '20 at 15:27

To expand on other answers, in cases where a Linux and Windows implementation of a feature are not compatible (that is, require references to libraries only available for a specific platform), you can also use an interface and have two separate assemblies, one written and compiled on each platform, with a type that implements this interface.

Then, based on the check, use Assembly.Load() to load only the right assembly (and its platform-specific dependency), reflection to find your type in the assembly, and Activator.CreateInstance() to get an instance of the type that you can then work with normally.

score 1 · Answer 8 · answered Sep 15 '21 at 09:37

1

Built-in static method: System.Runtime.Serialization.OperatingSystem.IsLinux().

answered Sep 15 '21 at 09:37

Dixin

61
1
5

score 0 · Answer 9 · edited Jan 28 '20 at 15:40

0

One more option is to use Process to call a shell script to get the uname, as follows:

Process p = new Process {
  StartInfo = {
    UseShellExecute        = false,
    RedirectStandardOutput = true,
    FileName               = "uname",
    Arguments              = "-s"
  }
};
p.Start();
string uname = p.StandardOutput.ReadToEnd().Trim();

if (uname == "Darwin") {
  // OS X
} else {
  // ...
}

edited Jan 28 '20 at 15:40

Peter Mortensen

30,738
21
105
131

answered Mar 26 '19 at 04:41

Zane Claes

14,732
15
74
131

1

This does not work for Windows. – Catalin Sep 12 '22 at 13:38

score 0 · Answer 10 · answered Aug 30 '21 at 17:08

0

OperatingSystem os = new OperatingSystem(System.Environment.OSVersion.Platform, new Version());
Console.WriteLine(os.ToString());

answered Aug 30 '21 at 17:08

Ahmed Naeem

90
6

Please provide explanation about your code that how can this solve the problem. – akash Aug 31 '21 at 03:02
It just simply return you a string, the name of the operating system. I don't think so any explanation is needed so far. – Ahmed Naeem Aug 31 '21 at 13:06
the Vesrion() class represents the assembly version of your CLR – Ahmed Naeem Aug 31 '21 at 13:07

score -1 · Answer 11 · answered Mar 31 '23 at 10:55

With the help of TimeZoneConverter libraryable to map the google timezone with the windows time zone. This library has support for windows and Linux and most of the systems.

using TimeZoneConverter;
//Convert Google's Time zone Id into Standard Time Zone name using TimeZoneConvertor library's method named 'GetTimeZoneInfo'
Input : Asia/Hong_Kong 
Output : China Standard Time
TimeZoneInfo tz = TZConvert.GetTimeZoneInfo(timeZoneId);

How to check the OS version at runtime, e.g. on Windows or Linux, without using a conditional compilation statement

11 Answers11

Linked

Related