internal static RuntimeAssembly[] OnReflectionOnlyNamespaceResolveEvent(AppDomain appDomain, RuntimeAssembly assembly, string namespaceName)
 {
     EventHandler<NamespaceResolveEventArgs> eventHandler = ReflectionOnlyNamespaceResolve;
     if (eventHandler != null)
     {
         Delegate[] ds = eventHandler.GetInvocationList();
         int len = ds.Length;
         for (int i = 0; i < len; i++)
         {
             NamespaceResolveEventArgs eventArgs = new NamespaceResolveEventArgs(namespaceName, assembly);
             
             ((EventHandler<NamespaceResolveEventArgs>)ds[i])(appDomain, eventArgs);
             
             Collection<Assembly> assembliesCollection = eventArgs.ResolvedAssemblies;
             if (assembliesCollection.Count > 0)
             {
                 RuntimeAssembly[] retAssemblies = new RuntimeAssembly[assembliesCollection.Count];
                 int retIndex = 0;
                 foreach (Assembly asm in assembliesCollection)
                 {
                     retAssemblies[retIndex] = AppDomain.GetRuntimeAssembly(asm);
                     retIndex++;
                 }
                 return retAssemblies;
             }
         }
     }
     
     return null;
 }

 internal static void CheckAssembly(RuntimeAssembly asm, CodeAccessPermission demand)
 {
     PermissionSet set;
     PermissionSet set2;
     asm.GetGrantSet(out set, out set2);
     CheckHelper(set, set2, demand, PermissionToken.GetToken(demand), RuntimeMethodHandleInternal.EmptyHandle, asm, SecurityAction.Demand, true);
 }

        public RuntimeLibrary(
            string type,
            string name,
            string version,
            string hash,
            IReadOnlyList<RuntimeAssetGroup> runtimeAssemblyGroups,
            IReadOnlyList<RuntimeAssetGroup> nativeLibraryGroups,
            IEnumerable<ResourceAssembly> resourceAssemblies,
            IEnumerable<Dependency> dependencies,
            bool serviceable)
            : base(type, name, version, hash, dependencies, serviceable)
        {
            if (runtimeAssemblyGroups == null)
            {
                throw new ArgumentNullException(nameof(runtimeAssemblyGroups));
            }
            if (nativeLibraryGroups == null)
            {
                throw new ArgumentNullException(nameof(nativeLibraryGroups));
            }
            if (resourceAssemblies == null)
            {
                throw new ArgumentNullException(nameof(resourceAssemblies));
            }
            RuntimeAssemblyGroups = runtimeAssemblyGroups;
            ResourceAssemblies = resourceAssemblies.ToArray();
            NativeLibraryGroups = nativeLibraryGroups;

            Assemblies = new RuntimeAssembly[0];
            NativeLibraries = new string[0];
        }

 internal StrongName(StrongNamePublicKeyBlob blob, string name, System.Version version, Assembly assembly)
 {
     if (name == null)
     {
         throw new ArgumentNullException("name");
     }
     if (string.IsNullOrEmpty(name))
     {
         throw new ArgumentException(Environment.GetResourceString("Argument_EmptyStrongName"));
     }
     if (blob == null)
     {
         throw new ArgumentNullException("blob");
     }
     if (version == null)
     {
         throw new ArgumentNullException("version");
     }
     RuntimeAssembly assembly2 = assembly as RuntimeAssembly;
     if ((assembly != null) && (assembly2 == null))
     {
         throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeAssembly"), "assembly");
     }
     this.m_publicKeyBlob = blob;
     this.m_name = name;
     this.m_version = version;
     this.m_assembly = assembly2;
 }

        /// <summary>
        ///     Create a factory which can generate evidence for the specified assembly
        /// </summary> 
        private AssemblyEvidenceFactory(RuntimeAssembly targetAssembly, PEFileEvidenceFactory peFileFactory)
        { 
            Contract.Assert(targetAssembly != null); 
            Contract.Assert(peFileFactory != null);
 
            m_targetAssembly = targetAssembly;
            m_peFileFactory = peFileFactory;
        }

 public EventItfInfo(string strEventItfName, string strSrcItfName, string strEventProviderName, RuntimeAssembly asmImport, RuntimeAssembly asmSrcItf)
 {
     this.m_strEventItfName = strEventItfName;
     this.m_strSrcItfName = strSrcItfName;
     this.m_strEventProviderName = strEventProviderName;
     this.m_asmImport = asmImport;
     this.m_asmSrcItf = asmSrcItf;
 }

 internal static TypeForwardedToAttribute[] GetCustomAttribute(RuntimeAssembly assembly)
 {
     Type[] o = null;
     RuntimeAssembly.GetForwardedTypes(assembly.GetNativeHandle(), JitHelpers.GetObjectHandleOnStack<Type[]>(ref o));
     TypeForwardedToAttribute[] attributeArray = new TypeForwardedToAttribute[o.Length];
     for (int i = 0; i < o.Length; i++)
     {
         attributeArray[i] = new TypeForwardedToAttribute(o[i]);
     }
     return attributeArray;
 }

 private Stream CaseInsensitiveManifestResourceStreamLookup(RuntimeAssembly satellite, string name)
 {
     StringBuilder builder = new StringBuilder();
     if (this._mediator.LocationInfo != null)
     {
         string str = this._mediator.LocationInfo.Namespace;
         if (str != null)
         {
             builder.Append(str);
             if (name != null)
             {
                 builder.Append(Type.Delimiter);
             }
         }
     }
     builder.Append(name);
     string str2 = builder.ToString();
     CompareInfo compareInfo = CultureInfo.InvariantCulture.CompareInfo;
     string str3 = null;
     foreach (string str4 in satellite.GetManifestResourceNames())
     {
         if (compareInfo.Compare(str4, str2, CompareOptions.IgnoreCase) == 0)
         {
             if (str3 != null)
             {
                 throw new MissingManifestResourceException(Environment.GetResourceString("MissingManifestResource_MultipleBlobs", new object[] { str2, satellite.ToString() }));
             }
             str3 = str4;
         }
     }
     if (FrameworkEventSource.IsInitialized)
     {
         if (str3 != null)
         {
             FrameworkEventSource.Log.ResourceManagerCaseInsensitiveResourceStreamLookupSucceeded(this._mediator.BaseName, this._mediator.MainAssembly, satellite.GetSimpleName(), str2);
         }
         else
         {
             FrameworkEventSource.Log.ResourceManagerCaseInsensitiveResourceStreamLookupFailed(this._mediator.BaseName, this._mediator.MainAssembly, satellite.GetSimpleName(), str2);
         }
     }
     if (str3 == null)
     {
         return null;
     }
     bool skipSecurityCheck = (this._mediator.MainAssembly == satellite) && (this._mediator.CallingAssembly == this._mediator.MainAssembly);
     StackCrawlMark lookForMyCaller = StackCrawlMark.LookForMyCaller;
     Stream stream = satellite.GetManifestResourceStream(str3, ref lookForMyCaller, skipSecurityCheck);
     if ((stream != null) && FrameworkEventSource.IsInitialized)
     {
         FrameworkEventSource.Log.ResourceManagerManifestResourceAccessDenied(this._mediator.BaseName, this._mediator.MainAssembly, satellite.GetSimpleName(), str3);
     }
     return stream;
 }

        internal static TypeForwardedToAttribute[] GetCustomAttribute(RuntimeAssembly assembly)
        {
            Type[] types = null;
            RuntimeAssembly.GetForwardedTypes(assembly.GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref types));

            TypeForwardedToAttribute[] attributes = new TypeForwardedToAttribute[types.Length];
            for (int i = 0; i < types.Length; ++i)
                attributes[i] = new TypeForwardedToAttribute(types[i]);

            return attributes;
        }

 public EventItfInfo(String strEventItfName,
                     String strSrcItfName,
                     String strEventProviderName,
                     RuntimeAssembly asmImport,
                     RuntimeAssembly asmSrcItf)
 {
     m_strEventItfName = strEventItfName;
     m_strSrcItfName = strSrcItfName;
     m_strEventProviderName = strEventProviderName;
     m_asmImport = asmImport;
     m_asmSrcItf = asmSrcItf;
 }

