internal MDbgAppDomain(MDbgProcess process, CorAppDomain appDomain, int number)
 {
     Debug.Assert(process != null);
     Debug.Assert(appDomain != null);
     m_process = process;
     m_appDomain = appDomain;
     m_number = number;
 }

 //
 // IEnumerator interface
 //
 public bool MoveNext()
 {
     ICorDebugAppDomain[] a = new ICorDebugAppDomain [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_ad = new CorAppDomain (a[0]);
     else
         m_ad = null;
     return m_ad != null;
 }

 public CorStepCompleteEventArgs(CorAppDomain appDomain, CorThread thread,
                                  CorStepper stepper, CorDebugStepReason stepReason)
     : base(appDomain, thread)
 {
     m_stepper = stepper;
     m_stepReason = stepReason;
 }

 public CorBreakpointEventArgs(CorAppDomain appDomain,
                                CorThread thread,
                                CorBreakpoint managedBreakpoint)
     : base(appDomain, thread)
 {
     m_break = managedBreakpoint;
 }

 public CorThreadEventArgs(CorAppDomain appDomain, CorThread thread)
     : base(appDomain != null ? appDomain : thread.AppDomain)
 {
     Thread = thread;
 }

 public CorAppDomainBaseEventArgs(CorAppDomain ad)
     : base(ad)
 {
 }

 public CorAppDomainEventArgs(CorProcess process, CorAppDomain ad)
     : base(process)
 {
     m_ad = ad;
 }

 public CorException2EventArgs(CorAppDomain appDomain,
                               CorThread thread,
                               CorFrame frame,
                               int offset,
                               CorDebugExceptionCallbackType eventType,
                               int flags,
                               ManagedCallbackType callbackType)
     : base(appDomain, thread, callbackType)
 {
     m_frame = frame;
     m_offset = offset;
     m_eventType = eventType;
     m_flags = flags;
 }

 public CorUpdateModuleSymbolsEventArgs(CorAppDomain appDomain,
                                         CorModule managedModule,
                                         IStream stream)
     : base(appDomain, managedModule)
 {
     m_stream = stream;
 }

 public CorLogSwitchEventArgs(CorAppDomain appDomain, CorThread thread,
                               int level, int reason, string logSwitchName, string parentName,
                               ManagedCallbackType callbackType)
     : base(appDomain, thread, callbackType)
 {
     m_level = level;
     m_reason = reason;
     m_logSwitchName = logSwitchName;
     m_parentName = parentName;
 }

 public CorLogMessageEventArgs(CorAppDomain appDomain, CorThread thread,
                                int level, string logSwitchName, string message,
                                ManagedCallbackType callbackType)
     : base(appDomain, thread, callbackType)
 {
     m_level = level;
     m_logSwitchName = logSwitchName;
     m_message = message;
 }

 public CorAssemblyEventArgs(CorAppDomain appDomain,
                              CorAssembly assembly, ManagedCallbackType callbackType)
     : base(appDomain, callbackType)
 {
     m_assembly = assembly;
 }

 public CorClassEventArgs(CorAppDomain appDomain, CorClass managedClass,
     ManagedCallbackType callbackType)
     : base(appDomain, callbackType)
 {
     m_class = managedClass;
 }

 public CorFunctionRemapCompleteEventArgs(CorAppDomain appDomain,
                                    CorThread thread,
                                    CorFunction managedFunction,
                                    ManagedCallbackType callbackType
                                    )
     : base(appDomain, thread, callbackType)
 {
     m_managedFunction = managedFunction;
 }

 public CorExceptionUnwind2EventArgs(CorAppDomain appDomain, CorThread thread,
                                     CorDebugExceptionUnwindCallbackType eventType,
                                     int flags,
                                     ManagedCallbackType callbackType)
     : base(appDomain, thread, callbackType)
 {
     m_eventType = eventType;
     m_flags = flags;
 }

 // Get process from controller 
 static private CorProcess GetProcessFromController(ICorDebugController pController)
 {
     CorProcess p;
     ICorDebugProcess p2 = pController as ICorDebugProcess;
     if (p2 != null)
     {
         p = CorProcess.GetCorProcess(p2);
     }
     else
     {
         ICorDebugAppDomain a2 = (ICorDebugAppDomain)pController;
         p = new CorAppDomain(a2).Process;
     }
     return p;
 }

 public CorEditAndContinueRemapEventArgs(CorAppDomain appDomain,
                                 CorThread thread,
                                 CorFunction managedFunction,
                                 int accurate,
                                 ManagedCallbackType callbackType)
     : base(appDomain, thread, callbackType)
 {
     m_managedFunction = managedFunction;
     m_accurate = accurate;
 }

 public CorBreakpointSetErrorEventArgs(CorAppDomain appDomain,
                                 CorThread thread,
                                 CorBreakpoint breakpoint,
                                 int errorCode)
     : base(appDomain, thread)
 {
     m_breakpoint = breakpoint;
     m_errorCode = errorCode;
 }

 public CorFunctionRemapOpportunityEventArgs(CorAppDomain appDomain,
                                    CorThread thread,
                                    CorFunction oldFunction,
                                    CorFunction newFunction,
                                    int oldILoffset
                                    )
     : base(appDomain, thread)
 {
     m_oldFunction = oldFunction;
     m_newFunction = newFunction;
     m_oldILoffset = oldILoffset;
 }