IGlobalRSCAQueryProvider::GetFunctionParameters 메서드

이벤트를 발생시킨 동적 함수 호출의 매개 변수를 반환합니다.

구문

virtual PCWSTR GetFunctionParameters(  
   VOID  
) const = 0;  

매개 변수

이 메서드는 매개 변수를 사용하지 않습니다.

반환 값

이벤트를 발생시킨 동적 함수 호출의 매개 변수를 포함하는 null로 끝나는 상수 유니코드 문자열에 대한 포인터입니다.

설명

GL_RSCA_QUERY 이벤트에 등록하는 CGlobalModule 파생 클래스는 CGlobalModule::OnGlobalRSCAQuery 메서드의 매개 변수로 IGlobalRscaQueryProvidervirtual 포인터를 받습니다. 그런 다음 포인터에서 메서드를 호출하여 함수의 매개 변수를 검색할 GetFunctionParametersIGlobalRSCAQueryProvider 수 있습니다.

메서드의 반환 값은 GetFunctionParameters 구현에 따라 달라집니다. 다음 정보를 지침으로 사용해야 하지만 모든 시나리오에서 올바르지 않을 수 있습니다.

• IProtocolManager, IPmCustomActions, IPmHealthAndIdleMonitor 및 IPmListenerChannelManager 인터페이스의 기본 구현자는 IRSCA_WorkerProcess::EnumerateAppDomains 및 IRSCA_AppDomain::Unload 메서드를 호출할 때 이벤트를 발생합니다. 이러한 메서드는 각각 GetFunctionName 메서드를 호출할 때 반환되는 PMH_App_Domain_Enum_V1 및 PMH_App_Domain_Unload_V1 값에 매핑됩니다. 이 함수의 매개 변수는 를 호출 GetFunctionParameters할 때 반환됩니다.

• IGlobalRSCAQueryProvider 구현자는 IRSCA_AppDomain 이벤트 중 하나가 발생하고 구현자가 이러한 문자열에 대한 참조를 보유할 때 함수 이름 및 함수 매개 변수 값을 문자열로 받습니다. 문자열이 NULL GetFunctionParameters 이면 빈 문자열을 반환합니다. 그렇지 않으면 이 GetFunctionParameters 공유 문자열에 대한 포인터를 반환합니다.

구현자에 대한 참고 사항

IGlobalRSCAQueryProvider구현자는 이 데이터를 사용하여 메모리 관리를 담당합니다. 따라서 IGlobalRSCAQueryProvider 동적 메모리 할당을 사용하는 구현자는 더 이상 필요하지 않은 경우 포인터를 PCWSTR 해제하거나 를 호출 delete 해야 합니다.

호출자 참고 사항

IGlobalRSCAQueryProvider구현자는 이 데이터를 사용하여 메모리 관리를 담당합니다. 따라서 IGlobalRSCAQueryProvider 클라이언트는 이 데이터가 더 이상 필요하지 않을 때 반환 PCWSTR 된 포인터를 해제하거나 를 호출 delete 해서는 안 됩니다. 또한 액세스 위반이 throw되거나 데이터가 유효하지 않으므로 클라이언트는 이 데이터를 가 아닌 const 포인터로 캐스팅하거나 이 PCWSTR에서 참조하는 메모리의 상태를 변경해서는 안 됩니다.

예제

다음 코드 예제에서는 GL_RSCA_QUERY 이벤트를 수신 대기한 다음 함수 매개 변수 정보를 이벤트 뷰어 쓰는 전역 모듈을 만드는 방법을 보여 줍니다.

주의

IIS 7은 이벤트 뷰어 많은 수의 이벤트를 생성합니다. 프로덕션 환경에서 로그 오버플로 오류를 방지하려면 일반적으로 이벤트 로그에 캐시 정보를 쓰지 않아야 합니다. 데모를 위해 이 코드 예제에서는 디버그 모드에서만 이벤트 뷰어 항목을 씁니다.

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

#include <string>
using namespace std;

