Condividi tramite

Metodo IHttpServer::GetManagedType

  • Articolo

Recupera il tipo gestito per un sito specifico e un URI (Uniform Resource Identifier).

Sintassi

virtual HRESULT GetManagedType(  
   IN DWORD dwSiteId,  
   IN PCWSTR pszVirtualPath,  
   __out PWSTR pszManagedType,  
   IN OUT DWORD* pcchManagedType  
) = 0;

Parametri

dwSiteId
[IN] Identificatore del sito per l'URI in pszVirtualPath.

pszVirtualPath
[IN] Puntatore a una stringa contenente un URI.

pszManagedType
[__out] Puntatore a un buffer stringa preallocato.

pcchManagedType
[IN] [OUT] Lunghezza, in byte, del pszManagedType buffer.

Valore restituito

Oggetto HRESULT. I valori possibili includono, ma non sono limitati a, quelli indicati nella tabella seguente.

Valore Descrizione
S_OK Indica che l'operazione ha avuto esito positivo.
E_INVALIDARG Indica che un valore non valido è stato passato in uno dei parametri , ad esempio uno dei puntatori è impostato su NULL.
E_OUTOFMEMORY Indica che non è disponibile memoria sufficiente per eseguire l'operazione.
ERROR_INVALID_PARAMETER Indica che un valore non valido è stato passato in uno dei parametri.
ERROR_INSUFFICIENT_BUFFER Indica che non è disponibile spazio buffer sufficiente per eseguire l'operazione.

Commenti

Il GetManagedType metodo recupera l'attributo per il type gestore delle richieste che elabora un percorso virtuale specifico specificato dai dwSiteId parametri e pszVirtualPath . Il metodo restituisce quindi queste informazioni nel buffer specificato dal pszManagedType parametro .

Importante

Il chiamante deve allocare il buffer per pszManagedType. Se il chiamante passa NULL per questo parametro, il metodo restituirà E_INVALIDARG.

L'attributo type per un gestore della richiesta si trova nella <handlers> sezione del file ApplicationHost.config. Questo attributo contiene un elenco degli spazi dei nomi di .NET Framework per un gestore delle richieste. Ad esempio, il gestore di richieste "TraceHandler-Integrated" ha un type attributo "System.Web.Handlers.TraceHandler" per impostazione predefinita.

Il IHttpServer::GetManagedType metodo differisce dal metodo IScriptMapInfo::GetManagedType in cui il metodo può recuperare l'attributo per qualsiasi percorso virtuale, mentre il IHttpServer::GetManagedTypeIScriptMapInfo::GetManagedType metodo recupera solo l'attributo typetype per l'interfaccia IScriptMapInfo.

Esempio

Nell'esempio di codice seguente viene illustrato come usare il GetManagedType metodo per creare un modulo HTTP che recupera il tipo gestito per l'URI /default.aspx.

Il modulo completa i passaggi seguenti:

  1. Recupera l'identificatore del sito per la richiesta corrente.

  2. Recupera la lunghezza necessaria per recuperare il tipo gestito per la richiesta.

  3. Alloca un buffer per il tipo gestito.

  4. Recupera il tipo gestito.

  5. Restituisce il risultato a un client Web e quindi termina.

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

// Create a pointer for the global server interface.
IHttpServer * g_pHttpServer = NULL;

