Merge pull request #563 from dotnet/master

Update live with current master

Author: JRAlexander

core/hosting/HostWithCoreClrHost/README.md

@@ -0,0 +1,20 @@
+.NET Core Hosting Sample
+========================
+
+This sample demonstrates a simple .NET Core host using the hosting APIs from [CoreClrHost.h](https://github.com/dotnet/coreclr/blob/master/src/coreclr/hosts/inc/coreclrhost.h). The sample host loads and starts the .NET Core CLR (including starting the default AppDomain), loads managed code, calls into a managed method, and provides a function pointer for the managed code to call back into the host.
+
+This sample is part of the [.NET Core hosting tutorial](https://docs.microsoft.com/dotnet/core/tutorials/netcore-hosting). See that topic for a more detailed explanation of this sample. There are also alternative hosting APIs (the `ICLRRuntimeHost2` interface in [mscoree.h](https://github.com/dotnet/coreclr/tree/master/src/pal/prebuilt/inc/mscoree.h)) that are demonstrated in the [HostWithMscoree folder](../HostWithMsCoree) of this repository. 
+
+About .NET Core Hosts
+---------------------
+
+.NET Core applications are always run by a host. In most cases, the default dotnet.exe host is used.
+
+It is possible to create your own host, though, to enable starting and running .NET Core code from a native application, or to enable a high degree of control over how the runtime operates. More complex, real-world hosts can be found in the [dotnet/coreclr](https://github.com/dotnet/coreclr/tree/master/src/coreclr/hosts) repository.
+
+Build and Run
+-------------
+
+To build this sample, just use the included build scripts *build.bat*, *build.sh*, or *buildOsx.sh*. These scripts build both the managed target assembly (ManagedLibrary.dll) and the host (SampleHost.exe). The build scripts are just simple wrappers around two build calls (`dotnet publish` for the managed component of the sample and cl.exe/g++ for the host), so it's also easy to build the two components directly if you prefer. The build scripts build for Windows 10 (x64), Linux (x64), and OSX (x64), respectively, and assume that both the dotnet CLI and the C++ compiler (cl.exe or g++) are available on the path (as will be the case on Windows if building from a Visual Studio Developer Command Prompt). The build scripts will need modified if you intend to target other platforms or use tools from other paths. Be sure that the bitness of the host and sample app match. By default, the build scripts build ManagedLibrary.dll for x64, so you will need to build the host for 64-bit.
+
+To run the host, just execute SampleHost from the bin/{{OS}} directory.

core/hosting/HostWithCoreClrHost/build.bat

@@ -0,0 +1,17 @@
+@echo off
+
+REM This script builds the sample for x64 Windows 10. If using Win7, adjust the 'dotnet publish' command.
+REM It assumes that both the dotnet CLI and cl.exe compiler are available on the path.
+REM A Visual Studio Developer Command Prompt will already have cl.exe on its path.
+
+SET SRCDIR=%~dp0src
+SET OUTDIR=%~dp0bin\windows
+
+mkdir %OUTDIR%
+
+REM Build managed component
+echo Building Managed Library
+dotnet publish --self-contained -r win10-x64 %SRCDIR%\ManagedLibrary\ManagedLibrary.csproj -o %OUTDIR%
+
+REM Build native component
+cl.exe %SRCDIR%\SampleHost.cpp /Fo%OUTDIR%\ /Fd%OUTDIR%\SampleHost.pdb /EHsc /Od /GS /sdl /Zi /D "WINDOWS" /link ole32.lib /out:%OUTDIR%\SampleHost.exe

core/hosting/HostWithCoreClrHost/build.sh

@@ -0,0 +1,19 @@
+# This script builds the sample for x64 Linux. 
+# It assumes that both the dotnet CLI and g++ compiler are available on the path.
+
+SCRIPTPATH=$(readlink -f "$0")
+BASEDIR=$(dirname $SCRIPTPATH)
+SRCDIR=${BASEDIR}/src
+OUTDIR=${BASEDIR}/bin/linux
+
+# Make output directory, if needed
+if [ ! -d "${OUTDIR}" ]; then
+    mkdir -p ${OUTDIR}
+fi
+
+# Build managed component
+echo Building Managed Library
+dotnet publish --self-contained -r linux-x64 ${SRCDIR}/ManagedLibrary/ManagedLibrary.csproj -o ${OUTDIR}
+
+# Build native component
+g++ -o ${OUTDIR}/SampleHost -D LINUX ${SRCDIR}/SampleHost.cpp -ldl

core/hosting/HostWithCoreClrHost/buildOsx.sh

@@ -0,0 +1,20 @@
+# This script builds the sample for x64 OSX. 
+# It assumes that both the dotnet CLI and g++ compiler are available on the path.
+
+BASEDIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+SRCDIR=${BASEDIR}/src
+OUTDIR=${BASEDIR}/bin/osx
+
+# Make output directory, if needed
+if [ ! -d "${OUTDIR}" ]; then
+    mkdir -p ${OUTDIR}
+fi
+
+# Build managed component
+echo Building Managed Library
+echo dotnet publish --self-contained -r osx-x64 ${SRCDIR}/ManagedLibrary/ManagedLibrary.csproj -o ${OUTDIR}
+dotnet publish --self-contained -r osx-x64 ${SRCDIR}/ManagedLibrary/ManagedLibrary.csproj -o ${OUTDIR}
+
+# Build native component
+# -D both LINUX and OSX since most LINUX code paths apply to OSX also
+g++ -o ${OUTDIR}/SampleHost -D LINUX -D OSX ${SRCDIR}/SampleHost.cpp -ldl

core/hosting/HostWithCoreClrHost/src/ManagedLibrary/ManagedLibrary.csproj

@@ -0,0 +1,11 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <!-- Although this project is not used as an exe (it's not the process's entry point),
+         it is built as an exe so that publishing it will include the .NET Core runtime and
+         framework libraries for use by the host -->
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp2.1</TargetFramework>
+  </PropertyGroup>
+
+</Project>

core/hosting/HostWithCoreClrHost/src/ManagedLibrary/ManagedWorker.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Threading;
+
+namespace ManagedLibrary
+{
+    // Sample managed code for the host to call
+    public class ManagedWorker
+    {
+        // This assembly is being built as an exe as a simple way to 
+        // get .NET Core runtime libraries deployed (`dotnet publish` will
+        // publish .NET Core libraries for exes). Therefore, this assembly
+        // requires an entry point method even though it is unused.
+        public static void Main() 
+        {
+            Console.WriteLine("This assembly is not meant to be run directly.");
+            Console.WriteLine("Instead, please use the SampleHost process to load this assembly.");
+        }
+
+        public delegate int ReportProgressFunction(int progress);
+
+        // This test method doesn't actually do anything, it just takes some input parameters,
+        // waits (in a loop) for a bit, invoking the callback function periodically, and
+        // then returns a string version of the double[] passed in.
+        [return: MarshalAs(UnmanagedType.LPStr)]
+        public static string DoWork(
+            [MarshalAs(UnmanagedType.LPStr)] string jobName, 
+            int iterations, 
+            int dataSize, 
+            [MarshalAs(UnmanagedType.LPArray, SizeParamIndex=2)] double[] data, 
+            ReportProgressFunction reportProgressFunction)
+        {
+            for (int i = 1; i <= iterations; i++)
+            {
+                Console.ForegroundColor = ConsoleColor.Cyan;
+                Console.WriteLine($"Beginning work iteration {i}");
+                Console.ResetColor();
+
+                // Pause as if doing work
+                Thread.Sleep(1000);
+
+                // Call the native callback and write its return value to the console
+                var progressResponse = reportProgressFunction(i);
+                Console.WriteLine($"Received response [{progressResponse}] from progress function");
+            }
+
+            Console.ForegroundColor = ConsoleColor.Green;
+            Console.WriteLine($"Work completed");
+            Console.ResetColor();
+
+            return $"Data received: {string.Join(", ", data.Select(d => d.ToString()))}";
+        }
+    }
+}