IHttpFileInfo：：GetModuleContextContainer 方法
返回相应文件的 IHttpModuleContextContainer 指针。
语法
virtual IHttpModuleContextContainer* GetModuleContextContainer(
VOID
) = 0;
参数
此方法不采用参数。
返回值
指向 IHttpModuleContextContainer 接口的指针。
备注
方法 GetModuleContextContainer 返回值取决于实现。 默认情况下，当前实现会创建同步但未分配的 IDispensedHttpModuleContextContainer 。
实现者须知
IHttpFileInfo 实现者负责使用此数据进行内存管理;因此， IHttpFileInfo 实现者应在构造时创建一个 IDispensedHttpModuleContextContainer 指针，并在指针的生命周期内保留 private 对此 IDispensedHttpModuleContextContainer 指针的 IHttpFileInfo 引用。 GetModuleContextContainer调用 方法时，应向上转换并返回相同的IDispensedHttpModuleContextContainer指针。 调用实现 IHttpFileInfo 接口的类的析构函数时，此析构函数应在此private引用上调用 IDispensedHttpModuleContextContainer：：ReleaseContainer 方法，然后将该引用设置为 NULL。
GetModuleContextContainer 不应返回 NULL。 如果内部容器为 NULL，请将此内部容器设置为调用 IHttpServer：:D ispenseContainer 时的值，然后返回此同一容器。
注意
尽管隐式向上转换操作被视为安全操作，但请考虑使用显式强制转换来明确程序。 此外，请考虑尽可能使用 dynamic_cast 运算符。
对调用者的说明
IHttpFileInfo 实现者负责使用此数据进行内存管理;因此， IHttpFileInfo 当不再需要此数据时，客户端不得释放、调用 delete 或尝试向下转换和调用 IDispensedHttpModuleContextContainer::ReleaseContainer 返回的 IHttpModuleContextContainer 指针。
示例
下面的代码示例演示了实现 接口的名为 的MyContainerIDispensedHttpModuleContextContainer自定义类，以及实现 接口的名为 的MyClassIHttpFileInfo自定义类。 MyClass 在 MyContainer 指针的 MyClass 生存期内管理指针。
#pragma warning( disable : 4290 )
#pragma warning( disable : 4530 )
#define _WINSOCKAPI_
#include <windows.h>
#include <io.h>
#include <sal.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 ToString method converts a BOOL to a wstring.
// b: the BOOL value to convert to a wstring.
// return: L"true" for true; otherwise, L"false" for false.
static wstring ToString(BOOL b)
{
return (b) ? L"true" : L"false";
}
// 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 CResponseWriter class writes
// text to the response stream.
class CResponseWriter
{
public:
// Creates the CResponseWriter class.
// response: the IHttpResponse
// pointer to write to.
// throws: a _com_error exception if
// the IHttpResponse pointer is NULL.
CResponseWriter(IHttpResponse* response)
throw (_com_error)
{
// If the response is NULL,
// throw an exception.
if (NULL == response)
{
ThrowOnFail(E_INVALIDARG);
}
// Set the internal response.
m_response = response;
}
// The destructor for the CResponseWriter
// class. The CResponseWriter method
// sets the IHttpResponse pointer to NULL.
virtual ~CResponseWriter()
{
m_response = NULL;
}
// The Write method writes the
// PCSTR to the response stream.
// pszValue: the PCSTR to write.
// throws: a _com_error if the
// Write method fails.
void Write
(
PCSTR pszValue
) throw (_com_error)
{
// The string must not be
// NULL, and its length must
// be greater than 0.
if ((NULL == pszValue) ||
(strlen(pszValue) < 1))
{
// Throw an invalid argument
// exception.
ThrowOnFail(E_INVALIDARG);
}
// Create a data chunk structure.
HTTP_DATA_CHUNK dataChunk;
// Set the chunk to a chunk in memory.
dataChunk.DataChunkType =
HttpDataChunkFromMemory;
// Set the chunk to
// the pszValue parameter.
dataChunk.FromMemory.pBuffer =
(PVOID)pszValue;
// Set the chunk size
// to the pszValue length.
dataChunk.FromMemory.BufferLength =
(USHORT)strlen(pszValue);
// Declare and initialize OUT
// parameters for the WriteEntityChunks
// method.
DWORD pcbSent = 0;
BOOL pfCompletionExpected = FALSE;
// Write the entity chunks to
// the response stream.
HRESULT hr =
m_response->WriteEntityChunks
(&dataChunk,
1,
FALSE,
FALSE,
&pcbSent,
&pfCompletionExpected);
// Throw an exception if the call
// to WriteEntityChunks is not a
// success.
ThrowOnFail(hr);
}
// The WriteLine method writes a string
// and newline characters to the response steam.
// pszValue: the PCSTR string to write.
// throws: a _com_error if the PCSTR
// or the newline characters are not
// written to the response stream.
void WriteLine
(
PCSTR pszValue
) throw (_com_error)
{
// Try to write the pszValue parameter.
Write(pszValue);
// Try to write the newline characters.
Write("\r\n");
}
// Convenience method that writes a name
// and value pair to the response stream.
// name: the name of the parameter.
// value: the value of the parameter.
// throws: a _com_error exception if
// the response stream is not written.
void WriteLine
(
const wstring& name,
const wstring& value
) throw (_com_error)
{
// Convert the UNICODE strings
// to mutlibyte strings.
string nameMulti =
CConvert::ToByteString(name);
string valueMulti =
CConvert::ToByteString(value);
// Create the string to write.
string writeString =
nameMulti +
string(": ") +
valueMulti;
// Write the line to
// the response stream.
WriteLine(writeString.c_str());
}
// Tests an HRESULT for success.
// hr: the HRESULT value to inspect.
// throws: a _com_error if the HRESULT
// parameter is not S_OK.
static void ThrowOnFail(HRESULT hr)
{
if (FAILED(hr))
{
_com_error ce(hr);
throw ce;
}
}
private:
// Specify the IHttpResponse
// pointer to write to.
IHttpResponse* m_response;
};
// The MyHttpModule class extends the CHttpModule
// class and handles response processing. This
// class handles retrieving an IHttpFileInfo pointer
// from the IHttpContext pointer during the overridden
// OnSendResponse method, and writes the IHttpFileInfo
// data to the response stream.
class MyHttpModule : public CHttpModule
{
public:
// The MyHttpModule method is the public
// constructor for the MyHttpModule class.
MyHttpModule()
{
}
// The OnSendResponse method
// handles respose processing.
// pHttpContext: an IHttpContext pointer.
// pProvider: an ISendResponseProvider pointer.
// return: RQ_NOTIFICATION_FINISH_REQUEST if the
// IHttpFileInfo pointer can be retrieved from the
// pHttpContext parameter; otherwise,
// RQ_NOTIFICATION_CONTINUE.
REQUEST_NOTIFICATION_STATUS OnSendResponse
(
IN IHttpContext* pHttpContext,
IN OUT ISendResponseProvider* pProvider
)
{
// Use the UNREFERENCED_PARAMETER macro since
// the pProvider parameter is never used.
UNREFERENCED_PARAMETER(pProvider);
if (NULL == pHttpContext)
{
return RQ_NOTIFICATION_CONTINUE;
}
// Get an IHttpFileInfo pointer
// from the IHttpContext pointer.
IHttpFileInfo* fileInfo =
pHttpContext->GetFileInfo();
// Get the IHttpResponse pointer
// from the IHttpContext pointer.
IHttpResponse* response =
pHttpContext->GetResponse();
// Both the IHttpFileInfo pointer
// and IHttpResponse pointer are
// required for processing.
if ((NULL == fileInfo) ||
(NULL == response))
{
return RQ_NOTIFICATION_CONTINUE;
}
// Clear the existing response stream.
response->Clear();
// Set the response header to plain text.
HRESULT hr =
response->SetHeader(HttpHeaderContentType,
"text/plain",
(USHORT)strlen("text/plain"),
TRUE);
// If the SetHeader method fails,
// call the SetStatus with an error code.
if (FAILED(hr))
{
response->SetStatus(500,
"IHttpResponse::SetHeader",
0, hr);
return RQ_NOTIFICATION_CONTINUE;
}
// The CResponseWriter will throw a
// com_exception if it cannot be created,
// or if the response stream cannot be written.
// Create a new CResponseWriter, and wrap
// all calls into that CResponseWriter,
// with a try-catch statement.
try
{
// Declare a writer for
// the response stream.
CResponseWriter writer(response);
// Get the IHttpModuleContextContainer
// from the IHttpFileInfo pointer.
IHttpModuleContextContainer* contextContainer =
fileInfo->GetModuleContextContainer();
// Convert the IHttpModuleContextContainer
// pointer to a wstring.
wstring contextString =
CConvert::ToString(NULL != contextContainer);
// Write the context data to
// the response stream.
writer.WriteLine(L"Context", contextString);
}
catch (_com_error& ce)
{
// Attempt to get the
// description of the error.
_bstr_t description =
ce.Description();
// Print the description if
// it is not empty.
if (0 == description.length())
{
description = ce.ErrorMessage();
}
// Set an error status on the
// IHttpResponse pointer.
response->SetStatus(500, description, 0, ce.Error());
}
// Return RQ_NOTIFICATION_FINISH_REQUEST, which
// will terminate any additional request processing.
return RQ_NOTIFICATION_FINISH_REQUEST;
}
protected:
// The MyHttpModule is the protected virtual
// constructor for the MyHttpModule class.
virtual ~MyHttpModule()
{
}
};
// The MyHttpModuleFactory class implements the IHttpModuleFactory
// interface, and creates a new MyHttpModule pointer, where this
// MyHttpModule listens for RQ_SEND_RESPONSE events.
class MyHttpModuleFactory : public IHttpModuleFactory
{
public:
// The RegisterGlobalModule method creates a new
// MyHttpModuleFactory pointer, assigns that pointer
// as the factory on the pModuleInfo parameter, and
// registers for RQ_SEND_RESPONSE events.
// dwServerVersion: the current server version.
// pModuleInfo: the IHttpModuleRegistrationInfo
// used for requesting notifications.
// pGlobalInfo: the IHttpServer pointer.
static HRESULT RegisterGlobalModule
(
DWORD dwServerVersion,
IHttpModuleRegistrationInfo* pModuleInfo,
IHttpServer* pGlobalInfo
)
{
// Create a new MyHttpModuleFactory pointer.
MyHttpModuleFactory* factory =
new MyHttpModuleFactory;
// If the factory is NULL, return a
// return a ERROR_NOT_ENOUGH_MEMORY
// errror.
if (NULL == factory)
{
return HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
}
// Return the value from calling the
// SetRequestNotifications method by
// passing the factory for RQ_SEND_RESPONSE
// events.
return pModuleInfo->SetRequestNotifications(
factory,
RQ_SEND_RESPONSE,
0);
}
// The GetHttpModule method creates a new MyHttpModule
// pointer and sets the ppModule with this pointer.
// ppModule: the OUT parameter which
// accepts a new CHttpModule subclass.
// pAllocator: the IModuleAllocator pointer,
// which is unused in this implementation.
virtual HRESULT GetHttpModule
(
OUT CHttpModule** ppModule,
IN IModuleAllocator* pAllocator
)
{
// Call the UNREFERENCED_PARAMETER with
// the IModuleAllocator pointer, because
// this parameter is never used.
UNREFERENCED_PARAMETER(pAllocator);
// Create a new MyHttpModule pointer and assign
// it to the dereferenced ppModule pointer.
*ppModule = new MyHttpModule;
// If the dereferenced ppModule is NULL
// then heap memory is exhausted. Return
// an ERROR_NOT_ENOUGH_MEMORY error.
if (NULL == *ppModule)
{
return HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
}
// Creating a new MyHttpModule pointer
// was successful; return S_OK.
return S_OK;
}
// The Terminate method must be implemented
// by IHttpModuleFactory implementers,
// and calls delete on this.
virtual void Terminate()
{
delete this;
}
private:
// The MyHttpModuleFactory is the
// protected constructor for the
// MyHttpModuleFactory class.
MyHttpModuleFactory()
{
}
// The MyHttpModuleFactory method is the
// protected virtual destructor for the
// MyHttpModuleFactory class.
virtual ~MyHttpModuleFactory()
{
}
};
// 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 HRESULT value returned from
// the MyHttpModuleFactory::RegisterGlobalModule
// static method.
HRESULT
__stdcall
RegisterModule
(
DWORD dwServerVersion,
IHttpModuleRegistrationInfo* pModuleInfo,
IHttpServer* pGlobalInfo
)
{
// Register for global events using the MyHttpModuleFactory
// class' static RegisterGlobalModule method.
return MyHttpModuleFactory::RegisterGlobalModule
(dwServerVersion, pModuleInfo, pGlobalInfo);
}
模块必须导出 RegisterModule 函数。 可以通过为项目创建模块定义 (.def) 文件导出此函数，也可以使用 开关编译模块 /EXPORT:RegisterModule 。 有关详细信息，请参阅 演练：使用本机代码创建Request-Level HTTP 模块。
可以选择使用调用约定编译代码， __stdcall (/Gz) 而不是为每个函数显式声明调用约定。
要求
| 类型 | 说明 |
|---|---|
| 客户端 | - 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 |
| Header | Httpserv.h |
另请参阅
IHttpFileInfo 接口
IHttpApplication：：GetModuleContextContainer 方法
IHttpConnection：：GetModuleContextContainer 方法
IHttpContext：：GetModuleContextContainer 方法
IHttpFileMonitor：：GetModuleContextContainer 方法
IHttpSite：：GetModuleContextContainer 方法
IHttpUrlInfo：：GetModuleContextContainer 方法
IMetadataInfo：：GetModuleContextContainer 方法