Expose static methods from System.OperatingSystem

src/Build.UnitTests/Evaluation/Expander_Tests.cs

@@ -2806,6 +2806,38 @@ public void PropertyFunctionRuntimeInformation(string propertyFunction, string e
             Assert.Equal(expectedExpansion, result);
         }
 
+        [WindowsFullFrameworkOnlyTheory]
+        [InlineData("windows")]
+        [InlineData("linux")]
+        [InlineData("macos")]
+        [InlineData("osx")]
+        public void IsOSPlatformFullFramework(string platform)
+        {
+            string propertyFunction = $"$([System.OperatingSystem]::IsOSPlatform('{platform}'))";
+            string expected = platform.Equals("windows", StringComparison.OrdinalIgnoreCase) ? "True" : "False";
+            var pg = new PropertyDictionary<ProjectPropertyInstance>();
+            var expander = new Expander<ProjectPropertyInstance, ProjectItemInstance>(pg, FileSystems.Default);
+            expander.ExpandIntoStringLeaveEscaped(propertyFunction, ExpanderOptions.ExpandProperties, MockElementLocation.Instance).ShouldBe(expected);
+        }
+
+        [DotNetOnlyTheory]
+        [InlineData("windows")]
+        [InlineData("linux")]
+        [InlineData("macos")]
+        [InlineData("osx")]
+        public void IsOSPlatformDotNet(string platform)
+        {
+            string propertyFunction = $"$([System.OperatingSystem]::IsOSPlatform('{platform}'))";
+            bool result = false;
+#if NET5_0_OR_GREATER
+            result = System.OperatingSystem.IsOSPlatform(platform);
+#endif
+            string expected = result ? "True" : "False";
+            var pg = new PropertyDictionary<ProjectPropertyInstance>();
+            var expander = new Expander<ProjectPropertyInstance, ProjectItemInstance>(pg, FileSystems.Default);
+            expander.ExpandIntoStringLeaveEscaped(propertyFunction, ExpanderOptions.ExpandProperties, MockElementLocation.Instance).ShouldBe(expected);
+        }
+
         [Theory]
         [InlineData("AString", "x12x456789x11", "$(AString.IndexOf('x', 1))", "3")]
         [InlineData("AString", "x12x456789x11", "$(AString.IndexOf('x45', 1))", "3")]

src/Build/Resources/Constants.cs

@@ -365,6 +365,14 @@ private static void InitializeAvailableMethods()
                         availableStaticMethods.TryAdd("Microsoft.Build.Utilities.ToolLocationHelper", new Tuple<string, Type>("Microsoft.Build.Utilities.ToolLocationHelper, Microsoft.Build.Utilities.Core, Version=" + MSBuildConstants.CurrentAssemblyVersion + ", Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", null));
                         availableStaticMethods.TryAdd("System.Runtime.InteropServices.RuntimeInformation", runtimeInformationType);
                         availableStaticMethods.TryAdd("System.Runtime.InteropServices.OSPlatform", osPlatformType);
+#if NET5_0_OR_GREATER
+                        availableStaticMethods.TryAdd("System.OperatingSystem", new Tuple<string, Type>(null, typeof(OperatingSystem)));
+#else
+                        // Add alternate type for System.OperatingSystem static methods which aren't available on .NET Framework.
+                        var operatingSystemType = new Tuple<string, Type>("Microsoft.Build.Framework.OperatingSystem, Microsoft.Build.Framework, Version=" + MSBuildConstants.CurrentAssemblyVersion + ", Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", null);
+                        availableStaticMethods.TryAdd("System.OperatingSystem", operatingSystemType);
+                        availableStaticMethods.TryAdd("Microsoft.Build.Framework.OperatingSystem", operatingSystemType);
+#endif
 
                         s_availableStaticMethods = availableStaticMethods;
                     }

src/Framework.UnitTests/OperatingSystem_Tests.cs

