IHttpModuleRegistrationInfo::SetPriorityForRequestNotification, méthode

Définit la priorité au niveau de la demande pour un module.

Syntaxe

virtual HRESULT SetPriorityForRequestNotification(  
   IN DWORD dwRequestNotification,  
   IN PCWSTR pszPriority  
) = 0;  

Paramètres

dwRequestNotification
[IN] Valeur de masque de bits qui contient les notifications de demande à définir pour le niveau de priorité. (Défini dans Httpserv.h.)

pszPriority
[IN] Pointeur vers une chaîne qui contient l’alias de priorité. (Défini dans Httpserv.h.)

Valeur renvoyée

Élément HRESULT. Les valeurs possibles sont notamment celles figurant dans le tableau suivant.

Remarques

La SetPriorityForRequestNotification méthode définit le niveau de priorité pour une liste de notifications au niveau de la demande pour lesquelles un module HTTP a été inscrit. IIS utilise le niveau de priorité pour déterminer l’ordre dans une notification indiquant que les modules doivent être organisés. Les niveaux de priorité sont inversés pour les notifications CHttpModule::OnSendResponse . Par exemple, un module HTTP qui s’est inscrit pour la notification CHttpModule::OnBeginRequest à l’aide de l’alias PRIORITY_ALIAS_HIGH serait classé par ordre de priorité avant un module inscrit pour la notification à l’aide OnBeginRequest de l’alias PRIORITY_ALIAS_LOW . Un module HTTP inscrit pour la notification à l’aide OnSendResponse de l’alias PRIORITY_ALIAS_HIGH est exécuté après un module inscrit pour la notification à l’aide OnSendResponse de l’alias PRIORITY_ALIAS_LOW .

Exemple

L’exemple suivant montre comment créer un module HTTP qui utilise la fonction RegisterModule et les méthodes suivantes pour inscrire un module pour les notifications de niveau global et de niveau requête.

• La méthode SetRequestNotifications inscrit une classe CHttpModule pour une notification OnBeginRequest au niveau de la demande.

• La SetPriorityForRequestNotification méthode définit la priorité du module pour les notifications au niveau de la demande.

• La méthode SetGlobalNotifications inscrit une classe CGlobalModule pour une notification OnGlobalPreBeginRequest de niveau global.

• La méthode SetPriorityForGlobalNotification définit la priorité du module pour la notification de niveau global.

  Le module répond aux notifications inscrites et écrit des entrées dans le journal de l’application dans le observateur d'événements.

#define _WINSOCKAPI_
#include <windows.h>
#include <sal.h>
#include <httpserv.h>

// Create a global handle for the Event Viewer.
HANDLE g_hEventLog;

// Define the method that writes to the Event Viewer.
BOOL WriteEventViewerLog(LPCSTR szBuffer[], WORD wNumStrings);

// Create the HTTP module class.
class MyHttpModule : public CHttpModule
{
public:
    REQUEST_NOTIFICATION_STATUS
    OnBeginRequest(
        IN IHttpContext * pHttpContext,
        IN IHttpEventProvider * pProvider
    )
    {
        UNREFERENCED_PARAMETER( pHttpContext );
        UNREFERENCED_PARAMETER( pProvider );

        // Create an array of strings.
        LPCSTR szBuffer[2] = {"MyHttpModule","OnBeginRequest"};
        // Write the strings to the Event Viewer.
        WriteEventViewerLog(szBuffer,2);

        // Return processing to the pipeline.
        return RQ_NOTIFICATION_CONTINUE;
    }
};

// Create the module's global class.
class MyGlobalModule : public CGlobalModule
{
public:
    GLOBAL_NOTIFICATION_STATUS
    OnGlobalPreBeginRequest(
        IN IPreBeginRequestProvider * pProvider
    )
    {
        UNREFERENCED_PARAMETER( pProvider );
        
        // Create an array of strings.
        LPCSTR szBuffer[2] = {"MyGlobalModule","OnGlobalPreBeginRequest"};
        // Write the strings to the Event Viewer.
        WriteEventViewerLog(szBuffer,2);

        // Return processing to the pipeline.
        return GL_NOTIFICATION_CONTINUE;
    }

    VOID Terminate()
    {
        // Remove the class from memory.
        delete this;
    }

    MyGlobalModule()
    {
        // Open a handle to the Event Viewer.
        g_hEventLog = RegisterEventSource( NULL,"IISADMIN" );
    }

