Add DllMap sample (#668)

Add DllMap sample

Add a sample to demonstrate the use of NativeLibrary APIs to
map library names during resolution.

Author: swaroop-sridhar

core/extensions/DllMapDemo/Demo.cs

@@ -0,0 +1,24 @@
+using System;
+using System.IO;
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+public class DllMapDemo
+{
+    public static void Main()
+    {
+        try
+        {
+            DllMap.Register(Assembly.GetExecutingAssembly());
+            int thirty = NativeSum(10, 20);
+            Console.WriteLine($"OldLib.NativeSum(10,20) = {thirty}");
+        }
+        catch (Exception e)
+        {
+            Console.WriteLine($"Error: {e.Message} Line: {e.Source}");
+        }
+    }
+
+    [DllImport("OldLib")]
+    static extern int NativeSum(int arg1, int arg2);
+}

core/extensions/DllMapDemo/Demo.csproj

@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp3.0</TargetFramework>
+  </PropertyGroup>
+  <ItemGroup>
+    <None Include="Demo.xml">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+</Project>

core/extensions/DllMapDemo/Demo.xml

@@ -0,0 +1,3 @@
+<configuration>
+    <dllmap dll="OldLib" target="NewLib"/>
+</configuration>

core/extensions/DllMapDemo/Map.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Xml.Linq;
+
+public static class DllMap
+{
+    // Register a call-back for native library resolution.
+    public static void Register(Assembly assembly)
+    {
+        NativeLibrary.SetDllImportResolver(assembly, MapAndLoad);
+    }
+
+    // The callback: which loads the mapped libray in place of the original
+    private static IntPtr MapAndLoad(string libraryName, Assembly assembly, DllImportSearchPath? dllImportSearchPath)
+    {
+        string mappedName = null;
+        mappedName = MapLibraryName(assembly.Location, libraryName, out mappedName) ? mappedName : libraryName;
+        return NativeLibrary.Load(mappedName, assembly, dllImportSearchPath);
+    }
+
+    // Parse the assembly.xml file, and map the old name to the new name of a library.
+    private static bool MapLibraryName(string assemblyLocation, string originalLibName, out string mappedLibName)
+    {
+        string xmlPath = Path.Combine(Path.GetDirectoryName(assemblyLocation),
+            Path.GetFileNameWithoutExtension(assemblyLocation) + ".xml");
+        mappedLibName = null;
+
+        if (!File.Exists(xmlPath))
+            return false;
+
+        XElement root = XElement.Load(xmlPath);
+        var map =
+            (from el in root.Elements("dllmap")
+             where (string)el.Attribute("dll") == originalLibName
+             select el).SingleOrDefault();
+
+        if (map != null)
+            mappedLibName = map.Attribute("target").Value;
+
+        return (mappedLibName != null);
+    }
+}

core/extensions/DllMapDemo/NewLib.cpp

@@ -0,0 +1,12 @@
+#include <stdio.h>
+
+#if defined(__GNUC__)
+#define EXPORT extern "C" __attribute__((visibility("default")))
+#elif defined(_MSC_VER)
+#define EXPORT extern "C" __declspec(dllexport)
+#endif 
+
+extern "C" EXPORT int NativeSum(int a, int b)
+{
+    return a + b;
+}

core/extensions/DllMapDemo/ReadMe.md

@@ -0,0 +1,31 @@
+# DllMap Demo
+
+This sample illustrates the use of NativeLibrary APIs to implement library name mappings similar to the [Mono](https://www.mono-project.com/) [Dllmap](http://www.mono-project.com/docs/advanced/pinvoke/dllmap/) feature.
+
+## NativeLibrary APIs
+
+.Net Core 3.0 provides a rich set of APIs to manage native libraries:
+
+- [NativeLibrary APIs](https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.nativelibrary?view=netcore-3.0): Perform operations on native libraries (such as `Load()`, `Free()`, get the address of an exported  symbol, etc.) in a platform-independent way from managed code.
+- [DllImport Resolver callback](https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.nativelibrary.setdllimportresolver?view=netcore-3.0):  Gets a callback for first-chance native library resolution using custom logic. 
+- [Native Library Resolve event](https://docs.microsoft.com/en-us/dotnet/api/system.runtime.loader.assemblyloadcontext.resolvingunmanageddll?view=netcore-3.0): Get an event for last-chance native library resolution using custom logic.   
+
+## Library Mapping
+
+These APIs can be used to implement custom native library resolution logic, including DllMap, as illustrated in this example. The sample demonstrates:
+
+- An [app](Demo.cs) that pInvokes a method in `OldLib`, but runs in an environment where only [`NewLib`](NewLib.cpp) is available.
+- The [XML file](Demo.xml) that maps the library name from `OldLib` to `NewLib`. 
+- The [Map](Map.cs) implementation, which parses the above mapping and uses `NativeLibrary` APIs to load the correct library.
+
+## Build and Run
+
+1. Install .NET Core 3.0 Preview 3 or newer.
+
+2. Use the .NET Core SDK to build the project via `dotnet build`.
+
+3. Build the native component `NewLib.cpp` as a dynamic library, using the platform's native toolset. 
+
+    Place the generated native library (`NewLib.dll` / `libNewLib.so` / `libNewLib.dylib`) in the `dotnet build` output directory.
+
+4. Run the app with `dotnet run`