public ManagedCallback GetProcessCallbackInterface(string name, ICorDebugProcess pProcess)
		{
			Process process;
			// We have to wait until the created process is added into the collection
			lock(debugger.ProcessIsBeingCreatedLock) {
				process = debugger.GetProcess(pProcess);
			}
			// Make *really* sure the process is not dead
			if (process == null) {
				debugger.TraceMessage("Ignoring callback \"" + name + "\": Process not found");
				return null;
			}
			if (process.HasExited) {
				debugger.TraceMessage("Ignoring callback \"" + name + "\": Process has exited");
				return null;
			}
			if (process.TerminateCommandIssued && !(name == "ExitProcess")) {
				debugger.TraceMessage("Ignoring callback \"" + name + "\": Terminate command was issued for the process");
				return null;
			}
			// Check that the process is not exited
			try {
				int isRunning = process.CorProcess.IsRunning();
			} catch (COMException e) {
				process.TraceMessage("Ignoring callback \"" + name + "\": " + e.Message);
				return null;
			}
			return process.CallbackInterface;
		}

		void EnterCallback(PausedReason pausedReason, string name, ICorDebugProcess pProcess)
		{
			isInCallback = true;
			
			process.TraceMessage("Callback: " + name);
			System.Diagnostics.Debug.Assert(process.CorProcess == pProcess);
			
			// After break is pressed we may receive some messages that were already queued
			if (process.IsPaused && process.PauseSession.PausedReason == PausedReason.ForcedBreak) {
				// TODO: This does not work well if exception if being processed and the user continues it
				process.TraceMessage("Processing post-break callback");
				// This compensates for the break call and we are in normal callback handling mode
				process.AsyncContinue(DebuggeeStateAction.Keep, new Thread[] {}, null);
				// Start of call back - create new pause session (as usual)
				process.NotifyPaused(pausedReason);
				// Make sure we stay pause after the callback is handled
				pauseOnNextExit = true;
				return;
			}
			
			if (process.IsRunning) {
				process.NotifyPaused(pausedReason);
				return;
			}
			
			throw new DebuggerException("Invalid state at the start of callback");
		}

        internal DebugProcess(DebugContext context, ICorDebugProcess process)
        {
            this.context = context;
            this.process = process;

            this.Process = Process.GetProcessById(process.GetID());
        }

		void EnterCallback(string name, ICorDebugProcess pProcess)
		{
			isInCallback = true;
			
			process.TraceMessage("Callback: " + name);
			System.Diagnostics.Debug.Assert(process.CorProcess == pProcess);
			
			// After break is pressed we may receive some messages that were already queued
			if (process.IsPaused) {
				process.TraceMessage("Processing post-break callback");
				// Decrese the "break count" from 2 to 1 - does not actually continue
				// TODO: This inccorectly marks the debugger as running
				process.AsyncContinue(DebuggeeStateAction.Keep);
				// Make sure we stay paused after the callback is handled
				pauseOnNextExit = true;
				return;
			}
			
			if (process.IsRunning) {
				process.NotifyPaused();
				return;
			}
			
			throw new DebuggerException("Invalid state at the start of callback");
		}

 public void Detach(ICorDebugProcess process)
 {
     if (this.runningProcesses.Remove(process))
     {
         process.Stop(Constants.Infinite);
         process.Detach();
     }
 }

 internal DnProcess(DnDebugger ownerDebugger, ICorDebugProcess process, int incrementedId)
 {
     this.ownerDebugger = ownerDebugger;
     this.appDomains = new DebuggerCollection<ICorDebugAppDomain, DnAppDomain>(CreateAppDomain);
     this.threads = new DebuggerCollection<ICorDebugThread, DnThread>(CreateThread);
     this.process = new CorProcess(process);
     this.incrementedId = incrementedId;
 }

		internal Process GetProcess(ICorDebugProcess corProcess) {
			foreach (Process process in this.Processes) {
				if (process.CorProcess == corProcess) {
					return process;
				}
			}
			return null;
		}

        public void CreateAppDomain(ICorDebugProcess pProcess, ICorDebugAppDomain pAppDomain)
        {
            var domain = new DebugDomain(null, pAppDomain);
            Logger.WriteLine("App domain {0} created", domain.Name);

            pAppDomain.Attach();

            pProcess.Continue(0);
        }

 //
 // IEnumerator interface
 //
 public bool MoveNext()
 {
     ICorDebugProcess[] a = new ICorDebugProcess[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_proc =  CorProcess.GetCorProcess(a[0]);
     else
         m_proc = null;
     return m_proc != null;
 }

 public static CorProcess GetCorProcess(ICorDebugProcess process)
 {
     Debug.Assert(process != null);
     lock (m_instances)
     {
         if (!m_instances.Contains(process))
         {
             CorProcess p = new CorProcess(process);
             m_instances.Add(process, p);
             return p;
         }
         return (CorProcess)m_instances[process];
     }
 }

        internal Process(NDebugger debugger, ICorDebugProcess corProcess, string workingDirectory)
        {
            this.debugger = debugger;
            this.corProcess = corProcess;
            this.workingDirectory = workingDirectory;

            this.callbackInterface = new ManagedCallback(this);

            activeEvals = new EvalCollection(debugger);
            modules = new ModuleCollection(debugger);
            modules.Added += OnModulesAdded;
            threads = new ThreadCollection(debugger);
            appDomains = new AppDomainCollection(debugger);
        }

        int ICorDebug.GetProcess(uint dwProcessId, out ICorDebugProcess ppProcess)
        {
            ppProcess = null;

            foreach (CorDebugProcess process in m_processes)
            {
                uint id = process.PhysicalProcessId.dwProcessId;

                if (dwProcessId == id)
                {
                    ppProcess = process;
                    break;
                }
            }

            return Utility.COM_HResults.BOOL_TO_HRESULT_FAIL( ppProcess != null ); /*better failure?*/
        }

 void ICorDebugManagedCallback.ExitAppDomain(
                            ICorDebugProcess process,
                            ICorDebugAppDomain appDomain)
 {
     HandleEvent(ManagedCallbackType.OnAppDomainExit,
                       new CorAppDomainEventArgs( process == null ? null : CorProcess.GetCorProcess(process),
                                                  appDomain == null ? null : new CorAppDomain(appDomain),
                                                  ManagedCallbackType.OnAppDomainExit));
 }

 void ICorDebugManagedCallback.ControlCTrap(ICorDebugProcess process)
 {
     HandleEvent(ManagedCallbackType.OnControlCTrap,
                       new CorProcessEventArgs( process == null ? null : CorProcess.GetCorProcess(process),
                                                ManagedCallbackType.OnControlCTrap));
 }

 void ICorDebugManagedCallback.DebuggerError(
                            ICorDebugProcess process,
                            int errorHR,
                            uint errorCode)
 {
     HandleEvent(ManagedCallbackType.OnDebuggerError,
                       new CorDebuggerErrorEventArgs( process == null ? null : CorProcess.GetCorProcess(process),
                                                      errorHR,
                                                      (int)errorCode,
                                                      ManagedCallbackType.OnDebuggerError));
 }

 void ICorDebugManagedCallback2.ChangeConnection(ICorDebugProcess process, uint connectionId)
 {
     Debug.Assert(false);
 }

		public void ChangeConnection(ICorDebugProcess pProcess, uint dwConnectionId)
		{
			EnterCallback("ChangeConnection", pProcess);
			
			ExitCallback();
		}

 private CorProcess(ICorDebugProcess process)
     : base(process)
 {
 }

 public DnAppDomain TryGetValidAppDomain(ICorDebugProcess comProcess, ICorDebugAppDomain comAppDomain)
 {
     DebugVerifyThread();
     var process = TryGetValidProcess(comProcess);
     if (process == null)
         return null;
     return process.TryGetValidAppDomain(comAppDomain);
 }

 /// <summary>
 /// Gets a process or null if it has exited
 /// </summary>
 /// <param name="comProcess">Process</param>
 /// <returns></returns>
 public DnProcess TryGetValidProcess(ICorDebugProcess comProcess)
 {
     DebugVerifyThread();
     var process = processes.TryGet(comProcess);
     if (process == null)
         return null;
     if (!process.CheckValid())
         return null;
     return process;
 }