/// <summary>
/// Gets a list of interfaces implemented by <paramref name="type"/> that aren't inherited by any other shadowed interfaces.
/// </summary>
/// <param name="type">The type for which to get the list.</param>
/// <returns>The interface list.</returns>
private static List <Type> GetUninheritedShadowedInterfaces(Type type)
{
// Cache reflection on interface inheritance
lock (typeToShadowTypes)
{
if (!typeToShadowTypes.TryGetValue(type, out List <Type> cachedInterfaces))
{
var interfaces = type.GetTypeInfo().ImplementedInterfaces.ToList();
typeToShadowTypes.Add(type, interfaces);
var interfacesToRemove = new List <Type>();
// First pass to identify most detailed interfaces
foreach (var item in interfaces)
{
// Only process interfaces that are using shadow
var shadowAttribute = ShadowAttribute.Get(item);
if (shadowAttribute == null)
{
interfacesToRemove.Add(item);
continue;
}
// Keep only final interfaces and not intermediate.
var inheritList = item.GetTypeInfo().ImplementedInterfaces;
foreach (var inheritInterface in inheritList)
{
interfacesToRemove.Add(inheritInterface);
}
}
foreach (var toRemove in interfacesToRemove)
{
interfaces.Remove(toRemove);
}
return(interfaces);
}
return(cachedInterfaces);
}
}
internal void Initialize(ICallbackable callbackable)
{
callbackable.Shadow = this;
var type = callbackable.GetType();
List <Type> slimInterfaces;
// Cache reflection on COM interface inheritance
lock (typeToShadowTypes)
{
if (!typeToShadowTypes.TryGetValue(type, out slimInterfaces))
{
#if NET40
var interfaces = type.GetTypeInfo().GetInterfaces();
#else
var interfaces = type.GetTypeInfo().ImplementedInterfaces;
#endif
slimInterfaces = new List <Type>();
slimInterfaces.AddRange(interfaces);
typeToShadowTypes.Add(type, slimInterfaces);
// First pass to identify most detailed interfaces
foreach (var item in interfaces)
{
// Only process interfaces that are using shadow
var shadowAttribute = ShadowAttribute.Get(item);
if (shadowAttribute == null)
{
slimInterfaces.Remove(item);
continue;
}
// Keep only final interfaces and not intermediate.
#if NET40
var inheritList = item.GetTypeInfo().GetInterfaces();
#else
var inheritList = item.GetTypeInfo().ImplementedInterfaces;
#endif
foreach (var inheritInterface in inheritList)
{
slimInterfaces.Remove(inheritInterface);
}
}
}
}
CppObjectShadow iunknownShadow = null;
// Second pass to instantiate shadow
foreach (var item in slimInterfaces)
{
// Only process interfaces that are using shadow
var shadowAttribute = ShadowAttribute.Get(item);
// Initialize the shadow with the callback
var shadow = (CppObjectShadow)Activator.CreateInstance(shadowAttribute.Type);
shadow.Initialize(callbackable);
// Take the first shadow as the main IUnknown
if (iunknownShadow == null)
{
iunknownShadow = shadow;
// Add IUnknown as a supported interface
guidToShadow.Add(ComObjectShadow.IID_IUnknown, iunknownShadow);
}
guidToShadow.Add(Utilities.GetGuidFromType(item), shadow);
// Associate also inherited interface to this shadow
#if NET40
var inheritList = item.GetTypeInfo().GetInterfaces();
#else
var inheritList = item.GetTypeInfo().ImplementedInterfaces;
#endif
foreach (var inheritInterface in inheritList)
{
var inheritShadowAttribute = ShadowAttribute.Get(inheritInterface);
if (inheritShadowAttribute == null)
{
continue;
}
// Use same shadow as derived
guidToShadow.Add(Utilities.GetGuidFromType(inheritInterface), shadow);
}
}
// Precalculate the list of GUID without IUnknown and IInspectable
// Used for WinRT
int countGuids = 0;
foreach (var guidKey in guidToShadow.Keys)
{
if (guidKey != Utilities.GetGuidFromType(typeof(IInspectable)) && guidKey != Utilities.GetGuidFromType(typeof(IUnknown)))
{
countGuids++;
}
}
guidPtr = Marshal.AllocHGlobal(Utilities.SizeOf <Guid>() * countGuids);
Guids = new IntPtr[countGuids];
int i = 0;
unsafe
{
var pGuid = (Guid *)guidPtr;
foreach (var guidKey in guidToShadow.Keys)
{
if (guidKey == Utilities.GetGuidFromType(typeof(IInspectable)) || guidKey == Utilities.GetGuidFromType(typeof(IUnknown)))
{
continue;
}
pGuid[i] = guidKey;
// Store the pointer
Guids[i] = new IntPtr(pGuid + i);
i++;
}
}
}
internal ShadowContainer(ICallbackable callbackable)
{
var type = callbackable.GetType();
var guidList = new List <Guid>();
// Associate all shadows with their interfaces.
foreach (var item in GetUninheritedShadowedInterfaces(type))
{
var shadowAttribute = ShadowAttribute.Get(item);
// Initialize the shadow with the callback
var shadow = (CppObjectShadow)Activator.CreateInstance(shadowAttribute.Type);
shadow.Initialize(callbackable);
guidToShadow.Add(item.GetTypeInfo().GUID, shadow);
if (item.GetTypeInfo().GetCustomAttribute <ExcludeFromTypeListAttribute>() != null)
{
guidList.Add(item.GetTypeInfo().GUID);
}
// Associate also inherited interface to this shadow
var inheritList = item.GetTypeInfo().ImplementedInterfaces;
foreach (var inheritInterface in inheritList)
{
// If there isn't a Shadow attribute then this isn't a native interface.
var inheritShadowAttribute = ShadowAttribute.Get(inheritInterface);
if (inheritShadowAttribute == null)
{
continue;
}
// If we have the same GUID as an already added interface,
// then there's already an accurate shadow for it, so we have nothing to do.
if (guidToShadow.ContainsKey(inheritInterface.GetTypeInfo().GUID))
{
continue;
}
// Use same shadow as derived
guidToShadow.Add(inheritInterface.GetTypeInfo().GUID, shadow);
if (inheritInterface.GetTypeInfo().GetCustomAttribute <ExcludeFromTypeListAttribute>() != null)
{
guidList.Add(inheritInterface.GetTypeInfo().GUID);
}
}
}
var guidCount = guidList.Count;
Guids = new IntPtr[guidCount];
guidPtr = Marshal.AllocHGlobal(Unsafe.SizeOf <Guid>() * guidCount);
unsafe
{
var i = 0;
var pGuid = (Guid *)guidPtr;
foreach (var guidKey in guidList)
{
pGuid[i] = guidKey;
// Store the pointer
Guids[i] = new IntPtr(pGuid + i);
i++;
}
}
}