    ~MyGlobalModule()
    {
        // Test whether the handle for the Event Viewer is open.
        if (NULL != g_hEventLog)
        {
            DeregisterEventSource( g_hEventLog );
            g_hEventLog = NULL;
        }
    }
};

// Create the module's class factory.
class MyHttpModuleFactory : public IHttpModuleFactory
{
public:
    HRESULT
    GetHttpModule(
        OUT CHttpModule ** ppModule, 
        IN IModuleAllocator * pAllocator
    )
    {
        UNREFERENCED_PARAMETER( pAllocator );

        // Create a new instance.
        MyHttpModule * pModule = new MyHttpModule;

        // Test for an error.
        if (!pModule)
        {
            // Return an error if the factory cannot create the instance.
            return HRESULT_FROM_WIN32( ERROR_NOT_ENOUGH_MEMORY );
        }
        else
        {
            // Return a pointer to the module.
            *ppModule = pModule;
            pModule = NULL;
            // Return a success status.
            return S_OK;
        }            
    }

    void Terminate()
    {
        // Remove the class from memory.
        delete this;
    }
};

// Define a method that writes to the Event Viewer.
BOOL WriteEventViewerLog(LPCSTR szBuffer[], WORD wNumStrings)
{
    // Test whether the handle for the Event Viewer is open.
    if (NULL != g_hEventLog)
    {
        // Write any strings to the Event Viewer and return.
        return ReportEvent(
            g_hEventLog,
            EVENTLOG_INFORMATION_TYPE,
            0, 0, NULL, wNumStrings,
            0, szBuffer, NULL );
    }
    return FALSE;
}

// Create the module's exported registration function.
HRESULT
__stdcall
RegisterModule(
    DWORD dwServerVersion,
    IHttpModuleRegistrationInfo * pModuleInfo,
    IHttpServer * pGlobalInfo
)
{
    UNREFERENCED_PARAMETER( dwServerVersion );
    UNREFERENCED_PARAMETER( pGlobalInfo );

    // Create an HRESULT to receive return values from methods.
    HRESULT hr;

    // Set the request notifications.
    hr = pModuleInfo->SetRequestNotifications(
        new MyHttpModuleFactory,
        RQ_BEGIN_REQUEST, 0 );

    // Test for an error and exit if necessary.
    if (FAILED(hr))
    {
        return hr;
    }

    // Set the request priority.
    hr = pModuleInfo->SetPriorityForRequestNotification(
        RQ_BEGIN_REQUEST,PRIORITY_ALIAS_MEDIUM);

    // Test for an error and exit if necessary.
    if (FAILED(hr))
    {
        return hr;
    }

    // Create an instance of the global module class.
    MyGlobalModule * pGlobalModule = new MyGlobalModule;
 
    // Test for an error.
    if (NULL == pGlobalModule)
    {
        return HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
    }
 
    // Set the global notifications.
    hr = pModuleInfo->SetGlobalNotifications(
        pGlobalModule, GL_PRE_BEGIN_REQUEST );

    // Test for an error and exit if necessary.
    if (FAILED(hr))
    {
        return hr;
    }

    // Set the global priority.
    hr = pModuleInfo->SetPriorityForGlobalNotification(
        GL_PRE_BEGIN_REQUEST,PRIORITY_ALIAS_LOW);

    // Test for an error and exit if necessary.
    if (FAILED(hr))
    {
        return hr;
    }

    // Return a success status;
    return S_OK;
}

Votre module doit exporter la RegisterModule fonction. Vous pouvez exporter cette fonction en créant un fichier de définition de module (.def) pour votre projet, ou vous pouvez compiler le module à l’aide du /EXPORT:RegisterModule commutateur. Pour plus d’informations, consultez Procédure pas à pas : création d’un module HTTP Request-Level à l’aide de code natif.

Vous pouvez éventuellement compiler le code à l’aide de la __stdcall (/Gz) convention d’appel au lieu de déclarer explicitement la convention d’appel pour chaque fonction.

Spécifications

Voir aussi

IHttpModuleRegistrationInfo, interface
IHttpModuleRegistrationInfo::SetGlobalNotifications, méthode
IHttpModuleRegistrationInfo::SetPriorityForGlobalNotification, méthode
IHttpModuleRegistrationInfo::SetRequestNotifications, méthode
fonction PFN_REGISTERMODULE