C# IDebugEvent2.GetAttributes方法代码示例

    public void Send(IDebugEvent2 eventObject, string iidEvent, IDebugProgram2 program, IDebugThread2 thread) {
      uint attributes;
      var riidEvent = new Guid(iidEvent);

      EngineUtils.RequireOk(eventObject.GetAttributes(out attributes));
      EngineUtils.RequireOk(m_ad7Callback.Event(m_engine, null, program, thread, eventObject, ref riidEvent, attributes));
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    public void Broadcast (IDebugEventCallback2 callback, IDebugEvent2 debugEvent, IDebugProgram2 program, IDebugThread2 thread)
    {
      LoggingUtils.PrintFunction ();

      if (callback == null)
      {
        throw new ArgumentNullException ("callback");
      }

      Guid eventGuid = ComUtils.GuidOf (debugEvent);

      uint eventAttributes = 0;

      LoggingUtils.RequireOk (debugEvent.GetAttributes (out eventAttributes));

      if (((eventAttributes & (uint) enum_EVENTATTRIBUTES.EVENT_STOPPING) != 0) && (thread == null))
      {
        throw new ArgumentNullException ("thread", "For stopping events, this parameter cannot be a null value as the stack frame is obtained from this parameter.");
      }

      try
      {
        int handle = callback.Event (this, null, program, thread, debugEvent, ref eventGuid, eventAttributes);

        if (handle != Constants.E_NOTIMPL)
        {
          LoggingUtils.RequireOk (handle);
        }
      }
      catch (Exception e)
      {
        LoggingUtils.HandleException (e);

        throw;
      }
      finally
      {
        if ((eventAttributes & (uint) enum_EVENTATTRIBUTES.EVENT_SYNCHRONOUS) != 0)
        {
          while (!m_broadcastHandleLock.WaitOne (0))
          {
            Thread.Sleep (100);
          }
        }
      }
    }

        internal void Send(IDebugEvent2 eventObject, string iidEvent, IDebugProgram2 program)
        {
            uint attributes;
            Guid riidEvent = new Guid(iidEvent);

            EngineUtils.RequireOk(eventObject.GetAttributes(out attributes));

            Debug.WriteLine(string.Format("Sending Event: {0} {1}", eventObject.GetType(), iidEvent));
            try
            {
                EngineUtils.RequireOk(events.Event(this, debugProcess, this, debugThread, eventObject, ref riidEvent, attributes));
            }
            catch (InvalidCastException)
            {
                // COM object has gone away
            }
        }

        internal void Send(IDebugEvent2 eventObject, string iidEvent, IDebugProgram2 program, IDebugThread2 thread) {
            LiveLogger.WriteLine("AD7Engine Event: {0} ({1})", eventObject.GetType(), iidEvent);

            // Check that events was not disposed
            var events = _events;
            if (events == null) {
                return;
            }

            uint attributes;
            var riidEvent = new Guid(iidEvent);

            EngineUtils.RequireOk(eventObject.GetAttributes(out attributes));

            if ((attributes & (uint)enum_EVENTATTRIBUTES.EVENT_STOPPING) != 0 && thread == null) {
                Debug.Fail("A thread must be provided for a stopping event");
                return;
            }

            try {
                EngineUtils.RequireOk(events.Event(this, null, program, thread, eventObject, ref riidEvent, attributes));
            } catch (InvalidCastException) {
                // COM object has gone away
            }
        }

 protected virtual void OnDebugEvent( IDebugEvent2 eventObject,
     Guid iidEvent,
     IDebugProgram2 program = null,
     IDebugThread2 thread = null,
     IDebugProcess2 process = null)
 {
     uint attributes;
     eventObject.GetAttributes( out attributes );
     DebugEventCallback.Event( DebugEngineBase, process, program, thread, eventObject, ref iidEvent, attributes );
 }

        internal void Send(IDebugEvent2 eventObject, string iidEvent, IDebugProgram2 program, IDebugThread2 thread) {
            var events = _events;
            if (events == null) {
                return;
            }

            uint attributes;
            var riidEvent = new Guid(iidEvent);
            Marshal.ThrowExceptionForHR(eventObject.GetAttributes(out attributes));

            if ((attributes & (uint)enum_EVENTATTRIBUTES.EVENT_STOPPING) != 0 && thread == null) {
                throw new InvalidOperationException("A thread must be provided for a stopping event");
            }

            try {
                Marshal.ThrowExceptionForHR(events.Event(this, null, program, thread, eventObject, ref riidEvent, attributes));
            } catch (InvalidCastException) {
                // COM object has gone away.
            }
        }

        /// <summary>
        /// Send events to the debugger.
        /// </summary>
        /// <param name="eventObject"> Event object to be sent to the debugger. </param>
        /// <param name="iidEvent"> ID of the event. </param>
        /// <param name="program"> A program that is running in a process. </param>
        /// <param name="thread"> A thread running in a program. </param>
        public void Send(IDebugEvent2 eventObject, string iidEvent, IDebugProgram2 program, IDebugThread2 thread)
        {
            uint attributes;
            Guid riidEvent = new Guid(iidEvent);

            EngineUtils.RequireOk(eventObject.GetAttributes(out attributes));

            if ((thread == null) && (m_engine != null) && (m_engine.thread != null) && (program != null) && (eventObject != null) && (riidEvent != null) && (attributes != null))
            {
                if (m_engine._currentThreadIndex != -1)
                {
                    EngineUtils.RequireOk(m_ad7Callback.Event(m_engine, null, program, m_engine.thread[m_engine._currentThreadIndex], eventObject, ref riidEvent, attributes));
                }
                else
                {
                    if (m_engine.thread != null)
                        EngineUtils.RequireOk(m_ad7Callback.Event(m_engine, null, program, m_engine.thread[0], eventObject, ref riidEvent, attributes));
                    else
                        EngineUtils.RequireOk(m_ad7Callback.Event(m_engine, null, program, null, eventObject, ref riidEvent, attributes));
                }
            }
            else
                EngineUtils.RequireOk(m_ad7Callback.Event(m_engine, null, program, thread, eventObject, ref riidEvent, attributes));
        }

        public int Event(IDebugEngine2 pEngine, 
            IDebugProcess2 pProcess, 
            IDebugProgram2 pProgram, 
            IDebugThread2 pThread, 
            IDebugEvent2 pEvent, 
            ref Guid riidEvent, 
            uint dwAttrib)
        {
            try
            {
                string threadName = null;
                if (pThread != null && pEvent != null)
                {
                    uint attributes;

                    pEvent.GetAttributes(out attributes);
                    if ( (uint)enum_EVENTATTRIBUTES.EVENT_SYNC_STOP == attributes)
                    {
                        //HandleException.PrintFrames(pThread);
                    }

                    pThread.GetName(out threadName);
                    //ExtractFrameContent(pThread);
                    //IEnumDebugFrameInfo2 ppEnum = null;
                }
                Trace.WriteLine(string.Format("Event {0} Thread {1}",  riidEvent, threadName ));

                if (typeof(IDebugInterceptExceptionCompleteEvent2).GUID == riidEvent)
                {
                    var interactionEvent = pEvent as IDebugInterceptExceptionCompleteEvent2;
                    ulong cookie;
                    interactionEvent.GetInterceptCookie(out cookie);

                    // another way to get code path:
                    //pProgram.EnumCodePaths(
                    var exceptionInfo = HandleException.PrintFrames(pThread);
                    if (exceptionInfo != null)
                    {
                        if (exceptionInfo.ExceptionKind == null)
                        {
                            exceptionInfo.ExceptionKind = LastExceptionType;
                        }
                        if (exceptionInfo.ExceptionMessage == null)
                        {
                            exceptionInfo.ExceptionMessage = LastExceptionMessage;
                        }
                        SaveToDb(exceptionInfo);
                    }
                }
                //HandleException.ProcessEvent(riidEvent, pThread);

                if (typeof(IDebugProgramCreateEvent2).GUID == riidEvent)
                {
                    // Add handle

                }

                //if (typeof(IDebugBreakEvent2).GUID == riidEvent)
                if(typeof(IDebugBreakpointEvent2).GUID == riidEvent)
                {
                    // Might be interesting to get the statement line number here and emit.
                    //var ev = pEvent as IDebugBreakEvent2;
                    var ev = pEvent as IDebugBreakpointEvent2;
                    var info = HandleException.ProcessEvent(riidEvent, pThread);
                    if (info != null)
                    {
                        SaveToDb(info);
                    }
                }

                if (riidEvent == typeof(IDebugEntryPointEvent2).GUID)
                {
                    // This is when execution is just about to the start.

                    // I can't get the reference to the engine, pEngine is always null, and
                    // there doesn't seem to be an interface to fetch it (there is a query interface in docs, but not in dll!)

                    //string engineStr; Guid engineGuid;
                    //pProgram.GetEngineInfo(out engineStr, out engineGuid);
                    //var superEngine = pEngine as IDebugEngine3;
                    //if (superEngine != null)
                    //{
                    //    superEngine.SetAllExceptions(enum_EXCEPTION_STATE.EXCEPTION_STOP_FIRST_CHANCE);
                    //}
                }
                else if (riidEvent == typeof(IDebugMessageEvent2).GUID)
                {
                    var ev = pEvent as IDebugMessageEvent2;
                    var str = ""; uint type; string helpFile; uint helpId;
                    var suc = ev.GetMessage(new enum_MESSAGETYPE[] { enum_MESSAGETYPE.MT_REASON_EXCEPTION }, out str, out type, out helpFile, out helpId);
                    //uint messageType;
                    //var suc = ev.GetMessage( out messageType, out str, out type, out helpFile, out helpId);
                    if (suc == VSConstants.S_OK)
                    {
                        if (str.StartsWith("A first chance exception of type"))
                        {
                            if (pThread != null)
                            {
                                //ExtractFrameContent(pThread);
                                //HandleException.PrintFrames(pThread);
//.........这里部分代码省略.........