static T GetOrRegisterHolder()
{
if (ms_key == null)
{
return(default(T));
}
var funcPtr = default(IntPtr);
if (InstanceGetters.TryGet(ms_key, out funcPtr))
{
using (InstanceGetters.DisableProcessing())
return(GetHolderCore(ms_t, funcPtr));
}
else
{
var funcPtrTmp = default(IntPtr);
using (InstanceGetters.DisableProcessing())
funcPtrTmp = GetFunctionPointerCore(ms_t);
while (!InstanceGetters.GetOrAdd(ms_key, funcPtrTmp, out funcPtr))
{
;
}
using (InstanceGetters.DisableProcessing())
return(GetHolderCore(ms_t, funcPtr));
}
}
public bool TryRemove(IndirectionInfo info, out Work method)
{
method = default(Work);
var holder = LooseCrossDomainAccessor.GetOrRegister <GenericHolder <TaggedBag <BodyOfNonPublicMethod, Dictionary <string, Work> > > >();
if (holder.Source.Value == null)
{
return(false);
}
var dict = holder.Source.Value;
lock (dict)
{
using (InstanceGetters.DisableProcessing())
{
var _ = default(Delegate);
if (!m_holder.TryRemove(info, out _))
{
return(false);
}
var key = info + "";
if (!dict.ContainsKey(key))
{
return(false);
}
method = dict[key];
dict.Remove(key);
return(true);
}
}
}
public Work AddOrUpdate(IndirectionInfo info, Work method)
{
var holder = LooseCrossDomainAccessor.GetOrRegister <GenericHolder <TaggedBag <BodyOfNonPublicMethod, Dictionary <string, Work> > > >();
if (holder.Source.Value == null)
{
holder.Source = TaggedBagFactory <BodyOfNonPublicMethod> .Make(new Dictionary <string, Work>());
}
var dict = holder.Source.Value;
lock (dict)
{
using (InstanceGetters.DisableProcessing())
{
var key = info + "";
holder.Source.Value[key] = method;
var wrapAndInvoke = CreateWrapAndInvokeMethod(IndirectionDelegate, key);
m_holder.AddOrUpdate(info, wrapAndInvoke);
dict[key] = method;
return(method);
}
}
}
public static void Register <T>() where T : InstanceHolder <T>
{
LooseCrossDomainAccessor <T> .Register();
lock (ms_unloadMethods)
using (InstanceGetters.DisableProcessing())
ms_unloadMethods.Add(LooseCrossDomainAccessor <T> .Unload);
}
public static T ExecuteOriginal <T>(Func <T> func)
{
if (func == null)
{
throw new ArgumentNullException("func");
}
using (InstanceGetters.DisableProcessing())
return(func());
}
public static void ExecuteOriginal(Action action)
{
if (action == null)
{
throw new ArgumentNullException("action");
}
using (InstanceGetters.DisableProcessing())
action();
}
public static TDelegate SafelyCast <TDelegate>(Delegate source) where TDelegate : class
{
if (source == null)
{
return(null);
}
using (InstanceGetters.DisableProcessing())
return(source.Cast <TDelegate>(typeof(InstanceGetters).Module));
}
static LooseCrossDomainAccessor()
{
using (InstanceGetters.DisableProcessing())
{
var all = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly;
foreach (var method in typeof(LooseCrossDomainAccessor <T>).GetMethods(all))
{
RuntimeHelpers.PrepareMethod(method.MethodHandle, new[] { typeof(T).TypeHandle });
}
}
}
protected override void Dispose(bool disposing)
{
lock (m_dict)
{
if (disposing)
{
using (InstanceGetters.DisableProcessing())
m_dict.Clear();
}
}
}
static IndirectionHolder()
{
using (InstanceGetters.DisableProcessing())
{
var all = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly;
foreach (var method in typeof(IndirectionHolder <TDelegate>).GetMethods(all))
{
RuntimeHelpers.PrepareMethod(method.MethodHandle, new[] { typeof(TDelegate).TypeHandle });
}
}
}
static TaggedBag()
{
using (InstanceGetters.DisableProcessing())
{
var all = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly;
foreach (var method in typeof(TaggedBag <TTag, TValue>).GetMethods(all))
{
RuntimeHelpers.PrepareMethod(method.MethodHandle, new[] { typeof(TTag).TypeHandle, typeof(TValue).TypeHandle });
}
}
}
static TargetSettingValue()
{
using (InstanceGetters.DisableProcessing())
{
var all = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly;
foreach (var method in typeof(TargetSettingValue <TIndirection>).GetMethods(all))
{
RuntimeHelpers.PrepareMethod(method.MethodHandle, new[] { typeof(TIndirection).TypeHandle });
}
}
}
public TDelegate AddOrUpdate(IndirectionInfo info, TDelegate method)
{
lock (m_dict)
{
using (InstanceGetters.DisableProcessing())
{
var key = info + "";
m_dict[key] = method;
return(method);
}
}
}
public static T GetOrRegister <T>() where T : InstanceHolder <T>
{
var holder = LooseCrossDomainAccessor <T> .HolderOrRegistered;
if (holder != null)
{
lock (ms_unloadMethods)
using (InstanceGetters.DisableProcessing())
ms_unloadMethods.Add(LooseCrossDomainAccessor <T> .Unload);
}
return(holder);
}
public void SetInstantiation(MethodBase target, Type[] sig, Type[] typeGenericArgs, Type[] methodGenericArgs)
{
using (InstanceGetters.DisableProcessing())
{
if (target == null)
{
throw new ArgumentNullException("target");
}
sig = sig.ReplaceGenericParameter(target.DeclaringType, typeGenericArgs, target, methodGenericArgs);
Instantiation = sig.Select(_ => _.ToString()).ToArray();
}
}
public static void Clear()
{
lock (ms_unloadMethods)
{
using (InstanceGetters.DisableProcessing())
{
foreach (var unloadMethod in ms_unloadMethods)
{
unloadMethod();
}
}
}
}
public static void Register()
{
if (ms_key == null)
{
return;
}
var funcPtr = default(IntPtr);
using (InstanceGetters.DisableProcessing())
funcPtr = GetFunctionPointerCore(ms_t);
InstanceGetters.TryAdd(ms_key, funcPtr);
}
static InstanceHolder()
{
using (InstanceGetters.DisableProcessing())
{
var all = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly;
foreach (var method in typeof(InstanceHolder <T>).GetMethods(all).Where(_ => !_.IsAbstract))
{
RuntimeHelpers.PrepareMethod(method.MethodHandle, new[] { typeof(T).TypeHandle });
}
// Prepare JIT here if the type has been already known explicitly.
new FallthroughException();
}
}
public IndirectionHolderUntyped(IndirectionHolder <Delegate> holder, Type indDlgt)
{
using (InstanceGetters.DisableProcessing())
{
if (holder == null)
{
throw new ArgumentNullException("holder");
}
if (!indDlgt.IsSubclassOf(typeof(Delegate)))
{
throw new ArgumentException("The parameter must be a delegate type.", "indDlgt");
}
m_holder = holder;
IndirectionDelegate = indDlgt;
}
}
public bool TryRemove(IndirectionInfo info, out TDelegate method)
{
method = default(TDelegate);
lock (m_dict)
{
using (InstanceGetters.DisableProcessing())
{
var key = info + "";
if (!m_dict.ContainsKey(key))
{
return(false);
}
method = m_dict[key];
m_dict.Remove(key);
return(true);
}
}
}
static Holder()
{
using (InstanceGetters.DisableProcessing())
{
// Using AppDomainID is an easy way to synchronize the stubbed method that is in same AppDomain with profiler side.
// In managed code, _dummyField (CLR v2.0.50727)/_pDomain (CLR v4.0.30319) field that belongs AppDomain class indicates that.
// See also this QA: [How to get current application domain id?](https://social.msdn.microsoft.com/Forums/en-US/2e2bc361-8a4f-4973-b4fc-3c79adbe0351/how-to-get-current-application-domain-id?forum=netfxtoolsdev)
var appDomainIdField = typeof(AppDomain).GetField("_dummyField", BindingFlags.NonPublic | BindingFlags.Instance);
if (appDomainIdField == null)
{
appDomainIdField = typeof(AppDomain).GetField("_pDomain", BindingFlags.NonPublic | BindingFlags.Instance);
}
if (appDomainIdField == null)
{
throw new NotSupportedException(string.Format("This runtime 'v{0}' is not supported.", typeof(object).Assembly.ImageRuntimeVersion));
}
Value = (IntPtr)appDomainIdField.GetValue(AppDomain.CurrentDomain);
}
}
static bool TryGetHolder(out T holder)
{
holder = default(T);
if (ms_key == null)
{
return(false);
}
var funcPtr = default(IntPtr);
if (!InstanceGetters.TryGet(ms_key, out funcPtr))
{
holder = null;
return(false);
}
else
{
using (InstanceGetters.DisableProcessing())
holder = GetHolderCore(ms_t, funcPtr);
return(true);
}
}
public void Dispose()
{
Dispose(true);
using (InstanceGetters.DisableProcessing())
GC.SuppressFinalize(this);
}