IDebugHostSymbols::CreateTypeSignature-Methode (dbgmodel.h)

Die CreateTypeSignature-Methode erstellt eine Signatur, die verwendet werden kann, um einer Gruppe konkreter Typen zuzuordnen, indem sie Modul- und Typname enthält. Das Format der Typnamensignaturzeichenfolge ist spezifisch für die zu debuggende Sprache (und debughost). Bei C/C++ entspricht die Signaturzeichenfolge einer NatVis-Typspezifikation. Das heißt, die Signaturzeichenfolge ist ein Typname, bei dem Für Vorlagenargumente Wildcards (angegeben als *) zulässig sind.

Syntax

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

Parameter

signatureSpecification

Die Signaturzeichenfolge, die die Typen angibt, für die diese Signatur gilt. Das Format dieser Zeichenfolge ist spezifisch für die zu debuggende Sprache. Bei C/C++ entspricht dies einer NatVis-Typspezifikation. Dies ist ein Typname, bei dem Für Vorlagenargumente (angegeben als *) Wildcards zulässig sind.

module

Wenn angegeben, stimmen nur Typen, die im angegebenen Modul enthalten sind, mit der Signatur überein. Wenn nicht angegeben, können Typen in einem beliebigen Modul möglicherweise mit der Signatur übereinstimmen.

typeSignature

Das erstellte Typsignaturobjekt wird hier zurückgegeben.

Rückgabewert

Diese Methode gibt HRESULT zurück, das Erfolg oder Fehler angibt.

Bemerkungen

Beispielcode-

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.
        }
    }
}

Unterschiede beim Abgleich von Symbolmodulen in FindModuleByName, CreateTypeSignature und CreateTypeSignatureForModuleRange

FindModuleByName- ermöglicht dem übergebenen Modulnamen entweder den tatsächlichen Bildnamen des Moduls, z. B. "Mein Module.dll" oder den Namen, auf den Sie im Debuggermodul verweisen können (z. B.: MyModule oder MyModule_<hex_base>).

Wenn Sie CreateTypeSignatureForModuleRange aufrufen und einen Namen/nullptr/nullptr/nullptr übergeben, wird eine Signatur erstellt, die mit jedem Modul übereinstimmt, das diesem Namen einer beliebigen Version entspricht.

Der an die CreateTypeSignature-Funktionen übergebene Modulname akzeptiert nur den tatsächlichen Bildnamen des Moduls (z. B. MyModule.dll).

Wenn Sie FindModuleByName- aufrufen und dann createTypeSignature mit diesem Modul erstellen, wird eine Signatur erstellt, die nur mit der bestimmten Instanz des an das Modul übergebenen Moduls übereinstimmt. Wenn es zwei Kopien eines Moduls gibt, das geladen wird (z. B. ntdll in einem 32-Bit-Prozess, der unter 64-Bit-Windows ausgeführt wird), stimmt es nur mit der übergebenen instanz überein. Es würde auch nicht mehr übereinstimmen, wenn diese DLL entladen und neu geladen wurde. Die Signatur ist einer bestimmten Instanz eines Moduls zugeordnet, das vom Debugger bezeichnet wird.

Anforderungen

Siehe auch

IDebugHostSymbols-Schnittstelle

FindModuleByName-

CreateTypeSignatureForModuleRange-