Exemple d’implémentation de l’évaluation d’ExpressionSample Implementation of Expression Evaluation

Important

Dans Visual Studio 2015, ce moyen d’implémenter des évaluateurs d’expression est déconseillée.In Visual Studio 2015, this way of implementing expression evaluators is deprecated. Pour plus d’informations sur l’implémentation des évaluateurs d’expression CLR, consultez évaluateurs d’Expression CLR et exemple d’évaluateur d’Expression managé.For information about implementing CLR expression evaluators, please see CLR Expression Evaluators and Managed Expression Evaluator Sample.

Pour un espion expression de la fenêtre, les appels de Visual Studio ParseText pour produire un IDebugExpression2 objet.For a Watch window expression, Visual Studio calls ParseText to produce an IDebugExpression2 object. IDebugExpressionContext2::ParseText instancie l’évaluateur d’expression (EE) et appelle analyser pour obtenir un IDebugParsedExpression objet.IDebugExpressionContext2::ParseText instantiates an expression evaluator (EE) and calls Parse to obtain an IDebugParsedExpression object.

Cette implémentation de IDebugExpressionEvaluator::Parse effectue les tâches suivantes :This implementation of IDebugExpressionEvaluator::Parse performs the following tasks:

  1. (C++ uniquement) Analyse de l’expression pour rechercher des erreurs.[C++ only] Parses the expression to look for errors.

  2. Instancie une classe (appelée CParsedExpression dans cet exemple) qui implémente le IDebugParsedExpression de l’interface et la stocke dans la classe de l’expression doit être analysé.Instantiates a class (called CParsedExpression in this example) that implements the IDebugParsedExpression interface and stores in the class the expression to be parsed.

  3. Retourne le IDebugParsedExpression de l’interface à partir de la CParsedExpression objet.Returns the IDebugParsedExpression interface from the CParsedExpression object.

Note

Dans les exemples qui suivent et dans l’exemple MyCEE, l’évaluateur d’expression ne sépare pas l’analyse de l’évaluation.In the examples that follow and in the MyCEE sample, the expression evaluator does not separate the parsing from the evaluation.

Code managéManaged Code

Il s’agit d’une implémentation de IDebugExpressionEvaluator::Parse dans le code managé.This is an implementation of IDebugExpressionEvaluator::Parse in managed code. Notez que cette version de la méthode diffère de l’analyse à EvaluateSync comme le code d’analyse évalue également en même temps (consultez l’évaluation d’une Expression espionne).Note that this version of the method defers the parsing to EvaluateSync as the code for parsing also evaluates at the same time (see Evaluating a Watch Expression).

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

Code non managéUnmanaged Code

Il s’agit d’une implémentation de IDebugExpressionEvaluator::Parse en code non managé.This is an implementation of IDebugExpressionEvaluator::Parse in unmanaged code. Cette méthode appelle une fonction d’assistance, Parse, d’analyser l’expression et recherchez les erreurs, mais cette méthode ignore la valeur obtenue.This method calls a helper function, Parse, to parse the expression and check for errors but this method ignores the resulting value. L’évaluation formelle est soumise à EvaluateSync où l’expression est analysée pendant qu’elle est évaluée (consultez l’évaluation d’une Expression espionne).The formal evaluation is deferred to EvaluateSync where the expression is parsed while it is evaluated (see Evaluating a Watch Expression).

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

Voir aussiSee Also

L’évaluation d’une Expression de la fenêtre Espion Evaluating a Watch Window Expression
Évaluation d’une expression espionneEvaluating a Watch Expression