// 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;

        // Retrieve the site ID.
        DWORD dwSiteId = pHttpContext->GetSite()->GetSiteId();

        // Create buffers to store the managed type.
        PWSTR pwszManagedType =
            (PWSTR) pHttpContext->AllocateRequestMemory( 1 );
        char* pszManagedType = NULL;
        DWORD cchManagedType = 0;

        // Test for an error.
        if (NULL != pwszManagedType)
        {
            // Retrieve the size of the managed type.
            hr = g_pHttpServer->GetManagedType(
                dwSiteId,L"/default.aspx",
                pwszManagedType,&cchManagedType);
            // Test for an error.
            if ((HRESULT_CODE(hr)==ERROR_INSUFFICIENT_BUFFER) && (cchManagedType>0))
            {
                // Allocate space for the managed type.
                pwszManagedType =
                    (PWSTR) pHttpContext->AllocateRequestMemory(
                    (cchManagedType*2)+1 );
                // Test for an error.
                if (NULL == pwszManagedType)
                {
                    // Set the error status.
                    hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
                    pProvider->SetErrorStatus( hr );
                }
                else
                {
                    // Retrieve the managed type.
                    hr = g_pHttpServer->GetManagedType(
                        dwSiteId,L"/default.aspx",
                        pwszManagedType,&cchManagedType);
                    // Test for an error.
                    if (SUCCEEDED(hr))
                    {
                        // Clear the existing response.
                        pHttpContext->GetResponse()->Clear();
                        // Set the MIME type to plain text.
                        pHttpContext->GetResponse()->SetHeader(
                            HttpHeaderContentType,"text/plain",
                            (USHORT)strlen("text/plain"),TRUE);
                        // Allocate space for the managed type.
                        pszManagedType =
                            (char*) pHttpContext->AllocateRequestMemory(
                            (DWORD) wcslen(pwszManagedType)+1 );
                        // Test for an error.
                        if (NULL == pszManagedType)
                        {
                            // Set the error status.
                            hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
                            pProvider->SetErrorStatus( hr );
                        }
                        else
                        {
                            // Convert the WCHAR string to a CHAR string.
                            wcstombs(pszManagedType,
                                pwszManagedType,wcslen(pwszManagedType));
                            // Return the managed type to the client.
                            WriteResponseMessage(pHttpContext,"Managed type: ",
                                (cchManagedType>1) ? pszManagedType : "n/a");
                        }
                        // End additional processing.
                        return RQ_NOTIFICATION_FINISH_REQUEST;
                    }
                }
            }
        }

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

private:

    // Create a utility method that inserts a name/value pair into the response.
    HRESULT WriteResponseMessage(
        IHttpContext * pHttpContext,
        PCSTR pszName,
        PCSTR pszValue
    )
    {
        // Create an HRESULT to receive return values from methods.
        HRESULT hr;
        
        // Create a data chunk.
        HTTP_DATA_CHUNK dataChunk;
        // Set the chunk to a chunk in memory.
        dataChunk.DataChunkType = HttpDataChunkFromMemory;
        // Buffer for bytes written of data chunk.
        DWORD cbSent;

        // Set the chunk to the first buffer.
        dataChunk.FromMemory.pBuffer =
            (PVOID) pszName;
        // Set the chunk size to the first buffer size.
        dataChunk.FromMemory.BufferLength =
            (USHORT) strlen(pszName);
        // Insert the data chunk into the response.
        hr = pHttpContext->GetResponse()->WriteEntityChunks(
            &dataChunk,1,FALSE,TRUE,&cbSent);
        // Test for an error.
        if (FAILED(hr))
        {
            // Return the error status.
            return hr;
        }

        // Set the chunk to the second buffer.
        dataChunk.FromMemory.pBuffer =
            (PVOID) pszValue;
        // Set the chunk size to the second buffer size.
        dataChunk.FromMemory.BufferLength =
            (USHORT) strlen(pszValue);
        // Insert the data chunk into the response.
        hr = pHttpContext->GetResponse()->WriteEntityChunks(
            &dataChunk,1,FALSE,TRUE,&cbSent);
        // Test for an error.
        if (FAILED(hr))
        {
            // Return the error status.
            return hr;
        }

        // Return a success status.
        return S_OK;
    }
};

// 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 );

    // Store the pointer for the global server interface.
    g_pHttpServer = pGlobalInfo;

    // Set the request notifications and exit.
    return pModuleInfo->SetRequestNotifications(
        new MyHttpModuleFactory,
        RQ_BEGIN_REQUEST,
        0
    );
}

Il modulo deve esportare la funzione RegisterModule . È possibile esportare questa funzione creando un file di definizione del modulo (con estensione def) per il progetto oppure è possibile compilare il modulo usando l'opzione /EXPORT:RegisterModule . Per altre informazioni, vedere Procedura dettagliata: Creazione di un modulo HTTP Request-Level tramite codice nativo.

Facoltativamente, è possibile compilare il codice usando la __stdcall (/Gz) convenzione chiamante anziché dichiarare esplicitamente la convenzione chiamante per ogni funzione.

Requisiti

Tipo Descrizione
Client - IIS 7.0 in Windows Vista
- IIS 7.5 in Windows 7
- IIS 8.0 in Windows 8
- IIS 10.0 in Windows 10
Server - IIS 7.0 in Windows Server 2008
- IIS 7.5 in Windows Server 2008 R2
- IIS 8.0 in Windows Server 2012
- IIS 8.5 in Windows Server 2012 R2
- IIS 10.0 in Windows Server 2016
Prodotto - 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
Intestazione Httpserv.h

Vedere anche

Interfaccia IHttpServer
Metodo IScriptMapInfo::GetManagedType