Compartir a través de


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 pDataChunkslos 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)