Überwachen von Anwendungen

Die API-Elemente der Dynamic Data Exchange Management Library (DDEML) können verwendet werden, um eine Anwendung zu erstellen, die DDE-Aktivitäten (Dynamic Data Exchange) im System überwacht. Wie jede DDEML-Anwendung enthält auch eine DDE-Überwachungsanwendung eine DDE-Rückruffunktion. Die DDEML benachrichtigt die DDE-Rückruffunktion einer Überwachungsanwendung, wenn ein DDE-Ereignis auftritt, und übergibt Informationen zum Ereignis an die Rückruffunktion. Die Anwendung zeigt die Informationen in der Regel in einem Fenster an oder schreibt sie in eine Datei.

Um Benachrichtigungen von der DDEML zu erhalten, muss eine Anwendung als DDE-Monitor registriert sein, indem sie das flag APPCLASS_MONITOR in einem Aufruf der DdeInitialize-Funktion angibt. In diesem Aufruf kann die Anwendung ein oder mehrere Monitorflags angeben, um die Ereignistypen anzugeben, für die die DDEML die Rückruffunktion der Anwendung benachrichtigen soll. Die folgenden Monitorflags können von einer Anwendung angegeben werden:

Flag	Beschreibung
MF_CALLBACKS	Benachrichtigt die Rückruffunktion, wenn eine Transaktion an eine DDE-Rückruffunktion im System gesendet wird.
MF_CONV	Benachrichtigt die Rückruffunktion, wenn eine Konversation eingerichtet oder beendet wird.
MF_ERRORS	Benachrichtigt die Rückruffunktion, wenn ein DDEML-Fehler auftritt.
MF_HSZ_INFO	Benachrichtigt die Rückruffunktion, wenn eine DDEML-Anwendung die Nutzungsanzahl eines Zeichenfolgenhandles erstellt, freigibt oder erhöht oder wenn ein Zeichenfolgenhandle als Ergebnis eines Aufrufs der DdeUninitialize-Funktion freigegeben wird.
MF_LINKS	Benachrichtigt die Rückruffunktion, wenn eine Empfehlungsschleife gestartet oder beendet wird.
MF_POSTMSGS	Benachrichtigt die Rückruffunktion, wenn das System oder eine Anwendung eine DDE-Nachricht sendet.
MF_SENDMSGS	Benachrichtigt die Rückruffunktion, wenn das System oder eine Anwendung eine DDE-Nachricht sendet.

 

Das folgende Beispiel zeigt, wie Sie eine DDE-Überwachungsanwendung registrieren, damit die DDE-Rückruffunktion Benachrichtigungen zu allen DDE-Ereignissen empfängt.

DWORD idInst; 
PFNCALLBACK lpDdeProc; 
hInst = hInstance; 
 
if (DdeInitialize( 
        (LPDWORD) &idInst,  // instance identifier 
        DDECallback,        // pointer to callback function 
        APPCLASS_MONITOR |  // this is a monitoring application 
        MF_CALLBACKS     |  // monitor callback functions 
        MF_CONV          |  // monitor conversation data 
        MF_ERRORS        |  // monitor DDEML errors 
        MF_HSZ_INFO      |  // monitor data handle activity 
        MF_LINKS         |  // monitor advise loops 
        MF_POSTMSGS      |  // monitor posted DDE messages 
        MF_SENDMSGS,        // monitor sent DDE messages 
        0))                 // reserved 
{
    return FALSE; 
}

Die DDEML informiert eine Überwachungsanwendung über ein DDE-Ereignis, indem eine XTYP_MONITOR Transaktion an die DDE-Rückruffunktion der Anwendung gesendet wird. Während dieser Transaktion übergibt die DDEML ein Monitorflag, das den Typ des aufgetretenen DDE-Ereignisses angibt, sowie ein Handle an ein DDE-Objekt, das detaillierte Informationen zum Ereignis enthält. Die DDEML stellt eine Reihe von Strukturen bereit, die die Anwendung verwenden kann, um die Informationen aus dem DDE-Objekt zu extrahieren. Für jeden DDE-Ereignistyp gibt es eine entsprechende Struktur.

Struktur	Beschreibung
MONCBSTRUCT	Enthält Informationen zu einer Transaktion.
MONCONVSTRUCT	Enthält Informationen zu einer Unterhaltung.
MONERRSTRUCT	Enthält Informationen zum aktuellen DDE-Fehler.
MONLINKSTRUCT	Enthält Informationen zu einer Empfehlungsschleife.
MONHSZSTRUCT	Enthält Informationen zu einem Zeichenfolgenhandle.
MONMSGSTRUCT	Enthält Informationen zu einer DDE-Nachricht, die gesendet oder gepostet wurde.

 

Das folgende Beispiel zeigt die DDE-Rückruffunktion einer DDE-Überwachungsanwendung, die Informationen zu jedem Zeichenfolgenhandleereignis formatiert und dann die Informationen in einem Fenster anzeigt. Die Funktion verwendet die MONHSZSTRUCT-Struktur , um die Informationen aus dem DDE-Objekt zu extrahieren.

HDDEDATA CALLBACK DDECallback(uType, uFmt, hconv, hsz1, hsz2, 
    hdata, dwData1, dwData2) 
UINT uType; 
UINT uFmt; 
HCONV hconv; 
HSZ hsz1; 
HSZ hsz2; 
HDDEDATA hdata; 
DWORD dwData1; 
DWORD dwData2; 
{ 
    LPVOID lpData; 
    CHAR *szAction; 
    CHAR szBuf[256]; 
    DWORD cb;
    HRESULT hResult; 
 
    switch (uType) 
    { 
        case XTYP_MONITOR: 
            // Obtain a pointer to the global memory object. 
 
            if (lpData = DdeAccessData(hdata, &cb)) 
            { 
                // Examine the monitor flag. 
 
                switch (dwData2) 
                { 
                    case MF_HSZ_INFO: 
 
#define PHSZS ((MONHSZSTRUCT *)lpData) 
 
                        // The global memory object contains 
                        // string handle data. Use the MONHSZSTRUCT 
                        // structure to access the data. 
 
                        switch (PHSZS->fsAction) 
                        { 
                            // Examine the action flags to determine
                            // the action performed on the handle.
 
                            case MH_CREATE: 
                                szAction = "Created"; 
                                break; 
 
                            case MH_KEEP: 
                                szAction = "Incremented"; 
                                break; 
 
                            case MH_DELETE: 
                                szAction = "Deleted"; 
                                break; 
 
                            case MH_CLEANUP: 
                                szAction = "Cleaned up"; 
                                break; 
 
                            default: 
                                DdeUnaccessData(hdata); 
                                return (HDDEDATA) 0; 
                        } 
 
                        // Write formatted output to a buffer. 
                        hResult = StringCchPrintf(szBuf, 256/sizeof(TCHAR),
                            "Handle %s, Task: %x, Hsz: %lx(%s)", 
                            (LPSTR) szAction, PHSZS->hTask, 
                            PHSZS->hsz, (LPSTR) PHSZS->str);
                        if (FAILED(hResult))
                        {
                        // TO DO: Write error handler.
                            return;
                        } 
                        // Display text or write to a file. 
 
                        break; 
 
#undef PHSZS 
 
                    // Process other MF_* flags. 
 
                    default: 
                        break; 
                } 
            } 
 
            // Free the global memory object. 
 
            DdeUnaccessData(hdata); 
            break; 
 
        default: 
            break; 
    } 
    return (HDDEDATA) 0; 
}