public CorNativeStopEventArgs(CorProcess process,
                               int threadId,
                               IntPtr debugEvent,
                               bool isOutOfBand,
                               ManagedCallbackType callbackType)
     : base(process, callbackType)
 {
     m_threadId = threadId;
     m_debugEvent = debugEvent;
     m_isOutOfBand = isOutOfBand;
 }

 public CorAppDomainBaseEventArgs(CorAppDomain ad, ManagedCallbackType callbackType)
     : base(ad, callbackType)
 {
 }

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

 protected override void HandleEvent(ManagedCallbackType eventId, CorEventArgs args)
 {
     m_outer.InternalFireEvent(eventId, args);
 }

 public CorProcessEventArgs(CorProcess process, ManagedCallbackType callbackType)
     : base(process, callbackType)
 {
 }

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

 public CorDebuggerErrorEventArgs(CorProcess process, int hresult,
                                   int errorCode, ManagedCallbackType callbackType)
     : base(process, callbackType)
 {
     m_hresult = hresult;
     m_errorCode = errorCode;
 }

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

 public CorModuleEventArgs(CorAppDomain appDomain, CorModule managedModule,
     ManagedCallbackType callbackType)
     : base(appDomain, callbackType)
 {
     m_managedModule = managedModule;
 }

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

 public CorEvalEventArgs(CorAppDomain appDomain, CorThread thread,
                          CorEval eval, ManagedCallbackType callbackType)
     : base(appDomain, thread, callbackType)
 {
     m_eval = eval;
 }

 public CorExceptionEventArgs(CorAppDomain appDomain,
                               CorThread thread,
                               bool unhandled,
                               ManagedCallbackType callbackType)
     : base(appDomain, thread, callbackType)
 {
     m_unhandled = unhandled;
 }

        /**
         * Helper for invoking events.  Checks to make sure that handlers
         * are hooked up to a handler before the handler is invoked.
         *
         * We want to allow maximum flexibility by our callers.  As such,
         * we don't require that they call <code>e.Controller.Continue</code>,
         * nor do we require that this class call it.  <b>Someone</b> needs
         * to call it, however.
         *
         * Consequently, if an exception is thrown and the process is stopped,
         * the process is continued automatically.
         */

        void InternalFireEvent(ManagedCallbackType callbackType, CorEventArgs e)
        {
            CorProcess owner = e.Process;

            Debug.Assert(owner != null);
            try
            {
                owner.DispatchEvent(callbackType, e);
            }
            finally
            {
                // If the callback marked the event to be continued, then call Continue now.
                if (e.Continue)
                {
                    e.Controller.Continue(false);
                }
            }
        }

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

 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 CorFunctionRemapCompleteEventArgs(CorAppDomain appDomain,
                                    CorThread thread,
                                    CorFunction managedFunction,
                                    ManagedCallbackType callbackType
                                    )
     : base(appDomain, thread, callbackType)
 {
     m_managedFunction = managedFunction;
 }

 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 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 CorMDAEventArgs(CorMDA mda, CorThread thread, CorProcess proc,
     ManagedCallbackType callbackType)
     : base(proc, callbackType)
 {
     m_mda = mda;
     Thread = thread;
     //m_proc = proc;
 }

        /**
         * Helper for invoking events.  Checks to make sure that handlers
         * are hooked up to a handler before the handler is invoked.
         *
         * We want to allow maximum flexibility by our callers.  As such,
         * we don't require that they call <code>e.Controller.Continue</code>,
         * nor do we require that this class call it.  <b>Someone</b> needs
         * to call it, however.
         *
         * Consequently, if an exception is thrown and the process is stopped,
         * the process is continued automatically.
         */

        void InternalFireEvent(ManagedCallbackType callbackType,CorEventArgs e)
        {
            CorProcess owner;
            CorController c = e.Controller;
            Debug.Assert(c!=null);
            if(c is CorProcess)
                owner = (CorProcess)c ;
            else 
            {
                Debug.Assert(c is CorAppDomain);
                owner = (c as CorAppDomain).Process;
            }
            Debug.Assert(owner!=null);
            try 
            {
                owner.DispatchEvent(callbackType,e);
            }
            finally
            {
                if(e.Continue)
                {
                        e.Controller.Continue(false);
                }
            }
        }