@@ -0,0 +1,57 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Shouldly;
+
+using Xunit;
+using Xunit.NetCore.Extensions;
+
+namespace Microsoft.Build.Framework.UnitTests
+{
+    public class OperatingSystem_Tests
+    {
+#if !NET5_0_OR_GREATER
+        [WindowsFullFrameworkOnlyTheory]
+        [InlineData("windows", true)]
+        [InlineData("linux", false)]
+        [InlineData("macOS", false)]
+        public void IsOSPlatform(string platform, bool expected)
+        {
+            Microsoft.Build.Framework.OperatingSystem.IsOSPlatform(platform).ShouldBe(expected);
+        }
+
+        [WindowsFullFrameworkOnlyTheory]
+        [InlineData("windows", 4, true)]
+        [InlineData("windows", 999, false)]
+        [InlineData("linux", 0, false)]
+        [InlineData("macOS", 0, false)]
+        public void IsOSPlatformVersionAtLeast(string platform, int major, bool expected)
+        {
+            Microsoft.Build.Framework.OperatingSystem.IsOSPlatformVersionAtLeast(platform, major).ShouldBe(expected);
+        }
+
+        [WindowsFullFrameworkOnlyFact]
+        public void IsWindows()
+        {
+            Microsoft.Build.Framework.OperatingSystem.IsWindows().ShouldBeTrue();
+        }
+
+        [WindowsFullFrameworkOnlyFact]
+        public void IsWindowsVersionAtLeast()
+        {
+            Microsoft.Build.Framework.OperatingSystem.IsWindowsVersionAtLeast(4).ShouldBeTrue();
+        }
+
+        [WindowsFullFrameworkOnlyFact]
+        public void IsOtherThanWindows()
+        {
+            Microsoft.Build.Framework.OperatingSystem.IsFreeBSD().ShouldBeFalse();
+            Microsoft.Build.Framework.OperatingSystem.IsFreeBSDVersionAtLeast(0).ShouldBeFalse();
+            Microsoft.Build.Framework.OperatingSystem.IsLinux().ShouldBeFalse();
+            Microsoft.Build.Framework.OperatingSystem.IsMacOS().ShouldBeFalse();
+            Microsoft.Build.Framework.OperatingSystem.IsMacOSVersionAtLeast(0).ShouldBeFalse();
+            Microsoft.Build.Framework.OperatingSystem.IsOSXLike().ShouldBeFalse();
+        }
+#endif
+    }
+}

src/Framework/OperatingSystem.cs

@@ -0,0 +1,66 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#if !NET5_0_OR_GREATER
+
+using System;
+
+namespace Microsoft.Build.Framework
+{
+    /// <summary>
+    /// System.OperatingSystem static methods were added in net5.0.
+    /// This class creates stand-in methods for net472 builds.
+    /// Assumes only Windows is supported.
+    /// </summary>
+    internal static class OperatingSystem
+    {
+        public static bool IsOSPlatform(string platform)
+        {
+            return platform?.Equals("WINDOWS", StringComparison.OrdinalIgnoreCase) ?? throw new ArgumentNullException(nameof(platform));
+        }
+
+        public static bool IsOSPlatformVersionAtLeast(string platform, int major, int minor = 0, int build = 0, int revision = 0)
+            => IsOSPlatform(platform) && IsOSVersionAtLeast(major, minor, build, revision);
+
+        public static bool IsLinux() => false;
+
+        public static bool IsFreeBSD() => false;
+
+        public static bool IsFreeBSDVersionAtLeast(int major, int minor = 0, int build = 0, int revision = 0) => false;
+
+        public static bool IsMacOS() => false;
+
+        public static bool IsOSXLike() => false;
+
+        public static bool IsMacOSVersionAtLeast(int major, int minor = 0, int build = 0) => false;
+
+        public static bool IsWindows() => true;
+
+        public static bool IsWindowsVersionAtLeast(int major, int minor = 0, int build = 0, int revision = 0)
+            => IsWindows() && IsOSVersionAtLeast(major, minor, build, revision);
+
+        private static bool IsOSVersionAtLeast(int major, int minor, int build, int revision)
+        {
+            Version current = Environment.OSVersion.Version;
+
+            if (current.Major != major)
+            {
+                return current.Major > major;
+            }
+
+            if (current.Minor != minor)
+            {
+                return current.Minor > minor;
+            }
+
+            if (current.Build != build)
+            {
+                return current.Build > build;
+            }
+
+            return current.Revision >= revision;
+        }
+    }
+}
+#endif
+