* First pass at adding winrt host entry-point.
* There's no way to specify HResult-swapping on a function called via hosted-interop so just return the HResult instead.
* Use the WindowsRuntimeMarshal class to create the activation factory and initialize it.
* Implement loading the dependent assemblies of a WinRT assembly into an isolated load context.
* PR Feedback.
* Fail to get the activation factory if the found type is not a managed type exported from a winmd.
* Rearrange parameters based on PR feedback.
* Remove unneeded include.
* Make ActivationFactoryLoader internal.
* Fix null-ref in WinRT-dependent-assembly loading
* Remove extraneous "System."
<!-- Accessed via native code. -->
<type fullname="System.Runtime.InteropServices.ComTypes.IEnumerable" />
<type fullname="System.Runtime.InteropServices.CustomMarshalers.*" />
+ <!-- Accessed by the WinRT Host -->
+ <type fullname="Internal.Runtime.InteropServices.WindowsRuntime.ActivationFactoryLoader" />
</assembly>
</linker>
</ItemGroup>
<ItemGroup Condition="'$(FeatureCominterop)' == 'true'">
<Compile Include="$(BclSourcesRoot)\Internal\Runtime\InteropServices\WindowsRuntime\ExceptionSupport.cs" />
+ <Compile Include="$(BclSourcesRoot)\Internal\Runtime\InteropServices\WindowsRuntime\ActivationFactoryLoader.cs" Condition="'$(FeatureCominteropWinRTManagedActivation)' == 'true'" />
<Compile Include="$(BclSourcesRoot)\Internal\Runtime\InteropServices\ComActivator.cs" Condition="'$(FeatureCominteropUnmanagedActivation)' == 'true'" />
<Compile Include="$(BclSourcesRoot)\Microsoft\Win32\OAVariantLib.cs" Condition="'$(FeatureClassicCominterop)' == 'true'" />
<Compile Include="$(BclSourcesRoot)\System\__ComObject.cs" />
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.WindowsRuntime;
+using System.Runtime.Loader;
+
+namespace Internal.Runtime.InteropServices.WindowsRuntime
+{
+ internal static class ActivationFactoryLoader
+ {
+ // Collection of all ALCs used for WinRT activation.
+ // Since each of the assemblies that act as the "key" here are WinRT assemblies
+ // we don't need to share this dictionary with the COM activation dictionary
+ // since there will be no overlap.
+ private static Dictionary<string, AssemblyLoadContext> s_AssemblyLoadContexts = new Dictionary<string, AssemblyLoadContext>(StringComparer.InvariantCultureIgnoreCase);
+
+ private static AssemblyLoadContext GetALC(string assemblyPath)
+ {
+ AssemblyLoadContext alc;
+
+ lock (s_AssemblyLoadContexts)
+ {
+ if (!s_AssemblyLoadContexts.TryGetValue(assemblyPath, out alc))
+ {
+ alc = new IsolatedComponentLoadContext(assemblyPath);
+ s_AssemblyLoadContexts.Add(assemblyPath, alc);
+ }
+ }
+
+ return alc;
+ }
+
+ /// <summary>Get a WinRT activation factory for a given type name.</summary>
+ /// <param name="componentPath">The path to the WinRT component that the type is expected to be defined in.</param>
+ /// <param name="typeName">The name of the component type to activate</param>
+ /// <param name="activationFactory">The activation factory</param>
+ public unsafe static int GetActivationFactory(
+ char* componentPath,
+ [MarshalAs(UnmanagedType.HString)] string typeName,
+ [MarshalAs(UnmanagedType.Interface)] out IActivationFactory activationFactory)
+ {
+ activationFactory = null;
+ try
+ {
+ if (typeName is null)
+ {
+ throw new ArgumentNullException(nameof(typeName));
+ }
+
+ AssemblyLoadContext context = GetALC(Marshal.PtrToStringUni((IntPtr)componentPath));
+
+ Type winRTType = context.LoadTypeForWinRTTypeNameInContext(typeName);
+
+ if (winRTType is null || !winRTType.IsExportedToWindowsRuntime)
+ {
+ throw new TypeLoadException(typeName);
+ }
+ activationFactory = WindowsRuntimeMarshal.GetManagedActivationFactory(winRTType);
+ }
+ catch (Exception ex)
+ {
+ return ex.HResult;
+ }
+ return 0;
+ }
+ }
+}
#if FEATURE_COMINTEROP
internal override bool IsWindowsRuntimeObjectImpl() => IsWindowsRuntimeObjectType(this);
- internal override bool IsExportedToWindowsRuntimeImpl() => IsTypeExportedToWindowsRuntime(this);
-
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private static extern bool IsWindowsRuntimeObjectType(RuntimeType type);
+#if FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION
+ internal override bool IsExportedToWindowsRuntimeImpl() => IsTypeExportedToWindowsRuntime(this);
+
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private static extern bool IsTypeExportedToWindowsRuntime(RuntimeType type);
-
+#endif // FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION
#endif // FEATURE_COMINTEROP
internal bool IsDelegate() => GetBaseType() == typeof(MulticastDelegate);
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
+ private static extern void LoadTypeForWinRTTypeNameInContextInternal(IntPtr ptrNativeAssemblyLoadContext, string typeName, ObjectHandleOnStack loadedType);
+
+ internal Type LoadTypeForWinRTTypeNameInContext(string typeName)
+ {
+ if (typeName is null)
+ {
+ throw new ArgumentNullException(nameof(typeName));
+ }
+
+ lock (_unloadLock)
+ {
+ VerifyIsAlive();
+
+ Type type = null;
+ LoadTypeForWinRTTypeNameInContextInternal(_nativeAssemblyLoadContext, typeName, JitHelpers.GetObjectHandleOnStack(ref type));
+ return type;
+ }
+ }
+
+ [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
private static extern IntPtr GetLoadContextForAssembly(RuntimeAssembly assembly);
// Returns the load context in which the specified assembly has been loaded
hr = BindAssemblySpecForHostedBinder(pSpec, pAssemblyName, m_pWinRtBinder, &pAssembly);
if (FAILED(hr))
goto EndTry2; // Goto end of try block.
+
+ PTR_CLRPrivAssemblyWinRT assem = dac_cast<PTR_CLRPrivAssemblyWinRT>(pAssembly->GetHostAssembly());
+ assem->SetFallbackBinder(pSpec->GetHostBinder());
EndTry2:;
}
// The combination of this conditional catch/ the following if statement which will throw reduces the count of exceptions
END_QCALL;
}
+
+#ifdef FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION
+void QCALLTYPE AssemblyNative::LoadTypeForWinRTTypeNameInContext(INT_PTR ptrAssemblyLoadContext, LPCWSTR pwzTypeName, QCall::ObjectHandleOnStack retType)
+{
+ QCALL_CONTRACT;
+
+ BEGIN_QCALL;
+
+ TypeHandle loadedType = WinRTTypeNameConverter::LoadManagedTypeForWinRTTypeName(pwzTypeName, (ICLRPrivBinder*)ptrAssemblyLoadContext, /* pbIsPrimitive */ nullptr);
+
+ if (!loadedType.IsNull())
+ {
+ GCX_COOP();
+ retType.Set(loadedType.GetManagedClassObject());
+ }
+
+ END_QCALL;
+}
+#endif
+
void QCALLTYPE AssemblyNative::GetType(QCall::AssemblyHandle pAssembly, LPCWSTR wszName, BOOL bThrowOnError, BOOL bIgnoreCase, QCall::ObjectHandleOnStack retType, QCall::ObjectHandleOnStack keepAlive)
{
CONTRACTL
static void QCALLTYPE LoadFromInMemoryModule(INT_PTR ptrNativeAssemblyLoadContext, INT_PTR hModule, QCall::ObjectHandleOnStack retLoadedAssembly);
#endif
static Assembly* LoadFromPEImage(ICLRPrivBinder* pBinderContext, PEImage *pILImage, PEImage *pNIImage);
+#ifdef FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION
+ static void QCALLTYPE LoadTypeForWinRTTypeNameInContext(INT_PTR ptrAssemblyLoadContext, LPCWSTR pwzTypeName, QCall::ObjectHandleOnStack retType);
+#endif
static INT_PTR QCALLTYPE GetLoadContextForAssembly(QCall::AssemblyHandle pAssembly);
static BOOL QCALLTYPE InternalTryGetRawMetadata(QCall::AssemblyHandle assembly, UINT8 **blobRef, INT32 *lengthRef);
// types being referenced from Windows.Foundation.Winmd).
//
// If the AssemblySpec does not correspond to WinRT type but our parent assembly binder is a WinRT binder,
- // then such an assembly will not be found by the binder. In such a case, we reset our binder reference.
+ // then such an assembly will not be found by the binder.
+ // In such a case, the parent binder should be the fallback binder for the WinRT assembly if one exists.
+ ICLRPrivBinder* pParentWinRTBinder = pParentAssemblyBinder;
pParentAssemblyBinder = NULL;
+ ReleaseHolder<ICLRPrivAssemblyID_WinRT> assembly;
+ if (SUCCEEDED(pParentWinRTBinder->QueryInterface<ICLRPrivAssemblyID_WinRT>(&assembly)))
+ {
+ pParentAssemblyBinder = dac_cast<PTR_CLRPrivAssemblyWinRT>(assembly.GetValue())->GetFallbackBinder();
+
+ // The fallback binder should not be a WinRT binder.
+ _ASSERTE(!AreSameBinderInstance(pWinRTBinder, pParentAssemblyBinder));
+ }
}
}
#endif // defined(FEATURE_COMINTEROP)
m_pIResourceNI(nullptr),
m_pIBindResult(nullptr),
m_fShareable(fShareable),
- m_dwImageTypes(0)
+ m_dwImageTypes(0),
+ m_FallbackBinder(nullptr)
{
STANDARD_VM_CONTRACT;
VALIDATE_ARG_THROW((pBinder != nullptr) && (pResourceIL != nullptr) && (pIBindResult != nullptr));
DWORD dwImageType,
DWORD * pdwImageType,
ICLRPrivResource ** ppIResource);
+
+ void SetFallbackBinder(ICLRPrivBinder* fallbackBinder)
+ {
+ m_FallbackBinder = clr::SafeAddRef(fallbackBinder);
+ }
+
+ ICLRPrivBinder* GetFallbackBinder()
+ {
+ return m_FallbackBinder;
+ }
private:
//=============================================================================================
ReleaseHolder<IBindResult> m_pIBindResult;
BOOL m_fShareable;
Volatile<DWORD> m_dwImageTypes;
+ ReleaseHolder<ICLRPrivBinder> m_FallbackBinder;
}; // class CLRPrivAssemblyWinRT
GCX_COOP();
bool bIsPrimitive;
- TypeHandle typeHandle = WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeName(wszTypeName, &bIsPrimitive);
+ TypeHandle typeHandle = WinRTTypeNameConverter::LoadManagedTypeForWinRTTypeName(wszTypeName, /* pLoadBinder */ nullptr, &bIsPrimitive);
if (!bIsPrimitive && !typeHandle.IsNull() && !typeHandle.IsTypeDesc() && typeHandle.AsMethodTable()->IsExportedToWinRT())
{
struct _gc {
QCFuncElement("LoadFromPath", AssemblyNative::LoadFromPath)
QCFuncElement("InternalLoadUnmanagedDllFromPath", AssemblyNative::InternalLoadUnmanagedDllFromPath)
QCFuncElement("LoadFromStream", AssemblyNative::LoadFromStream)
+#ifdef FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION
+ QCFuncElement("LoadTypeForWinRTTypeNameInContextInternal", AssemblyNative::LoadTypeForWinRTTypeNameInContext)
+#endif
#ifndef FEATURE_PAL
QCFuncElement("LoadFromInMemoryModuleInternal", AssemblyNative::LoadFromInMemoryModule)
#endif
}
// Try to load a WinRT type.
-TypeHandle GetWinRTType(SString* ssTypeName, BOOL bThrowIfNotFound)
+TypeHandle LoadWinRTType(SString* ssTypeName, BOOL bThrowIfNotFound, ICLRPrivBinder* loadBinder /* =nullptr */)
{
CONTRACT (TypeHandle)
{
TypeHandle typeHandle;
SString ssAssemblyName(SString::Utf8Literal, "WindowsRuntimeAssemblyName, ContentType=WindowsRuntime");
- DomainAssembly *pAssembly = LoadDomainAssembly(&ssAssemblyName, NULL,
- NULL,
+ DomainAssembly *pAssembly = LoadDomainAssembly(&ssAssemblyName, nullptr,
+ loadBinder,
bThrowIfNotFound, ssTypeName);
if (pAssembly != NULL)
{
EX_TRY
{
LPCWSTR pszWinRTTypeName = (ssTmpClassName.IsEmpty() ? ssClassName : ssTmpClassName);
- classTypeHandle = WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeName(pszWinRTTypeName, /*pbIsPrimitive = */ NULL);
+ classTypeHandle = WinRTTypeNameConverter::LoadManagedTypeForWinRTTypeName(pszWinRTTypeName, /* pLoadBinder */ nullptr, /*pbIsPrimitive = */ nullptr);
}
EX_CATCH
{
//--------------------------------------------------------------------------------
// Try to load a WinRT type.
-TypeHandle GetWinRTType(SString* ssTypeName, BOOL bThrowIfNotFound);
+TypeHandle LoadWinRTType(SString* ssTypeName, BOOL bThrowIfNotFound, ICLRPrivBinder* loadBinder = nullptr);
//--------------------------------------------------------------------------------
// Try to get the class from IInspectable.
IfFailThrow(cap.GetNonNullString(&szFactoryInterfaceName, &cbFactoryInterfaceName));
StackSString strFactoryInterface(SString::Utf8, szFactoryInterfaceName, cbFactoryInterfaceName);
- MethodTable *pMTFactoryInterface = GetWinRTType(&strFactoryInterface, /* bThrowIfNotFound = */ TRUE).GetMethodTable();
+ MethodTable *pMTFactoryInterface = LoadWinRTType(&strFactoryInterface, /* bThrowIfNotFound = */ TRUE).GetMethodTable();
_ASSERTE(pMTFactoryInterface);
m_factoryInterfaces.Append(pMTFactoryInterface);
// copy the name to a temporary buffer and NULL terminate it
StackSString ss(SString::Utf8, szName, cbName);
- TypeHandle th = GetWinRTType(&ss, /* bThrowIfNotFound = */ TRUE);
+ TypeHandle th = LoadWinRTType(&ss, /* bThrowIfNotFound = */ TRUE);
MethodTable *pMTStaticInterface = th.GetMethodTable();
m_staticInterfaces.Append(pMTStaticInterface);
}
FCIMPLEND
+#ifdef FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION
FCIMPL1(FC_BOOL_RET, RuntimeTypeHandle::IsTypeExportedToWindowsRuntime, ReflectClassBaseObject *rtTypeUNSAFE)
{
FCALL_CONTRACT;
FC_RETURN_BOOL(isExportedToWinRT);
}
FCIMPLEND
+#endif
#endif // FEATURE_COMINTEROP
NOINLINE static MethodDesc * RestoreMethodHelper(MethodDesc * pMethod, LPVOID __me)
#ifdef FEATURE_COMINTEROP
static FCDECL1(FC_BOOL_RET, IsWindowsRuntimeObjectType, ReflectClassBaseObject *rtTypeUNSAFE);
+#ifdef FEATURE_COMINTEROP_WINRT_MANAGED_ACTIVATION
static FCDECL1(FC_BOOL_RET, IsTypeExportedToWindowsRuntime, ReflectClassBaseObject *rtTypeUNSAFE);
-#endif // FEATURE_COMINTEROP
+#endif
+#endif //FEATURE_COMINTEROP
static
void QCALLTYPE PrepareMemberInfoCache(EnregisteredTypeHandle pMemberInfoCache);
// Get the MethodTable for Windows.Foundation.IStringable.
StackSString strIStringable(SString::Utf8, W("Windows.Foundation.IStringable"));
- MethodTable *pMTIStringable = GetWinRTType(&strIStringable, /* bThrowIfNotFound = */ FALSE).GetMethodTable();
+ MethodTable *pMTIStringable = LoadWinRTType(&strIStringable, /* bThrowIfNotFound = */ FALSE).GetMethodTable();
if (pMT != NULL && pMTIStringable != NULL && pMT->ImplementsInterface(pMTIStringable))
{
// This is only called in IL stubs which are in CER, so we don't need to worry about ThreadAbort
HELPER_METHOD_FRAME_BEGIN_RET_ATTRIB_1(Frame::FRAME_ATTR_NO_THREAD_ABORT, pObj);
+ // We're going to be making some COM calls, better initialize COM.
+ EnsureComStarted();
+
pIntf = MarshalObjectToInterface(&pObj, pItfMT, pClsMT, dwFlags);
// No exception will be thrown here (including thread abort as it is delayed in IL stubs)
OBJECTREF pObj = NULL;
HELPER_METHOD_FRAME_BEGIN_RET_1(pObj);
+
+ // We're going to be making some COM calls, better initialize COM.
+ EnsureComStarted();
UnmarshalObjectFromInterface(&pObj, ppUnk, pItfMT, pClsMT, dwFlags);
HELPER_METHOD_FRAME_BEGIN_RET_2(refClass, refString);
bool isPrimitive;
- TypeHandle th = WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeName(refString->GetBuffer(), &isPrimitive);
+ TypeHandle th = WinRTTypeNameConverter::LoadManagedTypeForWinRTTypeName(refString->GetBuffer(), /* pLoadBinder */ nullptr, &isPrimitive);
*pbIsPrimitive = isPrimitive;
refClass = th.GetManagedClassObject();
// Get TypeHandle from a WinRT type name
// Parse the WinRT type name in the form of WinRTType=TypeName[<WinRTType[, WinRTType, ...]>]
//
-TypeHandle WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeName(LPCWSTR wszWinRTTypeName, bool *pbIsPrimitive)
+TypeHandle WinRTTypeNameConverter::LoadManagedTypeForWinRTTypeName(LPCWSTR wszWinRTTypeName, ICLRPrivBinder * loadBinder, bool *pbIsPrimitive)
{
CONTRACTL
{
SString ssTypeName(SString::Literal, wszWinRTTypeName);
- TypeHandle th = GetManagedTypeFromWinRTTypeNameInternal(&ssTypeName, pbIsPrimitive);
+ TypeHandle th = LoadManagedTypeForWinRTTypeNameInternal(&ssTypeName, loadBinder, pbIsPrimitive);
if (th.IsNull())
{
COMPlusThrowArgumentException(W("typeName"), NULL);
// Return TypeHandle for the specified WinRT type name (supports generic type)
// Updates wszWinRTTypeName pointer as it parse the string
//
-TypeHandle WinRTTypeNameConverter::GetManagedTypeFromWinRTTypeNameInternal(SString *ssTypeName, bool *pbIsPrimitive)
+TypeHandle WinRTTypeNameConverter::LoadManagedTypeForWinRTTypeNameInternal(SString *ssTypeName, ICLRPrivBinder* loadBinder, bool *pbIsPrimitive)
{
CONTRACTL
{
PCWSTR wszPart = WindowsGetStringRawBuffer(rhsPartNames[i], &cchPartLength);
StackSString ssPartName(wszPart, cchPartLength);
- rqPartTypes[i] = GetManagedTypeFromSimpleWinRTNameInternal(&ssPartName, NULL);
+ rqPartTypes[i] = GetManagedTypeFromSimpleWinRTNameInternal(&ssPartName, loadBinder, nullptr);
}
#else //CROSSGEN_COMPILE
// load the components
for (DWORD i = 0; i < dwPartsCount; i++)
{
- rqPartTypes[i] = GetManagedTypeFromSimpleWinRTNameInternal(&rhsPartNames[i], NULL);
+ rqPartTypes[i] = GetManagedTypeFromSimpleWinRTNameInternal(&rhsPartNames[i], loadBinder, NULL);
}
delete[] rhsPartNames;
}
else
{
- return GetManagedTypeFromSimpleWinRTNameInternal(ssTypeName, pbIsPrimitive);
+ return GetManagedTypeFromSimpleWinRTNameInternal(ssTypeName, loadBinder, pbIsPrimitive);
}
}
// Return MethodTable* for the specified WinRT primitive type name (non-generic type)
// Updates wszWinRTTypeName pointer as it parse the string
//
-TypeHandle WinRTTypeNameConverter::GetManagedTypeFromSimpleWinRTNameInternal(SString *ssTypeName, bool *pbIsPrimitive)
+TypeHandle WinRTTypeNameConverter::GetManagedTypeFromSimpleWinRTNameInternal(SString *ssTypeName, ICLRPrivBinder* loadBinder, bool *pbIsPrimitive)
{
CONTRACTL
{
//
// A regular WinRT type
//
- return GetWinRTType(ssTypeName, TRUE);
+ return LoadWinRTType(ssTypeName, TRUE, loadBinder);
}
}
#pragma once
#include "..\md\winmd\inc\adapter.h"
+#include "clrprivbinding.h"
struct WinRTTypeNameInfo;
// Get TypeHandle from a WinRT type name
// Parse the WinRT type name in the form of WinRTType=TypeName[<WinRTType[, WinRTType, ...]>]
//
- static TypeHandle GetManagedTypeFromWinRTTypeName(LPCWSTR wszWinRTTypeName, bool *pbIsPrimitive);
+ static TypeHandle LoadManagedTypeForWinRTTypeName(LPCWSTR wszWinRTTypeName, ICLRPrivBinder * loadBinder, bool *pbIsPrimitive);
private :
// Return TypeHandle for the specified WinRT type name (supports generic type)
// Updates wszWinRTTypeName pointer as it parse the string
//
- static TypeHandle GetManagedTypeFromWinRTTypeNameInternal(SString *ssTypeName, bool *pbIsPrimitive);
+ static TypeHandle LoadManagedTypeForWinRTTypeNameInternal(SString *ssTypeName, ICLRPrivBinder* loadBinder, bool *pbIsPrimitive);
//
// Return MethodTable* for the specified WinRT primitive type name (non-generic type)
// Updates wszWinRTTypeName pointer as it parse the string
//
- static TypeHandle GetManagedTypeFromSimpleWinRTNameInternal(SString *ssTypeName, bool *pbIsPrimitive);
+ static TypeHandle GetManagedTypeFromSimpleWinRTNameInternal(SString *ssTypeName, ICLRPrivBinder* loadBinder, bool *pbIsPrimitive);
static bool AppendWinRTTypeNameForManagedType(
TypeHandle thManagedType,