Delen via

Het programma registreren

Nadat de foutopsporingsengine een poort heeft verkregen, vertegenwoordigd door een IDebugPort2-interface , is de volgende stap in het inschakelen van foutopsporing in het programma om het te registreren bij de poort. Zodra het programma is geregistreerd, is het beschikbaar voor foutopsporing op een van de volgende manieren:

  • Het proces van koppelen, waardoor het foutopsporingsprogramma volledige controle over foutopsporing van een actieve toepassing kan krijgen.

  • Just-In-Time-foutopsporing (JIT) waarmee fouten na de uitvoering kunnen worden opgespoord in een programma dat onafhankelijk van een debugger wordt uitgevoerd. Wanneer de runtimearchitectuur een fout onderschept, wordt de debugger gewaarschuwd voordat het besturingssysteem of de runtime-omgeving het geheugen en de resources van het foutieve programma vrijgeeft.

Registratieprocedure

Uw programma registreren

  1. Roep de methode AddProgramNode aan die door de poort is geïmplementeerd.

    IDebugPortNotify2::AddProgramNode vereist een aanwijzer naar een IDebugProgramNode2-interface .

    Meestal wordt het programmaknooppunt gemaakt wanneer het besturingssysteem of de runtimeomgeving een programma laadt. Als de foutopsporingsengine (DE) wordt gevraagd het programma te laden, maakt en registreert de DE het programmaknooppunt.

    In het volgende voorbeeld ziet u de foutopsporingsengine die het programma start en registreert bij een poort.

    Opmerking

    Dit codevoorbeeld is niet de enige manier om een proces te starten en hervatten; deze code is voornamelijk een voorbeeld van het registreren van een programma met een poort.

    // This is an IDebugEngineLaunch2 method.
HRESULT CDebugEngine::LaunchSuspended(/* omitted parameters */,
                                      IDebugPort2 *pPort,
                                      /* omitted parameters */,
                                      IDebugProcess2**ppDebugProcess)
{
    // do stuff here to set up for a launch (such as handling the other parameters)
    ...

    // Now get the IPortNotify2 interface so we can register a program node
    // in CDebugEngine::ResumeProcess.
    CComPtr<IDebugDefaultPort2> spDefaultPort;
    HRESULT hr = pPort->QueryInterface(&spDefaultPort);
    if (SUCCEEDED(hr))
    {
        CComPtr<IDebugPortNotify2> spPortNotify;
        hr = spDefaultPort->GetPortNotify(&spPortNotify);
        if (SUCCEEDED(hr))
        {
            // Remember the port notify so we can use it in ResumeProcess.
            m_spPortNotify = spPortNotify;

            // Now launch the process in a suspended state and return the
            // IDebugProcess2 interface
            CComPtr<IDebugPortEx2> spPortEx;
            hr = pPort->QueryInterface(&spPortEx);
            if (SUCCEEDED(hr))
            {
                // pass on the parameters we were given (omitted here)
                hr = spPortEx->LaunchSuspended(/* omitted parameters */,ppDebugProcess)
            }
        }
    }
    return(hr);
}

HRESULT CDebugEngine::ResumeProcess(IDebugProcess2 *pDebugProcess)
{
    // Make a program node for this process
    HRESULT hr;
    CComPtr<IDebugProgramNode2> spProgramNode;
    hr = this->GetProgramNodeForProcess(pProcess, &spProgramNode);
    if (SUCCEEDED(hr))
    {
        hr = m_spPortNotify->AddProgramNode(spProgramNode);
        if (SUCCEEDED(hr))
        {
            // resume execution of the process using the port given to us earlier.
           // (Querying for the IDebugPortEx2 interface is valid here since
           // that's how we got the IDebugPortNotify2 interface in the first place.)
            CComPtr<IDebugPortEx2> spPortEx;
            hr = m_spPortNotify->QueryInterface(&spPortEx);
            if (SUCCEEDED(hr))
            {
                hr  = spPortEx->ResumeProcess(pDebugProcess);
            }
        }
    }
    return(hr);
}

Verwante inhoud

  • Last updated on