/// <summary>
/// Retrieves the current delegate that is being called
/// </summary>
public static T GetCurrentCalleeDelegate <T>() where T : class // constraint can't be System.Delegate
{
//
// RH keeps track of the current thunk that is being called through a secret argument / thread
// statics. No matter how that's implemented, we get the current thunk which we can use for
// look up later
//
IntPtr pContext = RuntimeImports.GetCurrentInteropThunkContext();
Debug.Assert(pContext != null);
GCHandle handle;
unsafe
{
// Pull out Handle from context
handle = ((ThunkContextData *)pContext)->Handle;
}
T target = InteropExtensions.UncheckedCast <T>(handle.Target);
//
// The delegate might already been garbage collected
// User should use GC.KeepAlive or whatever ways necessary to keep the delegate alive
// until they are done with the native function pointer
//
if (target == null)
{
Environment.FailFast(SR.Delegate_GarbageCollected);
}
return(target);
}
private static __ComObject CreateComObjectInternal(RuntimeTypeHandle classType, IntPtr pComItf)
{
Debug.Assert(!classType.IsNull());
if (classType.Equals(McgModule.s_DependencyReductionTypeRemovedTypeHandle))
{
// We should filter out the strongly typed RCW in TryGetClassInfoFromName step
#if !RHTESTCL
Environment.FailFast(McgTypeHelpers.GetDiagnosticMessageForMissingType(classType));
#else
Environment.FailFast("We should never see strongly typed RCW discarded here");
#endif
}
//Note that this doesn't run the constructor in RH but probably do in your reflection based implementation.
//If this were a real RCW, you would actually 'new' the RCW which is wrong. Fortunately in CoreCLR we don't have
//this scenario so we are OK, but we should figure out a way to fix this by having a runtime API.
object newClass = InteropExtensions.RuntimeNewObject(classType);
Debug.Assert(newClass is __ComObject);
__ComObject newObj = InteropExtensions.UncheckedCast <__ComObject>(newClass);
IntPtr pfnCtor = AddrOfIntrinsics.AddrOf <AddrOfIntrinsics.AddrOfAttachingCtor>(__ComObject.AttachingCtor);
CalliIntrinsics.Call <int>(pfnCtor, newObj, pComItf, classType);
return(newObj);
}
public static T FastCast <T>(object value) where T : class
{
// We have an assert here, to verify that a "real" cast would have succeeded.
// However, casting on weakly-typed RCWs modifies their state, by doing a QI and caching
// the result. This often makes things work which otherwise wouldn't work (especially variance).
Debug.Assert(value == null || value is T);
return(InteropExtensions.UncheckedCast <T>(value));
}
/// <summary>
/// Retrieve the corresponding P/invoke instance from the stub
/// </summary>
public static Delegate GetPInvokeDelegateForStub(IntPtr pStub, RuntimeTypeHandle delegateType)
{
if (pStub == IntPtr.Zero)
{
return(null);
}
//
// First try to see if this is one of the thunks we've allocated when we marshal a managed
// delegate to native code
// s_thunkPoolHeap will be null if there isn't any managed delegate to native
//
IntPtr pContext;
IntPtr pTarget;
if (s_thunkPoolHeap != null && RuntimeAugments.TryGetThunkData(s_thunkPoolHeap, pStub, out pContext, out pTarget))
{
GCHandle handle;
unsafe
{
// Pull out Handle from context
handle = ((ThunkContextData *)pContext)->Handle;
}
Delegate target = InteropExtensions.UncheckedCast <Delegate>(handle.Target);
//
// The delegate might already been garbage collected
// User should use GC.KeepAlive or whatever ways necessary to keep the delegate alive
// until they are done with the native function pointer
//
if (target == null)
{
Environment.FailFast(SR.Delegate_GarbageCollected);
}
return(target);
}
//
// Otherwise, the stub must be a pure native function pointer
// We need to create the delegate that points to the invoke method of a
// NativeFunctionPointerWrapper derived class
//
McgPInvokeDelegateData pInvokeDelegateData;
if (!RuntimeAugments.InteropCallbacks.TryGetMarshallerDataForDelegate(delegateType, out pInvokeDelegateData))
{
return(null);
}
return(CalliIntrinsics.Call <Delegate>(
pInvokeDelegateData.ForwardDelegateCreationStub,
pStub
));
}
public static T CreateClass <T>() where T : class
{
return(InteropExtensions.UncheckedCast <T>(InteropExtensions.RuntimeNewObject(typeof(T).TypeHandle)));
}
