port to .NET Standard 2.0

src/BenchmarkDotNet.Core/BenchmarkDotNet.Core.csproj

@@ -2,7 +2,7 @@
   <Import Project="..\..\build\common.props" />
   <PropertyGroup>
     <AssemblyTitle>BenchmarkDotNet.Core</AssemblyTitle>
-    <TargetFrameworks>net46;netcoreapp1.1;netcoreapp2.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0</TargetFrameworks>
     <NoWarn>$(NoWarn);1591</NoWarn>
     <AssemblyName>BenchmarkDotNet.Core</AssemblyName>
     <PackageId>BenchmarkDotNet.Core</PackageId>
@@ -25,23 +25,18 @@
     <ProjectReference Include="..\BenchmarkDotNet.Disassembler.x86\BenchmarkDotNet.Disassembler.x86.csproj">
       <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
     </ProjectReference>
-    <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.3.0" />
-    <Reference Include="System.Management" />
-    <Reference Include="System.Xml" />
-    <Reference Include="System" />
-    <Reference Include="Microsoft.CSharp" />
-  </ItemGroup>
-  <ItemGroup Condition=" '$(TargetFrameworkIdentifier)' == '.NETCoreApp' ">
-    <PackageReference Include="System.Runtime.Serialization.Primitives" Version="4.3.0" />
-    <PackageReference Include="System.Xml.XPath.XmlDocument" Version="4.3.0" />
-    <PackageReference Include="System.Reflection.Emit.Lightweight" Version="4.3.0" />
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="Microsoft.DotNet.InternalAbstractions" Version="1.0.0" />
     <PackageReference Include="Microsoft.DotNet.PlatformAbstractions" Version="1.1.1" />
     <PackageReference Include="Microsoft.Win32.Registry" Version="4.3.0" />
+    <PackageReference Include="System.Management" Version="4.5.0-preview1-26216-02" />
     <PackageReference Include="System.ValueTuple" Version="4.3.0" />
     <PackageReference Include="System.Xml.XmlSerializer" Version="4.3.0" />
     <PackageReference Include="System.Diagnostics.FileVersionInfo" Version="4.3.0" />
+    <PackageReference Include="System.Runtime.Serialization.Primitives" Version="4.3.0" />
+    <PackageReference Include="System.Xml.XPath.XmlDocument" Version="4.3.0" />
+    <PackageReference Include="System.Reflection.Emit.Lightweight" Version="4.3.0" />
+    <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.3.0" />
   </ItemGroup>
 </Project>

src/BenchmarkDotNet.Core/Code/CodeGenerator.cs

@@ -191,12 +191,10 @@ private static string GetPassArguments(Benchmark benchmark)
 
         private static string GetExtraAttributes(Target target)
         {
-#if !NETCOREAPP1_1
             if (target.Method.GetCustomAttributes(false).OfType<System.STAThreadAttribute>().Any())
             {
                 return "[System.STAThreadAttribute]";
             }
-#endif
 
             return string.Empty;
         }

src/BenchmarkDotNet.Core/Diagnosers/DiagnosersLoader.cs

@@ -32,11 +32,12 @@ internal static IDiagnoser GetImplementation<TDiagnoser, TConfig>(TConfig config
 
         private static IDiagnoser[] LoadDiagnosers()
         {
-#if CLASSIC
-            return RuntimeInformation.IsMono() ? LoadMono() : LoadClassic();
-#else
+            if (RuntimeInformation.IsMono)
+                return LoadMono();
+            if (RuntimeInformation.IsFullFramework)
+                return LoadClassic();
+
             return LoadCore();
-#endif
         }
 
         private static IDiagnoser[] LoadCore() => new IDiagnoser[] { MemoryDiagnoser.Default };
@@ -49,7 +50,6 @@ private static IDiagnoser[] LoadMono()
                 DisassemblyDiagnoser.Create(new DisassemblyDiagnoserConfig()), 
             }; 
 
-#if CLASSIC
         private static IDiagnoser[] LoadClassic()
         {
             try
@@ -107,6 +107,5 @@ private static Assembly LoadDiagnosticsAssembly(Assembly benchmarkDotNetCoreAsse
 
         private static IDiagnoser CreateDiagnoser(Assembly loadedAssembly, string typeName)
             => (IDiagnoser)Activator.CreateInstance(loadedAssembly.GetType(typeName));
-#endif
     }
 }

