Compartilhar via

Implementação amostral da avaliação da expressão

  • Artigo

Importante

No Visual Studio 2015, essa maneira de implementar avaliadores de expressão foi preterida. Para obter informações sobre como implementar avaliadores de expressão CLR, consulte Avaliadores de expressão CLR e Exemplo de avaliador de expressão gerenciada.

Para uma expressão de janela de inspeção , o Visual Studio chama ParseText para produzir um objeto IDebugExpression2 . IDebugExpressionContext2::ParseText instancia um avaliador de expressão (EE) e chama Parse para obter um objeto IDebugParsedExpression .

O IDebugExpressionEvaluator::Parse executa as seguintes tarefas:

  1. [Somente C++] Analisa a expressão para procurar erros.

  2. Instancia uma classe (chamada CParsedExpression neste exemplo) que executa a interface e armazena na classe a expressão a IDebugParsedExpression ser analisada.

  3. Retorna a IDebugParsedExpression interface do CParsedExpression objeto.

Observação

Nos exemplos a seguir e no exemplo MyCEE, o avaliador da expressão não separa a análise da avaliação.

Código gerenciado

O código a seguir mostra uma implementação de IDebugExpressionEvaluator::Parse no código gerenciado. Esta versão do método adia a análise para EvaluateSync, pois o código para análise também é avaliado ao mesmo tempo (consulte Avaliar uma expressão de inspeção).

namespace EEMC
{
    public class CParsedExpression : IDebugParsedExpression
    {
        public HRESULT Parse(
                string                 expression,
                uint                   parseFlags,
                uint                   radix,
            out string                 errorMessage,
            out uint                   errorPosition,
            out IDebugParsedExpression parsedExpression)
        {
            errorMessage = "";
            errorPosition = 0;

            parsedExpression =
                new CParsedExpression(parseFlags, radix, expression);
            return COM.S_OK;
        }
    }
}

Código não gerenciado

O código a seguir é uma implementação de IDebugExpressionEvaluator::Parse em código não gerenciado. Esse método chama uma função auxiliar, , para analisar a expressão e verificar erros, Parsemas esse método ignora o valor resultante. A avaliação formal é adiada para EvaluateSync , onde a expressão é analisada enquanto é avaliada (consulte Avaliar uma expressão de observação).

STDMETHODIMP CExpressionEvaluator::Parse(
        in    LPCOLESTR                 pszExpression,
        in    PARSEFLAGS                flags,
        in    UINT                      radix,
        out   BSTR                     *pbstrErrorMessages,
        inout UINT                     *perrorCount,
        out   IDebugParsedExpression  **ppparsedExpression
    )
{
    if (pbstrErrorMessages == NULL)
        return E_INVALIDARG;
    else
        *pbstrErrormessages = 0;

    if (pparsedExpression == NULL)
        return E_INVALIDARG;
    else
        *pparsedExpression = 0;

    if (perrorCount == NULL)
        return E_INVALIDARG;

    HRESULT hr;
    // Look for errors in the expression but ignore results
    hr = ::Parse( pszExpression, pbstrErrorMessages );
    if (hr != S_OK)
        return hr;

    CParsedExpression* pparsedExpr = new CParsedExpression( radix, flags, pszExpression );
    if (!pparsedExpr)
        return E_OUTOFMEMORY;

    hr = pparsedExpr->QueryInterface( IID_IDebugParsedExpression,
                                      reinterpret_cast<void**>(ppparsedExpression) );
    pparsedExpr->Release();

    return hr;
}

Confira também