// The CConvert class mirrors the Convert class that is 
// defined in the .NET Framework. It converts primitives 
// and other data types to wstring types.
class CConvert
{
public:
    // The ToByteString converts a double-byte 
    // character string to a single-byte string.
    // str: the double-byte string to convert.
    // return: a single-byte string copied from str.
    static string ToByteString(const wstring& str)
    {
        // Get the length of the 
        // double-byte string.
        size_t length = str.length();

        // Create a temporary char pointer.
        char* byteChar = new char[length+1];
        byteChar[0] = '\0';
        // Copy the double-byte character string
        // into the single-byte string.        
        size_t charsReturned = 0;
        wcstombs_s(&charsReturned, byteChar, 
                   length+1, str.c_str(), length+1);
        // Create a string to return.
        string retString = byteChar;
        // Delete the temporary string and
        // set that string to NULL.
        delete[] byteChar;
        byteChar = NULL;

        // Return the single-byte string.
        return retString;
    }
};

// The CEventWriter class writes XML 
// documents and strings to the event log.
class CEventWriter
{
public:
    // Creates the CEventWriter class.
    // name: the name of the 
    // event log to open.
    CEventWriter(const wstring& name)
    {                
        #ifdef UNICODE
        m_eventLog = RegisterEventSource(NULL, name.c_str());
        #else
        string multiName = CConvert::ToByteString(name);
        m_eventLog = RegisterEventSource(NULL, multiName.c_str());
        #endif        
    }

    // Creates the destructor for the 
    // CEventWriter class. This destructor
    // closes the HANDLE to the event 
    // log if that HANDLE is open.
    virtual ~CEventWriter()
    {
        // If the HANDLE to the event 
        // log is open, close it.
        if (NULL != m_eventLog)
        {
            // Deregister the event log HANDLE.
            DeregisterEventSource(m_eventLog);
            // Set the HANDLE to NULL.
            m_eventLog = NULL;
        }
    }

    // The ReportInfo method writes 
    // a wstring to the event log.
    // info: the wstring to write.
    // return: true if the event log is written.
    BOOL ReportInfo(const wstring& info)
    {
        return ReportEvent(EVENTLOG_INFORMATION_TYPE, info);
    }
protected:
    // The ReportEvent method accepts an event type
    // and a wstring, and attempts to write that 
    // event to the event log.
    // type: the type of the event.
    // data: the wstring to write to the event log.
    // return: true if the event log is written;
    // otherwise, false.
    BOOL ReportEvent(WORD type, const wstring& data)
    {
        // If the m_eventLog HANDLE 
        // is NULL, return false.
        if (NULL == m_eventLog)
        {
            return FALSE;
        }

        #ifndef _DEBUG
        // If the current build is not debug,
        // return so the event log is not written.
        return TRUE;
        #endif

        #ifdef UNICODE
        // The unicode version of the ReportEvent
        // method requires double-byte strings.
        PCWSTR arr[1];
        arr[0] = data.c_str();
        return ::ReportEvent(m_eventLog,
                             type,
                             0, 0, NULL, 1, 
                             0, arr, (void*)arr);
        #else
        // The non-unicode version of the ReportEvent
        // method requires single-byte strings.
        string multiByte = 
            CConvert::ToByteString(data);
        LPCSTR arr[1];
        arr[0] = multiByte.c_str();
        return ::ReportEvent(m_eventLog,
                             type,
                             0, 0, NULL, 1,
                             0, arr, (void*)arr);
        #endif
    }
private:
    // Specify the HANDLE to the 
    // event log for writing.
    HANDLE m_eventLog;
};

// The CRSCAGlobalModule class creates the CGlobalModule 
// class and registers for GL_RSCA_QUERY and events.
class CRSCAGlobalModule : public CGlobalModule
{
public:
    // Creates the destructor for the 
    // CGlobalCacheModule class.
    virtual ~CRSCAGlobalModule()
    {

    }

    // The RegisterGlobalModule method creates and registers 
    // a new CRSCAGlobalModule for GL_RSCA_QUERY events.
    // dwServerVersion: the current server version.
    // pModuleInfo: the current IHttpModuleRegistrationInfo pointer.
    // pGlobalInfo: the current IHttpServer pointer.
    // return: E_INVALIDARG if the IHttpServer pointer
    // is NULL; ERROR_NOT_ENOUGH_MEMORY if the heap is out of 
    // memory; otherwise, the value from the call to the 
    // SetGlobalNotifications method on the pModuleInfo pointer.
    static HRESULT RegisterGlobalModule
    (
        DWORD dwServerVersion,
        IHttpModuleRegistrationInfo* pModuleInfo,
        IHttpServer* pGlobalInfo
    )
    {        
        // The pGlobalInfo parmeter must be 
        // non-NULL because the constructor 
        // for the CGlobalCacheModule class 
        // requires a non-NULL pointer to a 
        // valid IHttpServer pointer.
        if (NULL == pGlobalInfo)
        {
            return E_INVALIDARG;
        }

        // Create a new CGlobalCacheModule pointer.
        CRSCAGlobalModule* rscaModule = 
            new CRSCAGlobalModule();

        // Return an out-of-memory error 
        // if the traceModule is NULL 
        // after the call to the new operator.
        if (NULL == rscaModule)
        {            
            return HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
        }        

        // Attempt to set global notification 
        // for GL_RSCA_QUERY events by using 
        // the rscaModule as a listener.
        HRESULT hr = pModuleInfo->SetGlobalNotifications
            (rscaModule, GL_RSCA_QUERY);

        // Return the HRESULT from the call to 
        // the SetGlobalNotifications method.
        return hr;
    }