src/BenchmarkDotNet.Core/Diagnosers/DisassemblyDiagnoser.cs

@@ -89,7 +89,7 @@ public IEnumerable<ValidationError> Validate(ValidationParameters validationPara
         }
 
         private bool ShouldUseMonoDisassembler(Benchmark benchmark)
-            => benchmark.Job.Env.Runtime is MonoRuntime || RuntimeInformation.IsMono();
+            => benchmark.Job.Env.Runtime is MonoRuntime || RuntimeInformation.IsMono;
 
         private bool ShouldUseWindowsDissasembler(Benchmark benchmark)
             => !(benchmark.Job.Env.Runtime is MonoRuntime) && RuntimeInformation.IsWindows();

src/BenchmarkDotNet.Core/Diagnosers/MemoryDiagnoser.cs

@@ -58,7 +58,7 @@ public class AllocationColumn : IColumn
             public bool IsDefault(Summary summary, Benchmark benchmark) => false;
 
             public bool IsAvailable(Summary summary) 
-                => !RuntimeInformation.IsMono() || results.Keys.Any(benchmark => !(benchmark.Job.Env.Runtime is MonoRuntime));
+                => !RuntimeInformation.IsMono || results.Keys.Any(benchmark => !(benchmark.Job.Env.Runtime is MonoRuntime));
 
             public bool AlwaysShow => true;
             public ColumnCategory Category => ColumnCategory.Diagnoser;

src/BenchmarkDotNet.Core/Diagnosers/MonoDisassembler.cs