#pragma warning disable 618
        private static void ThrowSecurityException(RuntimeAssembly asm, PermissionSet granted, PermissionSet refused, RuntimeMethodHandleInternal rmh, SecurityAction action, Object demand, IPermission permThatFailed)
#pragma warning restore 618
        {
            AssemblyName asmName = null;
            Evidence asmEvidence = null;
            if (asm != null)
            {
                // Assert here because reflection will check grants and if we fail the check,
                // there will be an infinite recursion that overflows the stack.
                PermissionSet.s_fullTrust.Assert();
                asmName = asm.GetName();
            }
            throw SecurityException.MakeSecurityException(asmName, asmEvidence, granted, refused, rmh, action, demand, permThatFailed);
        }

 public sealed override Exception TryResolve(ReflectionDomain reflectionDomain, RuntimeAssembly currentAssembly, bool ignoreCase, out RuntimeType result)
 {
     result = null;
     if (AssemblyName == null)
     {
         return TypeName.TryResolve(reflectionDomain, currentAssembly, ignoreCase, out result);
     }
     else
     {
         RuntimeAssembly newAssembly;
         Exception assemblyLoadException = RuntimeAssembly.TryGetRuntimeAssembly(reflectionDomain, AssemblyName, out newAssembly);
         if (assemblyLoadException != null)
             return assemblyLoadException;
         return TypeName.TryResolve(reflectionDomain, newAssembly, ignoreCase, out result);
     }
 }

 public Hash(Assembly assembly)
 {
     if (assembly == null)
     {
         throw new ArgumentNullException("assembly");
     }
     if (assembly.IsDynamic)
     {
         throw new ArgumentException(Environment.GetResourceString("Security_CannotGenerateHash"), "assembly");
     }
     this.m_hashes = new Dictionary<Type, byte[]>();
     this.m_assembly = assembly as RuntimeAssembly;
     if (this.m_assembly == null)
     {
         throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeAssembly"), "assembly");
     }
 }

 public ResourceManager(Type resourceSource)
 {
     if (null == resourceSource)
     {
         throw new ArgumentNullException("resourceSource");
     }
     if (!(resourceSource is RuntimeType))
     {
         throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeType"));
     }
     this._locationInfo = resourceSource;
     this.MainAssembly = this._locationInfo.Assembly;
     this.BaseNameField = resourceSource.Name;
     this.CommonSatelliteAssemblyInit();
     this.m_callingAssembly = (RuntimeAssembly) Assembly.GetCallingAssembly();
     if ((this.MainAssembly == typeof(object).Assembly) && (this.m_callingAssembly != this.MainAssembly))
     {
         this.m_callingAssembly = null;
     }
 }

        [System.Security.SecurityCritical]  // auto-generated
        internal static AssemblyName CreateAssemblyName(
            String assemblyString, 
            bool forIntrospection, 
            out RuntimeAssembly assemblyFromResolveEvent)
        {
            if (assemblyString == null)
                throw new ArgumentNullException("assemblyString");
            Contract.EndContractBlock();

            if ((assemblyString.Length == 0) ||
                (assemblyString[0] == '\0'))
                throw new ArgumentException(Environment.GetResourceString("Format_StringZeroLength"));

            if (forIntrospection)
                AppDomain.CheckReflectionOnlyLoadSupported();

            AssemblyName an = new AssemblyName();

            an.Name = assemblyString;
            assemblyFromResolveEvent = null; // instead of an.nInit(out assemblyFromResolveEvent, forIntrospection, true);
            return an;
        }

        internal RuntimeModule(RuntimeAssembly assembly, ICorDebugModule comModule)
        {
            _assembly = assembly;
            _comModule = comModule;

            Symbols = _assembly.Domain.Process.Session.SymbolsServer.GetSymbolsProviderForFile(this.Name);
            if (Symbols != null)
            {
                int index = 0, max = Session.PendingBreakpoints.Count;
                Session.ProgressReporter.Report("Symbol reader present. Finding pending breakpoints to set.");
                while (index < max)
                {
                    if (TrySetBreakpoint(Session.PendingBreakpoints[index]))
                    {
                        max--;
                        Session.PendingBreakpoints.RemoveAt(index);
                    }
                    else
                    {
                        index++;
                    }
                }
            }
        }

        private void OnDeserialized(StreamingContext ctx)
        {
            _resourceSets = new Dictionary<String, ResourceSet>();
            _lastUsedResourceCache = new CultureNameResourceSetPair();
            // set up resource groveler, depending on whether this ResourceManager
            // is looking for files or assemblies
            ResourceManagerMediator mediator = new ResourceManagerMediator(this);
            if (UseManifest)
            {
                resourceGroveler = new ManifestBasedResourceGroveler(mediator);
            }
            else
            {
                resourceGroveler = new FileBasedResourceGroveler(mediator);
            }

            // correct callingAssembly for v2
            if (this.m_callingAssembly == null)
            {
                this.m_callingAssembly = (RuntimeAssembly)_callingAssembly;
            }

            // v2 does this lazily
            if (UseManifest && this._neutralResourcesCulture == null)
            {
                _neutralResourcesCulture = ManifestBasedResourceGroveler.GetNeutralResourcesLanguage(MainAssembly, ref _fallbackLoc);
            }
        }

        [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
        public ResourceManager(Type resourceSource)
        {
            if (null==resourceSource)
                throw new ArgumentNullException("resourceSource");
            Contract.EndContractBlock();

            if (!(resourceSource is RuntimeType))
                throw new ArgumentException(Environment.GetResourceString("Argument_MustBeRuntimeType"));

            _locationInfo = resourceSource;
            MainAssembly = _locationInfo.Assembly;
            BaseNameField = resourceSource.Name;
            
            SetAppXConfiguration();

            CommonAssemblyInit();

            m_callingAssembly = (RuntimeAssembly)Assembly.GetCallingAssembly();
            // Special case for mscorlib - protect mscorlib's private resources.
            if (MainAssembly == typeof(Object).Assembly && m_callingAssembly != MainAssembly)
            {
                m_callingAssembly = null;
            }
        }

 [MethodImplAttribute(MethodImplOptions.NoInlining)] // Methods containing StackCrawlMark local var has to be marked non-inlineable
 private void Init()
 {
     m_callingAssembly = (RuntimeAssembly)Assembly.GetCallingAssembly();
 }

        private bool ShouldUseSatelliteAssemblyResourceLookupUnderAppX(RuntimeAssembly resourcesAssembly)
        {
            bool fUseSatelliteAssemblyResourceLookupUnderAppX = resourcesAssembly.IsFrameworkAssembly();
            
#if FEATURE_CORECLR     
            if (!fUseSatelliteAssemblyResourceLookupUnderAppX)
            {
                // Check to see if the assembly is under PLATFORM_RESOURCE_ROOTS. If it is, then we should use satellite assembly lookup for it.
                String platformResourceRoots = (String)(AppDomain.CurrentDomain.GetData("PLATFORM_RESOURCE_ROOTS"));
                if ((platformResourceRoots != null) && (platformResourceRoots != String.Empty))
                {
                    string resourceAssemblyPath = resourcesAssembly.Location;
                    
                    // Loop through the PLATFORM_RESOURCE_ROOTS and see if the assembly is contained in it.
                    foreach(string pathPlatformResourceRoot in platformResourceRoots.Split(Path.PathSeparator))
                    {
                        if (resourceAssemblyPath.StartsWith(pathPlatformResourceRoot, StringComparison.CurrentCultureIgnoreCase))
                        {
                            // Found the resource assembly to be present in one of the PLATFORM_RESOURCE_ROOT, so stop the enumeration loop.
                            fUseSatelliteAssemblyResourceLookupUnderAppX = true;
                            break;
                        }
                    }
                }
            }
#endif // FEATURE_CORECLR
            return fUseSatelliteAssemblyResourceLookupUnderAppX;
            
        }