CODEWITHSUNDEEP
c#cross-platformc-preprocessor
Abanoub
Abanoub

Reputation: 3809

C# preprocessor differentiate between operating systems

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

Upvotes: 46

Views: 16873

Answers (6)

Alex
Alex

Reputation: 5167

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

// An API supported only on Linux.
[SupportedOSPlatform("linux")]
public void LinuxOnlyApi() { }

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

Upvotes: 6

Nir
Nir

Reputation: 2082

If you want your code to change based on runtime identifier, you can do as follows:

<PropertyGroup>
  <TargetFrameworks>net6.0</TargetFrameworks>
  <OutputType>WinExe</OutputType>
  <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
  <PlatformTarget>x64</PlatformTarget>
  <RuntimeIdentifier>win-x64</RuntimeIdentifier>
</PropertyGroup>
<PropertyGroup Condition="$(RuntimeIdentifier.StartsWith('win'))">
  <DefineConstants>OS_WINDOWS</DefineConstants>
</PropertyGroup>
<PropertyGroup Condition="$(RuntimeIdentifier.StartsWith('linux'))">
  <DefineConstants>OS_LINUX</DefineConstants>
</PropertyGroup>

Afterwards, you can use the ifdefs, for example

#if OS_WINDOWS
(your code)
#endif

Upvotes: 0

kol
kol

Reputation: 28728

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

Upvotes: 25

xanatos
xanatos

Reputation: 111940

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)
{

}

Upvotes: 19

Candide Guevara Marino
Candide Guevara Marino

Reputation: 2352

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)

Upvotes: 64

Jon Skeet
Jon Skeet

Reputation: 1503220

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.

Upvotes: 2

Related Questions