public DebugMetadataImporter(ICorDebugModule module)
        {
            _module = module;

            Guid interfaceGuid = typeof(IMetadataImport).GUID;
            _module.GetMetaDataInterface(ref interfaceGuid, out _metadatImport);
        }

 internal DnModule(DnAssembly ownerAssembly, ICorDebugModule module, int incrementedId, int moduleOrder)
 {
     this.ownerAssembly = ownerAssembly;
     this.module = new CorModule(module);
     this.incrementedId = incrementedId;
     this.moduleOrder = moduleOrder;
 }

 public CorModule(ICorDebugModule md)
 {
     corModule = md;
     char[] name = new char[300];
     uint sz = 0;
     corModule.GetName((uint)name.Length, out sz, name);
     fullName = new String(name, 0, (int)(sz - 1));
 }

        //
        // IEnumerator interface
        //

        #region IEnumerator Members

        public bool MoveNext()
        {
            var a = new ICorDebugModule[1];
            uint c = 0;
            int r = m_enum.Next((uint) a.Length, a, out c);
            if (r == 0 && c == 1) // S_OK && we got 1 new element
                m_mod = new CorModule(a[0]);
            else
                m_mod = null;
            return m_mod != null;
        }

        private IList<DebugModule> LoadModules()
        {
            ICorDebugModuleEnum modulesEnum;
            _assembly.EnumerateModules(out modulesEnum);
            uint modCount;
            modulesEnum.GetCount(out modCount);
            ICorDebugModule[] modules = new ICorDebugModule[modCount];
            uint modulesFetched;
            modulesEnum.Next(modCount, modules, out modulesFetched);

            var result = new List<DebugModule>((int)modulesFetched);
            for (int i = 0; i < modulesFetched; i++)
            {
                result.Add(new DebugModule(modules[i]));
            }

            return result;
        }

        internal Module(AppDomain appDomain, ICorDebugModule corModule)
        {
            this.appDomain = appDomain;
            this.process = appDomain.Process;
            this.corModule = corModule;

            metaData = new MetaDataImport(corModule);

            if (IsDynamic || IsInMemory) {
                name     = corModule.GetName();
            } else {
                fullPath = corModule.GetName();
                name     = System.IO.Path.GetFileName(FullPath);
            }
            asmFilename = corModule.GetAssembly().GetName();

            SetJITCompilerFlags();

            LoadSymbolsFromDisk(process.Options.SymbolsSearchPaths);
            ResetJustMyCodeStatus();
        }

        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++;
                    }
                }
            }
        }

 void ICorDebugManagedCallback.UnloadModule(
                           ICorDebugAppDomain appDomain,
                           ICorDebugModule managedModule)
 {
     HandleEvent(ManagedCallbackType.OnModuleUnload,
                       new CorModuleEventArgs( appDomain == null ? null : new CorAppDomain(appDomain),
                                               managedModule == null ? null : new CorModule(managedModule),
                                               ManagedCallbackType.OnModuleUnload));
 }

        public DnAssembly TryGetValidAssembly(ICorDebugAppDomain comAppDomain, ICorDebugModule comModule)
        {
            DebugVerifyThread();
            if (comModule == null)
                return null;

            var appDomain = TryGetValidAppDomain(comAppDomain);
            if (appDomain == null)
                return null;

            ICorDebugAssembly comAssembly;
            int hr = comModule.GetAssembly(out comAssembly);
            if (hr < 0)
                return null;

            return appDomain.TryGetAssembly(comAssembly);
        }

		public void UnloadModule(ICorDebugAppDomain pAppDomain, ICorDebugModule pModule)
		{
			EnterCallback("UnloadModule", pAppDomain);
			
			Module module = process.GetModule(pModule);
			process.modules.Remove(module);
			process.OnModuleUnloaded(module);
			
			ExitCallback();
		}

		public void UpdateModuleSymbols(ICorDebugAppDomain pAppDomain, ICorDebugModule pModule, IStream pSymbolStream)
		{
			EnterCallback("UpdateModuleSymbols", pAppDomain);
			
			Module module = process.GetModule(pModule);
			if (module.CorModule is ICorDebugModule3 && module.IsDynamic) {
				// In .NET 4.0, we use the LoadClass callback to load dynamic modules
				// because it always works - UpdateModuleSymbols does not.
				//  - Simple dynamic code generation seems to trigger both callbacks.
				//  - IronPython for some reason causes just the LoadClass callback
				//    so we choose to rely on it out of the two.
			} else {
				// In .NET 2.0, this is the the only method and it works fine
				module.LoadSymbolsFromMemory(pSymbolStream);
			}
			
			ExitCallback();
		}

		internal DnModule TryAdd(ICorDebugModule comModule) {
			return modules.Add(comModule);
		}

 public DebuggerModuleLoadedEventArgs(ICorDebugModule module)
 {
     _module = module;
 }

		internal Module GetModule(ICorDebugModule corModule)
		{
			foreach(Module module in this.Modules) {
				if (module.CorModule == corModule) {
					return module;
				}
			}
			throw new DebuggerException("Module is not in collection");
		}

		public UpdateModuleSymbolsDebugCallbackEventArgs(ICorDebugAppDomain pAppDomain, ICorDebugModule pModule, IStream pSymbolStream)
			: base(pAppDomain) {
			this.AppDomain = pAppDomain;
			this.Module = pModule;
			this.SymbolStream = pSymbolStream;
		}

            public void UnloadModule(ICorDebugAppDomain pAppDomain, ICorDebugModule pModule)
            {
                try
                {
                    _EnterCallback();

                    lock (dbgproc)
                    {
                        dbgproc.imodules.Remove(pModule);
                    }

                    _ResumeCallback();

                    _CallbackEvent("UnloadModule");
                }
                catch (Exception e)
                {
                    _CallbackException(e);
                }
            }

            public void UpdateModuleSymbols(ICorDebugAppDomain pAppDomain, ICorDebugModule pModule, IStream pSymbolStream)
            {
                try
                {
                    _EnterCallback();

                    _CallbackNotImplemented();

                    _CallbackEvent("UpdateModuleSymbols");
                }
                catch (Exception e)
                {
                    _CallbackException(e);
                }
            }

        public void LoadModule(ICorDebugAppDomain pAppDomain, ICorDebugModule pModule)
        {
            Logger.WriteLine("Module {0} loaded", new DebugModule(pModule).Name);

            var handler = OnModuleLoaded;
            if (handler != null) handler(this, new DebuggerModuleLoadedEventArgs(pModule));

            pAppDomain.Continue(0);
        }

		DnModule CreateModule(ICorDebugModule comModule, int id) {
			return new DnModule(this, comModule, id, Debugger.GetNextModuleId());
		}

 public void UnloadModule(ICorDebugAppDomain pAppDomain, ICorDebugModule pModule)
 {
     try
     {
         Logger.WriteLine("Module {0} unloaded", new DebugModule(pModule).Name);
     }
     catch (Exception)
     {
         Logger.WriteLine("Could not resolve unloaded module name");
     }
     pAppDomain.Continue(0);
 }