using Castle.Core.Internal; using System; using System.Collections.Generic; using System.Linq; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.Remoting; 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) { if (!RemotingServices.IsTransparentProxy(instance)) { IProxyTargetAccessor proxyTargetAccessor = instance as IProxyTargetAccessor; if (proxyTargetAccessor != null) instance = proxyTargetAccessor.DynProxyGetTarget(); } return instance; } public static Type GetUnproxiedType(object instance) { if (!RemotingServices.IsTransparentProxy(instance)) { IProxyTargetAccessor proxyTargetAccessor = instance as IProxyTargetAccessor; if (proxyTargetAccessor != null) { object obj = proxyTargetAccessor.DynProxyGetTarget(); if (obj != null) { if (obj == instance) return System.Reflection.IntrospectionExtensions.GetTypeInfo(instance.GetType()).BaseType; instance = obj; } } } return instance.GetType(); } public static bool IsProxy(object instance) { if (RemotingServices.IsTransparentProxy(instance)) return true; 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 = System.Reflection.CustomAttributeExtensions.GetCustomAttributes<InternalsVisibleToAttribute>(asm).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) { Type typeInfo = System.Reflection.IntrospectionExtensions.GetTypeInfo(target); if (typeInfo.IsPublic || typeInfo.IsNestedPublic) return true; bool isNested = target.IsNested; bool flag = isNested && (typeInfo.IsNestedAssembly || typeInfo.IsNestedFamORAssem); if (((!typeInfo.IsVisible && !isNested) | flag) && AreInternalsVisibleToDynamicProxy(typeInfo.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(System.Reflection.IntrospectionExtensions.GetTypeInfo(method.DeclaringType).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 = System.Reflection.IntrospectionExtensions.GetTypeInfo(inaccessibleMethod.DeclaringType).Assembly; string str = $"""{inaccessibleMethod}"""; string str2 = ExceptionMessageBuilder.CreateInstructionsToMakeVisible(assembly); return str + str2; } } }