C# Results.FindInt方法代码示例

        public async Task<bool> Stopped(Results results, int tid)
        {
            string reason = results.TryFindString("reason");
            ThreadProgress s = StateFromTid(tid);

            if (reason == "fork")
            {
                s = new ThreadProgress();
                s.State = State.AtFork;
                s.Newpid = results.FindInt("newpid");
                _threadStates[tid] = s;
                await _process.Step(tid, VisualStudio.Debugger.Interop.enum_STEPKIND.STEP_OUT, VisualStudio.Debugger.Interop.enum_STEPUNIT.STEP_LINE);
                return true;
            }
            else if (reason == "vfork")
            {
                s = new ThreadProgress();
                s.State = State.AtVfork;
                s.Newpid = results.FindInt("newpid");
                _threadStates[tid] = s;
                await _process.MICommandFactory.SetOption("schedule-multiple", "on");
                await _process.MICommandFactory.Catch("exec", onlyOnce: true);
                var thread = await _process.ThreadCache.GetThread(tid);
                await _process.Continue(thread);
                return true;
            }

            if (s == null)
            {
                return false;   // no activity being tracked on this thread
            }

            switch (s.State)
            {
                case State.AtFork:
                    await ProcessChild(s);
                    break;
                case State.AtVfork:
                    await _process.MICommandFactory.SetOption("schedule-multiple", "off");
                    if ("exec" == results.TryFindString("reason"))
                    {
                        // The process doesn't handle the SIGSTOP correctly (just ignores it) when the process is at the start of program 
                        // (after exec). Let it run some code so that it will correctly respond to the SIGSTOP.
                        s.Exe = results.TryFindString("new-exec");
                        await RunChildToMain(s);
                    }
                    else
                    {
                        // sometimes gdb misses the breakpoint at exec and execution will proceed to a breakpoint in the child
                        _process.Logger.WriteLine("Missed catching the exec after vfork. Spawning the child's debugger.");
                        s.State = State.AtExec;
                        goto missedExec;
                    }
                    break;
                case State.AtSignal:    // both child and parent are stopped
                    s.State = State.Complete;
                    return await DetachAndContinue(s);
                case State.AtExec:
                missedExec:
                    if (tid == s.Newtid)    // stopped in the child
                    {
                        await ProcessChild(s);
                    }
                    else // sometime the parent will get a spurious signal before the child hits main
                    {
                        await ContinueTheChild(s);
                    }
                    break;
                case State.Complete:
                    _threadStates.Remove(tid);
                    if (reason == "signal-received" && results.TryFindString("signal-name") == "SIGSTOP")
                    {
                        // SIGSTOP was propagated to the parent
                        await _process.MICommandFactory.Signal("SIGCONT");
                        return true;
                    }
                    return false;
                default:
                    return false;
            }
            return true;
        }

 public void ThreadCreatedEvent(Results evnt)
 {
     int tid = evnt.FindInt("id");
     string groupId = evnt.FindString("group-id");
     int pid = _process.PidByInferior(groupId);
     foreach (var p in _threadStates)
     {
         if (p.Value.Newpid == pid)
         {
             p.Value.Newtid = tid;
         }
     }
 }