@@ -25,7 +25,7 @@ internal MonoDisassembler(DisassemblyDiagnoserConfig config)
 
         internal DisassemblyResult Disassemble(Benchmark benchmark, MonoRuntime mono)
         {
-            Debug.Assert(mono == null || !RuntimeInformation.IsMono(), "Must never be called for Non-Mono benchmarks");
+            Debug.Assert(mono == null || !RuntimeInformation.IsMono, "Must never be called for Non-Mono benchmarks");
 
             var benchmarkTarget = benchmark.Target;
             string fqnMethod = GetMethodName(benchmarkTarget);

src/BenchmarkDotNet.Core/Diagnosers/UnresolvedDiagnoser.cs

@@ -4,21 +4,14 @@
 using BenchmarkDotNet.Engines;
 using BenchmarkDotNet.Exporters;
 using BenchmarkDotNet.Loggers;
-using BenchmarkDotNet.Reports;
+using BenchmarkDotNet.Portability;
 using BenchmarkDotNet.Running;
 using BenchmarkDotNet.Validators;
 
 namespace BenchmarkDotNet.Diagnosers
 {
     public class UnresolvedDiagnoser : IDiagnoser
     {
-        private const string ErrorMessage =
-#if CLASSIC
-            "Please make sure that you have installed the latest BenchmarkDotNet.Diagnostics.Windows package.";
-#else
-            "To use the classic Windows diagnosers for .NET Core you need to run the benchmarks for desktop .NET. More info: http://adamsitnik.com/Hardware-Counters-Diagnoser/#how-to-get-it-running-for-net-coremono-on-windows";
-#endif
-
         private readonly Type unresolved;
 
         public UnresolvedDiagnoser(Type unresolved) => this.unresolved = unresolved;
@@ -36,6 +29,9 @@ public void ProcessResults(DiagnoserResults results) { }
         public IEnumerable<ValidationError> Validate(ValidationParameters validationParameters)
             => new[] { new ValidationError(false, GetErrorMessage()) };
 
-        private string GetErrorMessage() => $"Unable to resolve {unresolved.Name} diagnoser. {ErrorMessage}";
+        private string GetErrorMessage() => $@"Unable to resolve {unresolved.Name} diagnoser. 
+            {(RuntimeInformation.IsFullFramework 
+                ? "Please make sure that you have installed the latest BenchmarkDotNet.Diagnostics.Windows package." 
+                : "To use the classic Windows diagnosers for .NET Core you need to run the benchmarks for desktop .NET. More info: http://adamsitnik.com/Hardware-Counters-Diagnoser/#how-to-get-it-running-for-net-coremono-on-windows")}";
     }
 }

src/BenchmarkDotNet.Core/Diagnosers/WindowsDisassembler.cs

@@ -11,7 +11,6 @@
 using BenchmarkDotNet.Loggers;
 using System.Linq;
 using System.Text;
-using BenchmarkDotNet.Engines;
 
 namespace BenchmarkDotNet.Diagnosers
 {
@@ -150,13 +149,14 @@ public static bool Is64Bit(Process process)
                 if (Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE") == "x86")
                     return false;
 
-#if !NETCOREAPP1_1
-                if (!IsWow64Process(process.Handle, out bool isWow64))
-                    throw new Exception("Not Windows");
-                return !isWow64;
-#else
-                return System.IntPtr.Size == 8; // todo: find the way to cover all scenarios for .NET Core
-#endif
+                if (Portability.RuntimeInformation.IsWindows())
+                {
+                    IsWow64Process(process.Handle, out bool isWow64);
+
+                    return !isWow64;
+                }
+
+                return IntPtr.Size == 8; // todo: find the way to cover all scenarios for .NET Core
             }
 
             [DllImport("kernel32.dll", SetLastError = true, CallingConvention = CallingConvention.Winapi)]

src/BenchmarkDotNet.Core/Engines/Engine.cs

@@ -195,12 +195,11 @@ private void ForceGcCollect()
 
         private void EnableMonitoring()
         {
-#if CLASSIC
-            if (RuntimeInformation.IsMono()) // Monitoring is not available in Mono, see http://stackoverflow.com/questions/40234948/how-to-get-the-number-of-allocated-bytes-in-mono
+            if (RuntimeInformation.IsMono) // Monitoring is not available in Mono, see http://stackoverflow.com/questions/40234948/how-to-get-the-number-of-allocated-bytes-in-mono
                 return;
 
-            AppDomain.MonitoringIsEnabled = true;
-#endif
+            if (RuntimeInformation.IsFullFramework)
+                AppDomain.MonitoringIsEnabled = true;
         }
 
         [UsedImplicitly]

src/BenchmarkDotNet.Core/Engines/GcStats.cs

@@ -120,20 +120,19 @@ public static GcStats FromForced(int forcedFullGarbageCollections)
 
         private static long GetAllocatedBytes()
         {
-            if (RuntimeInformation.IsMono()) // Monitoring is not available in Mono, see http://stackoverflow.com/questions/40234948/how-to-get-the-number-of-allocated-bytes-
+            if (RuntimeInformation.IsMono) // Monitoring is not available in Mono, see http://stackoverflow.com/questions/40234948/how-to-get-the-number-of-allocated-bytes-
                 return 0;
 
             // "This instance Int64 property returns the number of bytes that have been allocated by a specific 
             // AppDomain. The number is accurate as of the last garbage collection." - CLR via C#
             // so we enforce GC.Collect here just to make sure we get accurate results
             GC.Collect();
-#if NETCOREAPP1_1
+
+            if (RuntimeInformation.IsFullFramework)
+                return AppDomain.CurrentDomain.MonitoringTotalAllocatedMemorySize;
+
+            // https://apisof.net/catalog/System.GC.GetAllocatedBytesForCurrentThread() is not part of the .NET Standard, so we use reflection to call it..
             return GetAllocatedBytesForCurrentThreadDelegate.Invoke();
-#elif NETCOREAPP2_0
-            return GC.GetAllocatedBytesForCurrentThread();
-#elif CLASSIC
-            return AppDomain.CurrentDomain.MonitoringTotalAllocatedMemorySize;
-#endif
         }
 
         private static Func<long> GetAllocatedBytesForCurrentThread()

src/BenchmarkDotNet.Core/Environments/HostEnvironmentInfo.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
-using BenchmarkDotNet.Helpers;
 using BenchmarkDotNet.Horology;
 using BenchmarkDotNet.Loggers;
 using BenchmarkDotNet.Portability;
@@ -92,10 +91,9 @@ public override IEnumerable<string> ToFormattedString()
             yield return CpuInfoFormatter.Format(CpuInfo.Value);
             if (HardwareTimerKind != HardwareTimerKind.Unknown)
                 yield return $"Frequency={ChronometerFrequency}, Resolution={ChronometerResolution}, Timer={HardwareTimerKind.ToString().ToUpper()}";
-#if !CLASSIC
-            if (IsDotNetCliInstalled())
+
+            if (RuntimeInformation.IsNetCore && IsDotNetCliInstalled())
                 yield return $".NET Core SDK={DotNetSdkVersion.Value}";
-#endif
         }
 
         internal bool IsDotNetCliInstalled() => !string.IsNullOrEmpty(DotNetSdkVersion.Value);

src/BenchmarkDotNet.Core/Exporters/Json/SimpleJson.cs

@@ -46,7 +46,7 @@
 
 // original json parsing code from http://techblog.procurios.nl/k/618/news/view/14605/14863/How-do-I-write-my-own-parser-for-JSON.html
 
-#if NETFX_CORE || CORE
+#if NETFX_CORE
 #define SIMPLE_JSON_TYPEINFO
 #endif
 

src/BenchmarkDotNet.Core/Extensions/CommonExtensions.cs

@@ -89,10 +89,8 @@ public static string GetColumnTitle(this IColumn column, ISummaryStyle style)
 
         public static bool IsOneOf<T>(this T value, params T[] values) => values.Contains(value);
 
-#if !NETCOREAPP2_0 //  this method was added to the .NET Core 2.0 framework itself ;)
         public static TValue GetValueOrDefault<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key)
             => dictionary.TryGetValue(key, out TValue value) ? value : default;
