moving tasks to separate project library, the dll is dynamically loaded

Author: arturcic

src/GitVersion.sln

@@ -34,6 +34,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GitVersionTask", "GitVersio
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GitVersion.Tool", "GitVersionExe\GitVersion.Tool.csproj", "{929263FD-5CD2-42E1-BF3D-E0C1B0320DA4}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GitVersionTask.MsBuild", "GitVersionTask.MsBuild\GitVersionTask.MsBuild.csproj", "{0F1AEC4E-E81D-4F84-B2E8-3415A1A4DBF4}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -68,6 +70,10 @@ Global
 		{929263FD-5CD2-42E1-BF3D-E0C1B0320DA4}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{929263FD-5CD2-42E1-BF3D-E0C1B0320DA4}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{929263FD-5CD2-42E1-BF3D-E0C1B0320DA4}.Release|Any CPU.Build.0 = Release|Any CPU
+		{0F1AEC4E-E81D-4F84-B2E8-3415A1A4DBF4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{0F1AEC4E-E81D-4F84-B2E8-3415A1A4DBF4}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{0F1AEC4E-E81D-4F84-B2E8-3415A1A4DBF4}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{0F1AEC4E-E81D-4F84-B2E8-3415A1A4DBF4}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

src/GitVersionTask.MsBuild/GitVersionTask.MsBuild.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFrameworks>net461;netstandard2.0</TargetFrameworks>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.Build" Version="15.9.20" />
+        <PackageReference Include="Microsoft.Build.Tasks.Core" Version="15.9.20" />
+        <PackageReference Include="Microsoft.DotNet.PlatformAbstractions" Version="2.1.0" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <InternalsVisibleTo Include="GitVersionTask" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\GitVersionCore\GitVersionCore.csproj" />
+    </ItemGroup>
+
+</Project>

src/GitVersionTask/GitVersionTaskBase.cs renamed to src/GitVersionTask.MsBuild/GitVersionTaskBase.cs

@@ -1,4 +1,4 @@
-namespace GitVersionTask
+namespace GitVersionTask.MsBuild
 {
     using Microsoft.Build.Framework;
     using Microsoft.Build.Utilities;

src/GitVersionTask.MsBuild/LibGit2Sharp/GitLoaderContext.cs

@@ -0,0 +1,87 @@
+// This code originally copied from https://raw.githubusercontent.com/dotnet/sourcelink/master/src/Microsoft.Build.Tasks.Git/GitLoaderContext.cs
+#if !NET461
+namespace GitVersionTask.MsBuild.LibGit2Sharp
+{
+    using System;
+    using System.IO;
+    using System.Linq;
+    using System.Reflection;
+    using System.Runtime.InteropServices;
+    using System.Runtime.Loader;
+    using RuntimeEnvironment = Microsoft.DotNet.PlatformAbstractions.RuntimeEnvironment;
+
+    public sealed class GitLoaderContext : AssemblyLoadContext
+    {
+        private readonly string[] assemblies;
+        public static GitLoaderContext Instance { get; private set; }
+
+        private GitLoaderContext(string[] assemblies) => this.assemblies = assemblies;
+
+        public static void Init(params string[] assemblies) => Instance = new GitLoaderContext(assemblies);
+
+        protected override Assembly Load(AssemblyName assemblyName)
+        {
+            if (assemblies.Contains(assemblyName.Name))
+            {
+                var path = Path.Combine(Path.GetDirectoryName(typeof(GitLoaderContext).Assembly.Location), assemblyName.Name + ".dll");
+                return LoadFromAssemblyPath(path);
+            }
+
+            return Default.LoadFromAssemblyName(assemblyName);
+        }
+
+        protected override IntPtr LoadUnmanagedDll(string unmanagedDllName)
+        {
+            var modulePtr = IntPtr.Zero;
+
+            if (unmanagedDllName.StartsWith("git2-", StringComparison.Ordinal) ||
+                unmanagedDllName.StartsWith("libgit2-", StringComparison.Ordinal))
+            {
+                var directory = GetNativeLibraryDirectory();
+                var extension = GetNativeLibraryExtension();
+
+                if (!unmanagedDllName.EndsWith(extension, StringComparison.Ordinal))
+                {
+                    unmanagedDllName += extension;
+                }
+
+                var nativeLibraryPath = Path.Combine(directory, unmanagedDllName);
+                if (!File.Exists(nativeLibraryPath))
+                {
+                    nativeLibraryPath = Path.Combine(directory, "lib" + unmanagedDllName);
+                }
+
+                modulePtr = LoadUnmanagedDllFromPath(nativeLibraryPath);
+            }
+
+            return modulePtr != IntPtr.Zero ? modulePtr : base.LoadUnmanagedDll(unmanagedDllName);
+        }
+
+        private static string GetNativeLibraryDirectory()
+        {
+            var dir = Path.GetDirectoryName(typeof(GitLoaderContext).Assembly.Location);
+            return Path.Combine(dir, "runtimes", RuntimeIdMap.GetNativeLibraryDirectoryName(RuntimeEnvironment.GetRuntimeIdentifier()), "native");
+        }
+
+        private static string GetNativeLibraryExtension()
+        {
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+            {
+                return ".dll";
+            }
+
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+            {
+                return ".dylib";
+            }
+
+            if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+            {
+                return ".so";
+            }
+
+            throw new PlatformNotSupportedException();
+        }
+    }
+}
+#endif

src/GitVersionTask.MsBuild/LibGit2Sharp/LibGit2SharpLoader.cs

@@ -0,0 +1,90 @@
+// This code originally copied and adapted from https://raw.githubusercontent.com/dotnet/sourcelink/master/src/Microsoft.Build.Tasks.Git/TaskImplementation.cs
+
+namespace GitVersionTask.MsBuild.LibGit2Sharp
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Reflection;
+
+    public class LibGit2SharpLoader
+    {
+        private static string taskDirectory;
+
+        public static LibGit2SharpLoader Instance { get; private set; }
+        public Assembly Assembly { get; }
+
+        public static void LoadAssembly(string tasksAssembly) => Instance = new LibGit2SharpLoader(tasksAssembly);
+
+        private LibGit2SharpLoader(string tasksAssembly)
+        {
+            taskDirectory = Path.GetDirectoryName(typeof(LibGit2SharpLoader).Assembly.Location);
+#if NET461
+            nullVersion = new Version(0, 0, 0, 0);
+            loaderLog = new List<string>();
+
+            AppDomain.CurrentDomain.AssemblyResolve += AssemblyResolve;
+
+            var assemblyName = typeof(LibGit2SharpLoader).Assembly.GetName();
+            assemblyName.Name = tasksAssembly;
+            Assembly = Assembly.Load(assemblyName);
+#else
+            var operationsPath = Path.Combine(taskDirectory, tasksAssembly + ".dll");
+            Assembly = GitLoaderContext.Instance.LoadFromAssemblyPath(operationsPath);
+#endif
+        }
+
+        
+#if NET461
+
+        private static Version nullVersion;
+
+        private static List<string> loaderLog;
+
+        private static void Log(ResolveEventArgs args, string outcome)
+        {
+            lock (loaderLog)
+            {
+                loaderLog.Add($"Loading '{args.Name}' referenced by '{args.RequestingAssembly}': {outcome}.");
+            }
+        }
+
+        public static string[] GetLog()
+        {
+            lock (loaderLog)
+            {
+                return loaderLog.ToArray();
+            }
+        }
+
+        private static Assembly AssemblyResolve(object sender, ResolveEventArgs args)
+        {
+            // Limit resolution scope to minimum to affect the rest of msbuild as little as possible.
+            // Only resolve System.* assemblies from the task directory that are referenced with 0.0.0.0 version (from netstandard.dll).
+
+            var referenceName = new AssemblyName(args.Name);
+            if (!referenceName.Name.StartsWith("System.", StringComparison.OrdinalIgnoreCase))
+            {
+                Log(args, "not System");
+                return null;
+            }
+
+            if (referenceName.Version != nullVersion)
+            {
+                Log(args, "not null version");
+                return null;
+            }
+
+            var referencePath = Path.Combine(taskDirectory, referenceName.Name + ".dll");
+            if (!File.Exists(referencePath))
+            {
+                Log(args, $"file '{referencePath}' not found");
+                return null;
+            }
+
+            Log(args, $"loading from '{referencePath}'");
+            return Assembly.Load(AssemblyName.GetAssemblyName(referencePath));
+        }
+#endif
+    }
+}