C# preprocessor differentiate between operating systems

Question

Is it possible to differentiate between operating systems in C# using preprocessor? like :

#if OS_WINDOWS
//windows methods
#elif OS_MAC
//mac  methods
#elif OS_LINUX
//linux methods
#endif

Distinctly

The whole point of C# is that you don't need to recompile for different platforms. – Sporocyst

But you might need to configure things differently. If both configuration values are in the settings file, you need to know which one to use. – Silencer

Answer 1

What you are asking for is possible but needs a bit of work.

1. Define a preprocessor variable in your csproj

   <PropertyGroup Condition=" '$(OS)' == 'Windows_NT' ">
     <DefineConstants>_WINDOWS</DefineConstants>
   </PropertyGroup>
   

2. Use that in your code

   #if _WINDOWS
     // your windows stuff
   #else
     // your *nix stuff
   #endif
   

I find this technique useful when you have constants that are dependent on the OS (for example native library names)

Aboveground

Answer 2

No. Sadly you can't. And it is even logical: if you compile for AnyCPU, then your program is executable on any platform.

What you can do is create multiple project configurations, where you set the #define you want (in the Properties of the project, Build, Conditional compilation symbols).

But perhaps this is a XY problem... Normally you don't need to do it, and you can live with a

if (Environment.OSVersion.Platform == PlatformID.Win32NT)
{

}
else if (Environment.OSVersion.Platform == PlatformID.MacOSX)
{

}
else if (Environment.OSVersion.Platform == PlatformID.Unix)
{

}

Deni

This leaves PlatformID.Win32NT though – Kline

Answer 3

Since MSBuild 15, there is a property function: IsOSPlatform().

It can be used to define OS-specific constants in the project file (*.csproj):

<PropertyGroup Condition="$([MSBuild]::IsOSPlatform('Windows'))">
  <DefineConstants>OS_WINDOWS</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition="$([MSBuild]::IsOSPlatform('Linux'))">
  <DefineConstants>OS_LINUX</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition="$([MSBuild]::IsOSPlatform('FreeBSD'))">
  <DefineConstants>OS_FREEBSD</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition="$([MSBuild]::IsOSPlatform('OSX'))">
  <DefineConstants>OS_MAC</DefineConstants>
</PropertyGroup>

These constants can be checked in preprocessor directives, for example:

#if OS_WINDOWS
  // Windows-specific code
#elif OS_LINUX
  // Linux-specific code
#elif OS_FREEBSD
  // FreeBSD-specific code
#elif OS_MAC
  // Mac-specific code
#endif

Philodendron

I tried this, specifically the OS_WINDOWS is what I needed for certain features I want available only on windows. It worked perfectly when I build for windows, but publishing to other platforms such as Linux fails with this output "We were unable to determine the cause of the error", any idea why or how to fix it? – Quanta

@DavidShnayder I use this on Windows 10 and Debian 11.4 with .NET 6, and it works. – Philodendron

@DavidShnayder First, I would remove the problematic preprocessor directives and apply their effect manually (add/remove the affected parts of the code). If you don't find the problem this way, you can try the '$(OS)' == 'Windows_NT' condition instead of the IsOSPlatform-based approach. – Philodendron

Based on the docs, it looks like the platform string for Mac is MacOS, not OSX. – Fabianfabianism

Answer 4

As of 2023 the recommended way to safeguard OS specific code at run time is to use OperatingSystem class:

if (OperatingSystem.IsLinux()) // standard guard examples
{
    LinuxOnlyApi();
}

Amazement

Answer 5

No - think about it, the compiler runs once, but the same binary output can be used on multiple machines.

Now you can specify any symbols you want when you compile - so you could easily compile three different times and pass in different preprocessor symbols each time.

If you don't need any compile-time changes, you can just use Environment.OSVersion to detect the operating system you're running under.

Felecia

what if I need compile time changes ? let say I do not want my windows setup contains linux related binaries and vice versa. At the same time I do not want to use reflection. Ideally I'd like to use smth like multitargeting and conditional references in csproj file(based on RID) – Yeti

@isxaker: I don't know whether you can specify different preprocessor symbols for different runtimes (as opposed to different target frameworks). I guess you could have (say) net6-windows TFM and separately net6-linux... – Felecia

that is the point - there's no net6-linux in contrast to net6-windows ) – Yeti

@isxaker: I guess you could use conditionally say "net6.0 but not net6.0-windows"? It feels like really it's worth asking a new question with a lot more detail about what you're trying to achieve. – Felecia