    // The OnGlobalRSCAQuery method is the event 
    // handler method for the GL_RSCA_QUERY event.
    // pProvider: the IGlobalRSCAQueryProvider pointer.
    // return: GL_NOTIFICATION_CONTINUE.
    virtual GLOBAL_NOTIFICATION_STATUS OnGlobalRSCAQuery
    (
        IN IGlobalRSCAQueryProvider* pProvider
    )
    {
        // Return GL_NOTIFICATION_CONTINUE if the
        // IGlobalRSCAQueryProvider pointer is NULL.
        if (NULL == pProvider)
        {
            return GL_NOTIFICATION_CONTINUE;
        }

        // Get the parameters from the 
        // IGlobalRSCAQueryProvider pointer.
        wstring parameters = 
            pProvider->GetFunctionParameters();

        // Write the parameter information
        // to the event writer.
        m_eventWriter.ReportInfo
            (L"Parameters:  " + parameters);

        // Return GL_NOTIFICATION_CONTINUE so
        // other listeners will receive this event.
        return GL_NOTIFICATION_CONTINUE;
    }

    // The Terminate method is a pure virtual 
    // method that all non-abstract CGlobalModule
    // classes must implement. Calls delete on this.
    virtual VOID Terminate(VOID)
    {
        delete this;
    }
protected:
    // Creates the CRSCAGlobalModule class.
    // Initializes the CEventWriter to write
    // to the event log using the IISADMIN key.
    CRSCAGlobalModule() : m_eventWriter(L"IISADMIN")
    {

    }
private:
    // Specify the CEventWriter writer.
    CEventWriter m_eventWriter;
};

// The RegisterModule method is the 
// main entry point for the DLL.
// dwServerVersion: the current server version.
// pModuleInfo: the current 
// IHttpModuleRegistrationInfo pointer.
// pGlobalInfo: the current IHttpServer pointer.
// return: the value returned by calling the
// CRSCAGlobalModule::RegisterGlobalModule
// method.
HRESULT
__stdcall
RegisterModule(
    DWORD dwServerVersion,
    IHttpModuleRegistrationInfo* pModuleInfo,
    IHttpServer* pGlobalInfo
)
{        
    // Call the static method for initialization.
    return CRSCAGlobalModule::RegisterGlobalModule            
        (dwServerVersion, 
         pModuleInfo, 
         pGlobalInfo);             
}

네이티브 DLL 모듈을 만들고 배포하는 방법에 대한 자세한 내용은 연습: 네이티브 코드를 사용하여 Request-Level HTTP 모듈 만들기를 참조하세요.

위의 코드는 데이터 상자에 다음과 유사한 문자열이 포함된 이벤트 뷰어 애플리케이션 로그에 이벤트를 씁니다.

Parameters:  

필요에 따라 각 함수에 대한 호출 규칙을 명시적으로 선언하는 대신 __stdcall (/Gz) 호출 규칙을 사용하여 코드를 컴파일할 수 있습니다.

요구 사항

형식	Description
클라이언트	- Windows Vista의 IIS 7.0 - Windows 7의 IIS 7.5 - Windows 8의 IIS 8.0 - WINDOWS 10 IIS 10.0
서버	- Windows Server 2008의 IIS 7.0 - Windows Server 2008 R2의 IIS 7.5 - Windows Server 2012의 IIS 8.0 - Windows Server 2012 R2의 IIS 8.5 - WINDOWS SERVER 2016 IIS 10.0
제품	- IIS 7.0, IIS 7.5, IIS 8.0, IIS 8.5, IIS 10.0 - IIS Express 7.5, IIS Express 8.0, IIS Express 10.0
헤더	Httpserv.h

참고 항목

IGlobalRSCAQueryProvider 인터페이스