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

El método CreateFunctionAlias crea un "alias de función", un "alias rápido" para un método implementado en alguna extensión. El significado de este alias es específico del host. Puede extender el evaluador de expresiones del host con la función o puede hacer algo completamente diferente.

En Herramientas de depuración para Windows, un alias de función:

• Es accesible en el evaluador de expresiones a través del símbolo @$ . Se puede llamar a un alias de función registrado en someName en el evaluador a través de @$someName(...).

• Se puede invocar a través de la sintaxis de bang anterior. La invocación "!someName arg1, arg2, ..." es semánticamente equivalente a ejecutar el evaluador de expresiones (dx) con "@$someName(arg1, arg2, ...)" y mostrando el resultado.

Sintaxis

HRESULT CreateFunctionAlias(
  PCWSTR       aliasName,
  IModelObject *functionObject
);

Parámetros

aliasName

Nombre (rápido) del alias que se va a crear o registrar.

functionObject

Un método de modelo de datos (un IModelMethod boxed en un IModelObject) que implementa la funcionalidad del alias de función.

Valor devuelto

Este método devuelve HRESULT, que indica que se ha realizado correctamente o no.

Comentarios

Código de ejemplo

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

Requisitos

Requisito	Valor
Header	dbgmodel.h

Consulte también

Interfaz IDebugHostExtensibility