IDebugProgramProvider2::WatchForProviderEventsIDebugProgramProvider2::WatchForProviderEvents

Permite que o processo ser notificado de eventos de porta.Allows the process to be notified of port events.

SintaxeSyntax

HRESULT WatchForProviderEvents(
   PROVIDER_FLAGS       Flags,
   IDebugDefaultPort2*  pPort,
   AD_PROCESS_ID        processId,
   CONST_GUID_ARRAY     EngineFilter,
   REFGUID              guidLaunchingEngine,
   IDebugPortNotify2*   pEventCallback
);
int WatchForProviderEvents(
   enum_PROVIDER_FLAGS   Flags,
   IDebugDefaultPort2    pPort,
   AD_PROCESS_ID         ProcessId,
   CONST_GUID_ARRAY      EngineFilter,
   ref Guid              guidLaunchingEngine,
   IDebugPortNotify2     pEventCallback
);

ParâmetrosParameters

Flags
[in] Uma combinação de sinalizadores do PROVIDER_FLAGS enumeração.[in] A combination of flags from the PROVIDER_FLAGS enumeration. Os sinalizadores a seguir são típicos para essa chamada:The following flags are typical for this call:

SinalizadorFlag DescriçãoDescription
PFLAG_REMOTE_PORT Chamador está em execução no computador remoto.Caller is running on remote machine.
PFLAG_DEBUGGEE Chamador está atualmente em depuração (informações adicionais sobre a realização de marshaling serão retornadas para cada nó).Caller is currently being debugged (additional information about marshalling is returned for each node).
PFLAG_ATTACHED_TO_DEBUGGEE Chamador foi anexado ao, mas não é iniciado pelo depurador.Caller was attached to but not launched by the debugger.
PFLAG_REASON_WATCH Chamador deseja observar eventos.Caller wants to watch for events. Se este sinalizador não for definido.If this flag is not set. em seguida, o evento de retorno de chamada é removido e o chamador não recebe notificações.then the callback event is removed and the caller no longer receives notifications.

pPort
[in] A porta que o processo de chamada está em execução.[in] The port the calling process is running on.

processId
[in] Uma AD_PROCESS_ID estrutura que contém a ID do processo que contém o programa em questão.[in] An AD_PROCESS_ID structure holding the ID of the process that contains the program in question.

EngineFilter
[in] Uma matriz de GUIDs de mecanismos de depuração associados com o processo.[in] An array of GUIDs of debug engines associated with the process.

guidLaunchingEngine
[in] GUID do mecanismo de depuração que iniciou esse processo (se houver).[in] GUID of the debug engine that launched this process (if any).

pEventCallback
[in] Uma IDebugPortNotify2 objeto que recebe as notificações de eventos.[in] An IDebugPortNotify2 object that receives the event notifications.

Valor de retornoReturn Value

Se for bem-sucedido, retornará S_OK; caso contrário, retorna um código de erro.If successful, returns S_OK; otherwise, returns an error code.

ComentáriosRemarks

Quando um chamador quiser remover um manipulador de eventos que foi estabelecido com uma chamada anterior a esse método, o chamador passa os mesmos parâmetros, como ele fez na primeira vez, mas deixa desativar o PFLAG_REASON_WATCH sinalizador.When a caller wants to remove an event handler that was established with a previous call to this method, the caller passes the same parameters as it did the first time but leaves off the PFLAG_REASON_WATCH flag.

ExemploExample

O exemplo a seguir mostra como implementar esse método para um CDebugEngine objeto que expõe a IDebugProgramProvider2 interface.The following example shows how to implement this method for a CDebugEngine object that exposes the IDebugProgramProvider2 interface.

STDMETHODIMP CDebugEngine::WatchForProviderEvents(
    PROVIDER_FLAGS Flags,
    IDebugDefaultPort2 *pPort,
    AD_PROCESS_ID processId,
    CONST_GUID_ARRAY EngineFilter,
    REFGUID guidLaunchingEngine,
    IDebugPortNotify2 *pPortNotify)
{
    HRESULT hRes = E_FAIL;

    if (EVAL(pPort != NULL) && EVAL(pPortNotify != NULL))
    {
        // We will only watch/send events about the process if the debugger
        // is actually debugging the process, and only if this is an attach or a LoRIE launch
        if (IsFlagSet(Flags, PFLAG_DEBUGGEE) &&
            guidLaunchingEngine == GUID_NULL &&
            processId.ProcessIdType == AD_PROCESS_ID_SYSTEM)
        {
            // We don't support WatchForProviderEvents when in interop mode
            if (m_fInterop)
            {
                ASSERT(!"Shouldn't ever be called in interop mode");
                hRes = E_FAIL;
            }
            else
            {
                if (IsFlagSet(Flags, PFLAG_REASON_WATCH))
                {
                    // QI to get IDebugEventCallback2 which is required.
                    CComQIPtr<IDebugEventCallback2> pCallback(pPortNotify);

                    ASSERT(pCallback != NULL);
                    if ( pCallback != NULL )
                    {
                        // Register the callback
                        hRes = this->InitDebugSession(pCallback);

                        if ( S_OK == hRes )
                        {
                            // Get the IDebugProcess2 from the port and call AttachImpl
                            CComPtr<IDebugProcess2> spProcess;

                            hRes = pPort->GetProcess(processId, &spProcess);

                            if (HREVAL(S_OK, hRes))
                            {
                                hRes = AttachImpl(spProcess, NULL, NULL, processId.ProcessId.dwProcessId, ATTACH_REASON_USER, NULL);

                                if ( FAILED(hRes) && (!m_pPidList || 0 == m_pPidList->GetCount()) )
                                    this->Cleanup();
                            }
                        }
                        else
                            this->Cleanup();
                    }
                    else
                        hRes = E_FAIL;
                }
                else
                {
                    // Detach will be done by SDM calling on programs directly if there are managed programs.

                    // This handling is the case where no managed code ever ran.
                    if ( this->IsProcessBeingDebugged(processId.ProcessId.dwProcessId) )
                    {
                        ProgramList *pProgList = this->GetProgramListCopy();

                        if ( EVAL(pProgList) )
                        {
                            if ( pProgList->GetCount() == 0)
                            {
                                CComPtr<ICorDebugProcess> pCorProcess;

                                hRes = this->GetCorProcess(processId.ProcessId.dwProcessId, &pCorProcess);

                                if (HREVAL(S_OK, hRes) )
                                {
                                    hRes = pCorProcess->Stop(INFINITE);

                                    if ( HREVAL(S_OK, hRes) )
                                        hRes = pCorProcess->Detach();
                                }

                                // Tell the engine that it should unregister this process from com+
                                this->UnregisterProcess(processId.ProcessId.dwProcessId);

                                // If there are no more pids left then cleanup everything.
                                if ( 0 == m_pPidList->GetCount() )
                                    this->Cleanup();
                            }
                            // This is needed for cases where the SDM has not yet received program create
                            // by the time that we need to detach (example: the managed attach succeeds,
                            // but some other attach step fails).
                            else
                            {
                                PROGNODE *pProgNode = NULL;
                                while ( pProgNode = pProgList->Next(pProgNode) )
                                {
                                    CDebugProgram * pProgram = ((CDebugProgram *)pProgNode->data);
                                    hRes = pProgram->Detach();
                                }
                            }

                            delete pProgList;
                        }
                    }
                    else
                        hRes = S_OK;
                }
            }
        }
        else
        {
            hRes = S_FALSE;
        }
    }
    else
    {
        hRes = E_INVALIDARG;
    }

    return hRes;
}

Consulte tambémSee also