ProxyUtil
using Castle.Core.Internal;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
namespace Castle.DynamicProxy
{
public static class ProxyUtil
{
private static readonly IDictionary<Assembly, bool> internalsVisibleToDynamicProxy = new Dictionary<Assembly, bool>();
private static readonly Lock internalsVisibleToDynamicProxyLock = Lock.Create();
public static object GetUnproxiedInstance(object instance)
{
IProxyTargetAccessor proxyTargetAccessor = instance as IProxyTargetAccessor;
if (proxyTargetAccessor != null)
instance = proxyTargetAccessor.DynProxyGetTarget();
return instance;
}
public static Type GetUnproxiedType(object instance)
{
IProxyTargetAccessor proxyTargetAccessor = instance as IProxyTargetAccessor;
if (proxyTargetAccessor != null) {
object obj = proxyTargetAccessor.DynProxyGetTarget();
if (obj != null) {
if (obj == instance)
return instance.GetType().GetTypeInfo().get_BaseType();
instance = obj;
}
}
return instance.GetType();
}
public static bool IsProxy(object instance)
{
return instance is IProxyTargetAccessor;
}
public static bool IsProxyType(Type type)
{
return typeof(IProxyTargetAccessor).IsAssignableFrom(type);
}
public static bool IsAccessible(MethodBase method)
{
if (IsAccessibleMethod(method))
return IsAccessibleType(method.DeclaringType);
return false;
}
public static bool IsAccessible(MethodBase method, out string message)
{
if (IsAccessible(method)) {
message = null;
return true;
}
message = CreateMessageForInaccessibleMethod(method);
return false;
}
public static bool IsAccessible(Type type)
{
return IsAccessibleType(type);
}
internal static bool AreInternalsVisibleToDynamicProxy(Assembly asm)
{
using (IUpgradeableLockHolder upgradeableLockHolder = internalsVisibleToDynamicProxyLock.ForReadingUpgradeable()) {
if (!internalsVisibleToDynamicProxy.ContainsKey(asm)) {
upgradeableLockHolder.Upgrade();
if (!internalsVisibleToDynamicProxy.ContainsKey(asm)) {
bool flag = asm.GetCustomAttributes<InternalsVisibleToAttribute>().Any((InternalsVisibleToAttribute attr) => attr.AssemblyName.Contains(ModuleScope.DEFAULT_ASSEMBLY_NAME));
internalsVisibleToDynamicProxy.Add(asm, flag);
return flag;
}
return internalsVisibleToDynamicProxy[asm];
}
return internalsVisibleToDynamicProxy[asm];
}
}
internal static bool IsAccessibleType(Type target)
{
TypeInfo typeInfo = target.GetTypeInfo();
if (typeInfo.get_IsPublic() || typeInfo.get_IsNestedPublic())
return true;
bool isNested = target.IsNested;
bool flag = isNested && (typeInfo.get_IsNestedAssembly() || typeInfo.get_IsNestedFamORAssem());
if (((!typeInfo.get_IsVisible() && !isNested) | flag) && AreInternalsVisibleToDynamicProxy(typeInfo.get_Assembly()))
return true;
return false;
}
internal static bool IsAccessibleMethod(MethodBase method)
{
if (method.IsPublic || method.IsFamily || method.IsFamilyOrAssembly)
return true;
if (method.IsAssembly || method.IsFamilyAndAssembly)
return AreInternalsVisibleToDynamicProxy(method.DeclaringType.GetTypeInfo().get_Assembly());
return false;
}
internal static bool IsInternal(MethodBase method)
{
if (!method.IsAssembly) {
if (method.IsFamilyAndAssembly)
return !method.IsFamilyOrAssembly;
return false;
}
return true;
}
private static string CreateMessageForInaccessibleMethod(MethodBase inaccessibleMethod)
{
Assembly assembly = inaccessibleMethod.DeclaringType.GetTypeInfo().get_Assembly();
string str = $"""{inaccessibleMethod}""";
string str2 = ExceptionMessageBuilder.CreateInstructionsToMakeVisible(assembly);
return str + str2;
}
}
}