-#endif
 
         public static double Sqr(this double x) => x * x;
         public static double Pow(this double x, double k) => Math.Pow(x, k);

src/BenchmarkDotNet.Core/Extensions/ProcessExtensions.cs

@@ -100,15 +100,11 @@ public static bool TrySetAffinity(
 
         internal static void SetEnvironmentVariables(this ProcessStartInfo start, Benchmark benchmark, IResolver resolver)
         {
-#if !NETCOREAPP1_1 // ProcessStartInfo.EnvironmentVariables is avaialable for .NET Core 2.0+
             if (!benchmark.Job.HasValue(InfrastructureMode.EnvironmentVariablesCharacteristic))
                 return;
 
             foreach (var environmentVariable in benchmark.Job.Infrastructure.EnvironmentVariables)
-            {
                 start.EnvironmentVariables[environmentVariable.Key] = environmentVariable.Value;
-            }
-#endif
         }
     }
 }

src/BenchmarkDotNet.Core/Extensions/ThreadExtensions.cs

@@ -1,6 +1,4 @@
-#if !NETCOREAPP1_1
-
-using System;
+using System;
 using System.Threading;
 using BenchmarkDotNet.Loggers;
 
@@ -37,4 +35,3 @@ public static bool TrySetPriority(
         }
     }
 }
-#endif

src/BenchmarkDotNet.Core/Helpers/DirtyAssemblyResolveHelper.cs

@@ -1,5 +1,4 @@
-#if CLASSIC
-using BenchmarkDotNet.Loggers;
+using BenchmarkDotNet.Loggers;
 using System;
 using System.IO;
 using System.Reflection;
@@ -61,5 +60,4 @@ private Assembly HelpTheFrameworkToResolveTheAssembly(object sender, ResolveEven
             return Assembly.LoadFrom(guessedPath);
         }
     }
-}
-#endif
+}

src/BenchmarkDotNet.Core/Horology/WindowsClock.cs

@@ -1,7 +1,5 @@
-#if !CORE
 using System.Runtime.ExceptionServices;
 using System.Security;
-#endif
 using System.Runtime.InteropServices;
 
 namespace BenchmarkDotNet.Horology
@@ -19,10 +17,8 @@ internal class WindowsClock : IClock
         [DllImport("kernel32.dll")]
         private static extern bool QueryPerformanceFrequency(out long value);
 
-#if !CORE
         [HandleProcessCorruptedStateExceptions] // #276
         [SecurityCritical]
-#endif
         private static bool Initialize(out long qpf)
         {
             if (!Portability.RuntimeInformation.IsWindows())

src/BenchmarkDotNet.Core/Portability/Cpu/MosCpuInfoProvider.cs

@@ -1,5 +1,4 @@
-#if !CORE
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Management;
@@ -39,5 +38,4 @@ private static CpuInfo Load()
                 logicalCoreCount > 0 ? (int?) logicalCoreCount : null);
         }
     }
-}
-#endif
+}