Monitoraggio di applicazioni

Gli elementi API della libreria DDEML (Dynamic Data Exchange Management Library) possono essere usati per creare un'applicazione che monitora l'attività DDE (Dynamic Data Exchange) nel sistema. Come qualsiasi applicazione DDEML, un'applicazione di monitoraggio DDE contiene una funzione di callback DDE. DDEML invia una notifica alla funzione di callback DDE di un'applicazione di monitoraggio ogni volta che si verifica un evento DDE, passando informazioni sull'evento alla funzione di callback. L'applicazione visualizza in genere le informazioni in una finestra o le scrive in un file.

Per ricevere notifiche da DDEML, è necessario che un'applicazione sia registrata come monitor DDE specificando il flag APPCLASS_MONITOR in una chiamata alla funzione DdeInitialize. In questa stessa chiamata, l'applicazione può specificare uno o più flag di monitoraggio per indicare i tipi di eventi per cui dDEML deve notificare alla funzione di callback dell'applicazione. I flag di monitoraggio seguenti possono essere specificati da un'applicazione:

L'esempio seguente illustra come registrare un'applicazione di monitoraggio DDE in modo che la relativa funzione di callback DDE riceva le notifiche di tutti gli eventi DDE.

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; 
}

DDEML informa un'applicazione di monitoraggio di un evento DDE inviando una transazione XTYP_MONITOR alla funzione di callback DDE dell'applicazione. Durante questa transazione, DDEML passa un flag di monitoraggio che specifica il tipo di evento DDE che si è verificato e un handle a un oggetto DDE che contiene informazioni dettagliate sull'evento. DDEML fornisce un set di strutture che l'applicazione può usare per estrarre le informazioni dall'oggetto DDE. Esiste una struttura corrispondente per ogni tipo di evento DDE.

Nell'esempio seguente viene illustrata la funzione di callback DDE di un'applicazione di monitoraggio DDE che formatta informazioni su ogni evento di handle di stringa e quindi visualizza le informazioni in una finestra. La funzione usa la struttura MONHSZSTRUCT per estrarre le informazioni dall'oggetto DDE.

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; 
}