UWP API in ASP.NET

Question

I\'d like to use a piece of Windows 10 specific UWP API (specifically, the Windows.Graphics.Printing3D stuff) in an ASP.NET code-behind DLL. Is there any way to do so?

Answer 1

While looking for a .NET-only resolution to this one, I've found a moderately clean way - a Win32/64 C++ DLL that would consume UWP API and present a COM- or P/Invoke-based interface to .NET.

Create a regular Win32 DLL. Build an interface for .NET to consume - exported functions or objects, depends. In my case, a single exported function will do. In the project's C/C++ settings, make the following changes:

• Under General, set Consume Windows Runtime Extensions to Yes.
• Under General, set Additional #using Directories to: C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcpackages;C:\Program Files (x86)\Windows Kits\10\UnionMetadata (assuming Visual Studio 2015)
• Under Code Generation, set Enable Minimal Rebuild to No (it's only Yes for Debug, not for Release).

Then instantiate and use UWP components in the DLL in the usual C++/CX manner, like you would in a Store app, via using namespace Windows::... and ref new.

In this approach, you lose bitness agnosticism; an unmanaged DLL can't be "Any CPU". You win some, you lose some. Also, the site will not run without the Visual C++ redistributable package on the system. On the other hand, it may run faster than a .NET app; less managed/native boundary crossings.

Inspiration: "Using C++/CX in Desktop apps" by Pavel Y.

Answer 2

Open the project file as XML, and paste the following line under the first <PropertyGroup>:

<TargetPlatformVersion>10.0</TargetPlatformVersion>

Once you do that, the Add reference dialog will include UWP libraries, and the file type options in the "Browse..." dialog there will include .winmd.

Load the project, do Add reference/Browse, locate C:\Program Files (x86)\Windows Kits\10\UnionMetadata\Windows.winmd, add that.

There are some helpful extension methods in the managed assembly System.Runtime.WindowsRuntime (e. g. IBuffer.AsStream()), but for some reason, it's not listed under Assemblies. To reference it, you'd need to edit the project file directly, and under the first <ItemGroup>, add the following:

<Reference Include="System.Runtime.WindowsRuntime" />

Unlike the guide states, you don't need to change the compilation target to x86 or x64; leave AnyCPU be.

---

For desktop .NET applications, this is sufficient. For ASP.NET, however, there's a catch. The way the ASP.NET runtime sets up its AppDomains not compatible with UWP. It's probably a bug deep down, but I've reported it, and a Microsoft rep said the whole thing was not a supported scenario to begin with.

Anyway, you have to change the LoaderOptimization policy of the AppDomain to SingleDomain. The quickest way to do so is via abusing a private method of AppDomain:

AppDomain ad = AppDomain.CurrentDomain;
MethodInfo mi = ad.GetType().GetMethod("SetupLoaderOptimization", BindingFlags.Instance | BindingFlags.NonPublic);
mi.Invoke(ad, new object[] { LoaderOptimization.SingleDomain });

A good place to do that would be in the app startup code.

A slightly less dangerous approach would involve creating a new AppDomain, which would inherit all setup properties from the current one but LoaderOptimization, which will be set to SingleDomain, and running the UWP dependent code in that domain. Like this:

AppDomain CreateUnsharingDomain()
{
    AppDomain cad = AppDomain.CurrentDomain;
    AppDomainSetup cads = cad.SetupInformation;
    return AppDomain.CreateDomain("Dummy", cad.Evidence,
        new AppDomainSetup
        {
            ApplicationName = cads.ApplicationName,
            ApplicationBase = cads.ApplicationBase,
            DynamicBase = cads.DynamicBase,
            CachePath = cads.CachePath,
            PrivateBinPath = cads.PrivateBinPath,
            ShadowCopyDirectories = cads.ShadowCopyDirectories,
            ShadowCopyFiles = cads.ShadowCopyFiles,
            ApplicationTrust = cads.ApplicationTrust,
            LoaderOptimization = LoaderOptimization.SingleDomain
        });
        //Not sure which other properties to copy...
}

CreateUnsharingDomain().DoCallBack(MyUWPDependentMethod);

Again, it would make sense to create the domain once and cache it for the app lifetime.

This approach might be faster than the one with the monkey-patched AppDomain. The MultiDomain optimization exists for a reason; if you leave most of the Web code in a MultiDomain world, the optimization will do its work as intended.

Inspiration: "Walkthrough: Using WinRT libraries from a Windows Desktop application" by David Moore.