Méthode IDebugHostExtensibility ::CreateFunctionAlias (dbgmodel.h)

La méthode CreateFunctionAlias crée un « alias de fonction », un « alias rapide » pour une méthode implémentée dans une extension. La signification de cet alias est spécifique à l’hôte. Il peut étendre l’évaluateur d’expression de l’hôte avec la fonction ou faire quelque chose de complètement différent.

Pour Les outils de débogage pour Windows, un alias de fonction :

• Est accessible dans l’évaluateur d’expression via le symbole @$ . Un alias de fonction inscrit sous someName peut être appelé dans l’évaluateur via @$someName (...).

• Peut être appelé via l’ancienne syntaxe bang. L’appel « !someName arg1, arg2, ... » est sémantiquement équivalent à l’exécution de l’évaluateur d’expression (dx) avec « @$someName(arg1, arg2, ...) » et à l’affichage du résultat.

Syntaxe

HRESULT CreateFunctionAlias(
  PCWSTR       aliasName,
  IModelObject *functionObject
);

Paramètres

aliasName

Nom (rapide) de l’alias en cours de création/inscription.

functionObject

Méthode de modèle de données (un IModelMethod boxé dans un IModelObject) qui implémente les fonctionnalités de l’alias de fonction.

Valeur retournée

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

Remarques

Exemple de Code

class MySumFunction:
    public Microsoft::WRL::RuntimeClass<
        Microsoft::WRL::RuntimeClassFlags<
            Microsoft::WRL::RuntimeClassType::ClassicCom
            >,
        IModelMethod
        >
{
public:

    IFACEMETHOD(Call)(_In_ IModelObject * /*pContextObject*/, 
                      _In_ ULONG64 argCount, 
                      _In_reads_(argCount) IModelObject **ppArguments, 
                      _COM_Errorptr_ **ppResult)
    {
        HRESULT hr = S_OK;
        *ppResult = nullptr;

        if (argCount == 0)
        {
            return E_INVALIDARG;
        }

        int sum = 0;
        for (ULONG64 i = 0; i < argCount; ++i)
        {
            VARIANT vtValue;
            if (FAILED(ppArguments[i]->GetIntrinsicValueAs(&vtValue)))
            {
                return E_INVALIDARG;
            }
            sum += vtValue.lVal;
        }

        VARIANT vtSum;
        vtSum.vt = VT_I4;
        vtSum.lVal = sum;

        ComPtr<IModelObject> spSum;
        hr = GetManager()->CreateIntrinsicObject(ObjectIntrinsic, &vtSum, &spSum);
        if (SUCCEEDED(hr))
        {
            *ppResult = spSum.Detach();
        }

        return hr;
    }
};

// Create a method object and register it as a function alias.
ComPtr<MySumFunction> spSumFunc = Microsoft::WRL::Make<MySumFunction>();
if (spSumFunc != nullptr)
{
    VARIANT vtMethod;
    vtMethod.vt = VT_UNKNOWN;
    vtMethod.punkVal = static_cast<IModelMethod *>(spSumFunc.Get());
    
    ComPtr<IModelObject> spMethodObject;
    if (SUCCEEDED(GetManager()->CreateIntrinsicObject(ObjectMethod, 
                                                      &vtMethod, 
                                                      &spMethodObject)))
    {
        ComPtr<IDebugHostExtensibility> spHostExtensibility;
        if (SUCCEEDED(GetHost()->QueryInterface(IID_PPV_ARGS(&spHostExtensibility)))
        {
            if (SUCCEEDED(spHostExtensibility->CreateFunctionAlias(
                L"sumit",
                spMethodObject.Get())))
            {
                // sumit is now an alias for our function.  The meaning here 
                // is host specific.  For DbgEng, it means you can do things
                // like "dx @$sumit(5, 7, 8)" or "!sumit 5, 7, 8"
            }
        }
    }
}

Configuration requise

Voir aussi

Interface IDebugHostExtensibility