Compartilhar via


Método IDebugHostSymbols::CreateTypeSignature (dbgmodel.h)

O método CreateTypeSignature cria uma assinatura que pode ser usada para corresponder a um conjunto de tipos concretos contendo o módulo e o nome do tipo. O formato da cadeia de caracteres de assinatura de nome de tipo é específico para o idioma que está sendo depurado (e o host de depuração). Para C/C++, a cadeia de caracteres de assinatura é equivalente a uma Especificação de Tipo NatVis. Ou seja, a cadeia de caracteres de assinatura é um nome de tipo em que curingas (especificados como *) são permitidos para argumentos de modelo.

Sintaxe

HRESULT CreateTypeSignature(
  PCWSTR                  signatureSpecification,
  IDebugHostModule        *module,
  IDebugHostTypeSignature **typeSignature
);

Parâmetros

signatureSpecification

A cadeia de caracteres de assinatura que identifica os tipos aos quais essa assinatura se aplica. O formato dessa cadeia de caracteres é específico para o idioma que está sendo depurado. Para C/C++, isso é equivalente a uma especificação de tipo NatVis. Esse é um nome de tipo em que caracteres curingas são permitidos para argumentos de modelo (especificados como um *).

module

Se especificado, somente os tipos contidos no módulo especificado correspondem à assinatura. Se não for especificado, os tipos em qualquer módulo poderão corresponder à assinatura.

typeSignature

O objeto de assinatura de tipo criado é retornado aqui.

Valor de retorno

Esse método retorna HRESULT que indica êxito ou falha.

Observações

de código de exemplo

ComPtr<IDebugHost> spHost; /* get the host */

ComPtr<IDebugHostSymbols> spSym;
if (SUCCEEDED(spHost.As(&spSym)))
{
    // Create a type signature for MyTemplateType<*>
    ComPtr<IDebugHostTypeSignature> spSig1;
    if (SUCCEEDED(spSym->CreateTypeSignature(L"MyTemplateType<*>", 
                                             nullptr, 
                                             &spSig1)))
    {
        // spSig1 is a type signature which will match any concrete template 
        // type with a base name of MyTemplateType and *ANY* template arguments.
        // This is true regardless of the module in which the type is contained.
    }

    ComPtr<IDebugHostModule> spMyModule;
    if (SUCCEEDED(spSym->FindModuleByName(USE_CURRENT_HOST_CONTEXT, 
                                          L"MyModule.dll", 
                                          &spMyModule)))
    {
        // Create a type signature for MyTemplateType<*> within MyModule.dll.
        ComPtr<IDebugHostTypeSignature> spSig2;
        if (SUCCEEDED(spSym->CreateTypeSignature(L"MyTemplateType<*>", 
                                                 nullptr, 
                                                 &spSig2)))
        {
            // spSig2 is a type signature which will match any concrete 
            // template type with a base name of MyTemplateType and *ANY* 
            // template arguments that is within the particular MyModule.dll 
            // that's in the current UI context (e.g.: process) of the debugger.
            // This means if the host is debugging multiple processes
            // and you switch processes, a MyTemplateType<*> in an identically
            // named and versioned MyModule.dll will *NOT* match this signature.
        }
    }
}

diferenças na correspondência do módulo de símbolo em FindModuleByName, CreateTypeSignature e CreateTypeSignatureForModuleRange

FindModuleByName permitirá que o nome do módulo passado seja o nome real da imagem do módulo, por exemplo, Meu Module.dllou aquele pelo qual você pode referenciá-lo no mecanismo do depurador (por exemplo: MyModule ou MyModule_<hex_base>).

Chamar CreateTypeSignatureForModuleRange e passar um nome/nullptr/nullptr criará uma assinatura que corresponderá a qualquer módulo que corresponda a esse nome de qualquer versão.

O nome do módulo passado para as funções CreateTypeSignature só aceitará o nome real da imagem do módulo (por exemplo: MyModule.dll).

Chamar FindModuleByName e, em seguida, CreateTypeSignature com esse módulo criará uma assinatura que corresponderá apenas à instância específica do módulo passado para ele. Se houver duas cópias de um módulo carregadas (por exemplo: ntdll em um processo de 32 bits em execução no Windows de 64 bits), ele corresponderá apenas à instância específica passada. Também não corresponderia mais se essa DLL fosse descarregada e recarregada. A assinatura está associada a uma instância específica de um módulo, conforme conhecido pelo depurador.

Requisitos

Requisito Valor
cabeçalho dbgmodel.h

Consulte também

interface IDebugHostSymbols

FindModuleByName

CreateTypeSignatureForModuleRange