Méthode IDebugHost ::GetDefaultMetadata (dbgmodel.h)

La méthode GetDefaultMetadata retourne un magasin de métadonnées par défaut qui peut être utilisé pour certaines opérations (par exemple, la conversion de chaîne) lorsqu’aucune métadonnées explicite n’a été transmise. Cela permet à l’hôte de débogage d’avoir un certain contrôle sur la façon dont certaines données sont présentées. Par exemple, les métadonnées par défaut peuvent inclure une clé PreferredRadix, ce qui permet à l’hôte d’indiquer si les ordinaux doivent être affichés en décimaux ou hexadécimaux s’ils ne sont pas spécifiés autrement.

Notez que les valeurs de propriété sur le magasin de métadonnées par défaut doivent être résolues manuellement et doivent transmettre l’objet pour lequel les métadonnées par défaut sont interrogées. La méthode GetKey doit être utilisée au lieu de GetKeyValue.

Syntaxe

HRESULT GetDefaultMetadata(
  IKeyStore **defaultMetadataStore
);

Paramètres

defaultMetadataStore

Le magasin de métadonnées par défaut de l’hôte de débogage est retourné ici.

Valeur retournée

Cette méthode retourne HRESULT qui indique la réussite ou l’échec.

Remarques

Exemple de code

Exemple d’utilisation (généralement appelé par le modèle de données lui-même) :

ComPtr<IDebugHost> spHost;     /* get the debug host */
ComPtr<IModelObject> spObject; /* find some object that we want default metadata for */

ComPtr<IKeyStore> spDefaultMetadata;
if (SUCCEEDED(spHost->GetDefaultMetadata(&spDefaultMetadata)))
{
    // Query the preferred display radix for spObject.  We must resolve the 
    // property manually and pass spObject as the context object.
    // This allows the default store to do things like say "radix is 10 for 
    // signed types and 16 for unsigned types"
    ComPtr<IModelObject> spRadixKey;
    if (SUCCEEDED(spDefaultMetadata->GetKey(L"PreferredRadix", &spRadixKey, nullptr)))
    {
        // There is a default radix in which to display spObject.  Resolve 
        // the property manually.
        ModelObjectKind kind;
        if (SUCCEEDED(spRadixKey->GetKind(&kind)))
        {
            if (kind == ObjectPropertyAccessor)
            {
                VARIANT vtProp;
                if (SUCCEEDED(spRadixKey->GetIntrinsicValue(&vtProp)))
                {
                    // There is an *in process* guarantee that the IUnknown 
                    // is IModelPropertyAccessor because of ObjectPropertyAccessor
                    IModelPropertyAccessor *pProperty =
                       static_cast<IModelPropertyAccessor *>(vtProp.punkVal);

                    ComPtr<IModelObject> spRadix;
                    if (SUCCEEDED(pProperty->GetValue(L"PreferredRadix",
                                                      spObject.Get(), 
                                                      &spRadix)))
                    {
                        // spRadix contains the display radix.  Unbox
                        // with GetIntrinsicValueAs.
                    }

                    VariantClear(&vtProp);
                }
            }
            else
            {
                // spRadixKey contains the display radix.  Unbox 
                // with GetIntrinsicValueAs.
            }
        }
    }
}

Exemple d’implémentation (un hôte effectue normalement cette opération) :

// Define a property which returns a radix of 16 for unsigned values and 10 
// for signed values
class RadixProperty :
    public Microsoft::WRL::RuntimeClass<
        Microsoft::WRL::RuntimeClassFlags<
            Microsoft::WRL::RuntimeClassType::ClassicCom
            >,
        IModelPropertyAccessor
        >
{
public:

    IFACEMETHOD(GetValue)(_In_ PCWSTR /*pwszKeyName*/, 
                          _In_opt_ IModelObject *pContextObject, 
                          _Out_ IModelObject **ppValue)
    {
        HRESULT hr = S_OK;
        *ppValue = nullptr;

        unsigned int radix = 0;
        if (pContextObject != nullptr)
        {
            ModelObjectKind kind;
            hr = pContextObject->GetKind(&kind);
            if (SUCCEEDED(hr) && kind == ObjectIntrinsic)
            {
                VARIANT vtValue;
                if (SUCCEEDED(pContextObject->GetIntrinsicValue(&vtValue)))
                {
                    switch(vtValue.vt)
                    {
                        case VT_I1: case VT_I2: case VT_I4: case VT_I8:
                            radix = 10;
                            break;
                        case VT_UI1: case VT_UI2: case VT_UI4: case VT_UI8:
                            radix = 16;
                            break;
                    }
                    VariantClear(&vtValue);
                }
            }
        }

        ComPtr<IModelObject> spResultRadix;
        if (SUCCEEDED(hr) && radix != 0)
        {
            VARIANT vtRadix;
            vtRadix.vt = VT_UI4;
            vtRadix.ulVal = radix;
            hr = GetManager()->CreateIntrinsicObject(ObjectIntrinsic, 
                                                     &vtRadix, 
                                                     &spResultRadix);
        }
        else if (SUCCEEDED(hr) && radix == 0)
        {
            // We succeeded but don't have a defined radix.  Return no value.
            hr = GetManager()->CreateNoValue(&spResultRadix);
        }

        if (SUCCEEDED(hr))
        {
            *ppValue = spResultRadix.Detach();
        }

        return hr;
    }

    IFACEMETHOD(SetValue)(_In_ PCWSTR /*pwszKeyName*/, 
                          _In_opt_ IModelObject * /*pContextObject*/, 
                          _In_ IModelObject * /*pValue*/)
    {
        return E_NOTIMPL;
    }
};

// Implementation on the implementation class for IDebugHost:
IFACEMETHOD(GetDefaultMetadata)(_Out_ IKeyStore **ppMetadata)
{
    HRESULT hr = S_OK;
    *ppMetadata = nullptr;

    ComPtr<IKeyStore> spMetadata;
    hr = GetManager()->CreateMetadataStore(&spMetadata));
    if (SUCCEEDED(hr))
    {
        ComPtr<RadixProperty> spProperty = Microsoft::WRL::Make<RadixProperty>();
        if (spProperty == nullptr)
        {
             hr = E_OUTOFMEMORY;
        }
        else
        {
            VARIANT vtProp;
            vtProp.vt = VT_UNKNOWN;
            vtProp.punkVal = static_cast<IModelPropertyAccessor *>(spProperty.Get());

            ComPtr<IModelObject> spPropertyObject;
            hr = GetManager()->CreateIntrinsicObject(ObjectPropertyAccessor, 
                                                     &vtProp, 
                                                     &spPropertyObject));
            if (SUCCEEDED(hr))
            {
                hr = spDefaultMetadata->SetKey(L"PreferredRadix",
                                               spPropertyObject.Get(), 
                                               nullptr));
            }
        }
    }

    if (SUCCEEDED(hr))
    {
        *ppMetaData = spMetadata.Detach();
    }

    return hr;
}

Configuration requise

Condition requise	Valeur
En-tête	dbgmodel.h

Voir aussi

Interface IDebugHost