IHttpResponse::WriteEntityChunks (Método)
Anexa una o varias estructuras de HTTP_DATA_CHUNK al cuerpo de la respuesta.
Sintaxis
virtual HRESULT WriteEntityChunks(
IN HTTP_DATA_CHUNK* pDataChunks,
IN DWORD nChunks,
IN BOOL fAsync,
IN BOOL fMoreData,
OUT DWORD* pcbSent,
OUT BOOL* pfCompletionExpected = NULL
) = 0;
Parámetros
pDataChunks
[IN] Puntero a una o varias HTTP_DATA_CHUNK
estructuras.
nChunks
[IN] que DWORD
contiene el número de fragmentos a pDataChunks
los que apunta .
fAsync
[IN] true
si el método debe completarse de forma asincrónica; de lo contrario, false
.
fMoreData
[IN] true
si se van a enviar más datos en la respuesta; false
si es el último dato.
pcbSent
[OUT] Número de bytes que se enviaron al cliente si la llamada se completa de forma sincrónica.
pfCompletionExpected
[OUT] true
si hay una finalización asincrónica pendiente para esta llamada; de lo contrario, false
.
Valor devuelto
Una clase HRESULT
. Entre los valores posibles se incluyen los que se indican en la tabla siguiente, entre otros.
Value | Descripción |
---|---|
S_OK | Indica que la operación se realizó correctamente. |
ERROR_INVALID_PARAMETER | Indica que el parámetro no es válido (por ejemplo, el pDataChunks puntero se establece en NULL). |
ERROR_NOT_ENOUGH_MEMORY | Indica que no hay memoria suficiente para realizar la operación. |
ERROR_ARITHMETIC_OVERFLOW | Se han agregado más de 65535 fragmentos a la respuesta. |
Comentarios
Los desarrolladores pueden usar el WriteEntityChunks
método para insertar una sola HTTP_DATA_CHUNK
estructura o una matriz de estructuras en el cuerpo de HTTP_DATA_CHUNK
la respuesta. Si la operación se ha completado de forma sincrónica, el pcbSent
parámetro recibirá el número de bytes que se insertaron en la respuesta.
Si el almacenamiento en búfer está activado, el WriteEntityChunks
método creará una copia de cualquier HTTP_DATA_CHUNK
estructura, duplicando así los datos subyacentes para que no sea necesario conservarlos. Si se desactiva el almacenamiento en búfer o se alcanza el límite del búfer de respuesta, el WriteEntityChunks
método también vaciará la respuesta. Si el almacenamiento en búfer está desactivado y el fAsync
parámetro es true
, la memoria debe conservarse hasta que se complete la solicitud.
Puede configurar una WriteEntityChunks
operación para que se complete de forma asincrónica estableciendo el fAsync
parámetro en true
. En esta situación, el WriteEntityChunks
método volverá inmediatamente al autor de la llamada y el pcbSent
parámetro no recibirá el número de bytes que se insertaron en la respuesta. Si el almacenamiento en búfer está deshabilitado y el fAsync
parámetro es true
, la memoria del pDataChunks
parámetro debe conservarse hasta que se complete la llamada asincrónica.
Un máximo de 65535 fragmentos (64 KB menos 1) se puede escribir en una solicitud.
Ejemplo
En el ejemplo siguiente se muestra cómo usar el WriteEntityChunks
método para crear un módulo HTTP que inserte una matriz de dos fragmentos de datos en la respuesta. A continuación, el ejemplo devuelve la respuesta a un cliente web.
#define _WINSOCKAPI_
#include <windows.h>
#include <sal.h>
#include <httpserv.h>
// Create the module class.
class MyHttpModule : public CHttpModule
{
public:
REQUEST_NOTIFICATION_STATUS
OnBeginRequest(
IN IHttpContext * pHttpContext,
IN IHttpEventProvider * pProvider
)
{
UNREFERENCED_PARAMETER( pProvider );
// Create an HRESULT to receive return values from methods.
HRESULT hr;
// Create an array of data chunks.
HTTP_DATA_CHUNK dataChunk[2];
// Buffer for bytes written of data chunk.
DWORD cbSent;
// Create string buffers.
PCSTR pszOne = "First chunk data\n";
PCSTR pszTwo = "Second chunk data\n";
// Retrieve a pointer to the response.
IHttpResponse * pHttpResponse = pHttpContext->GetResponse();
// Test for an error.
if (pHttpResponse != NULL)
{
// Clear the existing response.
pHttpResponse->Clear();
// Set the MIME type to plain text.
pHttpResponse->SetHeader(
HttpHeaderContentType,"text/plain",
(USHORT)strlen("text/plain"),TRUE);
// Set the chunk to a chunk in memory.
dataChunk[0].DataChunkType = HttpDataChunkFromMemory;
// Set the chunk to the first buffer.
dataChunk[0].FromMemory.pBuffer =
(PVOID) pszOne;
// Set the chunk size to the first buffer size.
dataChunk[0].FromMemory.BufferLength =
(USHORT) strlen(pszOne);
// Set the chunk to a chunk in memory.
dataChunk[1].DataChunkType = HttpDataChunkFromMemory;
// Set the chunk to the second buffer.
dataChunk[1].FromMemory.pBuffer =
(PVOID) pszTwo;
// Set the chunk size to the second buffer size.
dataChunk[1].FromMemory.BufferLength =
(USHORT) strlen(pszTwo);
// Insert the data chunks into the response.
hr = pHttpResponse->WriteEntityChunks(
dataChunk,2,FALSE,TRUE,&cbSent);
// Test for an error.
if (FAILED(hr))
{
// Set the error status.
pProvider->SetErrorStatus( hr );
}
// End additional processing.
return RQ_NOTIFICATION_FINISH_REQUEST;
}
// Return processing to the pipeline.
return RQ_NOTIFICATION_CONTINUE;
}
};
// 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;
}
};
// Create the module's exported registration function.
HRESULT
__stdcall
RegisterModule(
DWORD dwServerVersion,
IHttpModuleRegistrationInfo * pModuleInfo,
IHttpServer * pGlobalInfo
)
{
UNREFERENCED_PARAMETER( dwServerVersion );
UNREFERENCED_PARAMETER( pGlobalInfo );
// Set the request notifications and exit.
return pModuleInfo->SetRequestNotifications(
new MyHttpModuleFactory,
RQ_BEGIN_REQUEST,
0
);
}
El módulo debe exportar la función RegisterModule . Puede exportar esta función mediante la creación de un archivo de definición de módulo (.def) para el proyecto, o bien puede compilar el módulo mediante el /EXPORT:RegisterModule
modificador . Para obtener más información, vea Tutorial: Creación de un módulo HTTP de Request-Level mediante código nativo.
Opcionalmente, puede compilar el código mediante la __stdcall (/Gz)
convención de llamada en lugar de declarar explícitamente la convención de llamada para cada función.
Requisitos
Tipo | Descripción |
---|---|
Remoto | - IIS 7.0 en Windows Vista - IIS 7.5 en Windows 7 - IIS 8.0 en Windows 8 - IIS 10.0 en Windows 10 |
Servidor | - IIS 7.0 en Windows Server 2008 - IIS 7.5 en Windows Server 2008 R2 - IIS 8.0 en Windows Server 2012 - IIS 8.5 en Windows Server 2012 R2 - IIS 10.0 en Windows Server 2016 |
Producto | - 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 |
Encabezado | Httpserv.h |
Consulte también
IHttpResponse (interfaz)
IHttpResponse::WriteEntityChunkByReference (Método)