Évaluer les variables localesEvaluate locals

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, see CLR expression evaluators and Managed expression evaluator sample.

GetPropertyInfo est appelée pour obtenir la valeur de local, ainsi que les nom de l’ordinateur local et le type.GetPropertyInfo is called to obtain the value of a local, as well as the local's name and type. Dans la mesure où la valeur d’une variable locale est dépendante de l’état actuel du programme, la valeur de la locale doit être obtenue à partir de la mémoire.Since the value of a local is dependent on the current state of the program, the local's value must be obtained from memory. Le IDebugBinder objet est utilisé pour lier le IDebugField objet représentant l’ordinateur local vers l’emplacement approprié dans la mémoire contenant la valeur.The IDebugBinder object is used to bind the IDebugField object representing the local to the appropriate location in memory containing the value. Cet emplacement en mémoire est représenté par un IDebugObject objet.This location in memory is represented by an IDebugObject object.

Cette fonctionnalité de récupération de la valeur d’une variable locale est encapsulée dans une fonction d’assistance qui effectue les tâches suivantes :This functionality of retrieving the value of a local is encapsulated in a helper function that performs the following tasks:

  1. Lie le IDebugField objet vers la mémoire pour obtenir un IDebugObject objet.Binds the IDebugField object to memory to obtain an IDebugObject object.

  2. Obtient la valeur de la mémoire.Gets the value from memory. Cette valeur est représentée comme une série d’octets.This value is represented as a series of bytes.

  3. Met en forme la valeur basée sur type de l’ordinateur local.Formats the value based on the local's type.

  4. Retourne un objet générique qui contient la valeur de la locale.Returns a generic object that contains the local's value. En c#, il s’agit d’un object, et en C++, il s’agit d’un VARIANT.In C#, this is an object, and in C++, this is a VARIANT.

Code managéManaged code

Il s’agit d’une implémentation d’une fonction qui Récupère la valeur d’une variable locale dans le code managé.This is an implementation of a function that retrieves the value of a local in managed code.

namespace EEMC  
{  
    internal class Field  
    {  
        internal static object GetValue(  
            IDebugBinder binder,  
            IDebugField field,  
            Type t,  
            uint size)  
        {  
            if (t == null || size == 0)  return null;  

            IDebugObject debugObject = null;  
            binder.Bind(null, field, out debugObject);  

            byte[] buffer = new byte[size];  
            for (int i = 0; i < size; i++)  buffer[i] = 0;  

            debugObject.GetValue(buffer, size);   

            if (t == typeof(sbyte)) return (sbyte) buffer[0];  
            if (t == typeof(short)) return BitConverter.ToInt16(buffer, 0);  
            if (t == typeof(int))   return BitConverter.ToInt32(buffer, 0);  
            if (t == typeof(long))  return BitConverter.ToInt64(buffer, 0);  
            if (t == typeof(byte))  return buffer[0];  
            if (t == typeof(char))  return BitConverter.ToChar(buffer, 0);  
            if (t == typeof(uint))  return BitConverter.ToUInt32(buffer, 0);  
            if (t == typeof(ulong)) return BitConverter.ToUInt64(buffer, 0);  
            if (t == typeof(float)) return BitConverter.ToSingle(buffer, 0);  
            if (t == typeof(double))  return BitConverter.ToDouble(buffer, 0);  
            if (t == typeof(bool))  return BitConverter.ToBoolean(buffer, 0);  
            if (t == typeof(string))  return BitConverter.ToString(buffer, 0);  
            return null;  
        }  
    }  
}  

Code non managéUnmanaged code

Il s’agit d’une implémentation d’une fonction qui Récupère la valeur d’une variable locale dans le code non managé.This is an implementation of a function that retrieves the value of a local in unmanaged code. FieldGetType est indiqué dans l’obtention des valeurs locales.FieldGetType is shown in Getting Local Values.

HRESULT FieldGetPrimitiveValue(  
    in  IDebugBinder* pbinder,  
    in  IDebugField*  pfield,  
    out VARIANT*      pvarValue  
    )  
{  
    if (pvarValue == NULL)  
        return E_INVALIDARG;  
    else  
        *pvarValue = 0;  

    if (pfield == NULL)  
        return E_INVALIDARG;  

    if (pbinder == NULL)  
        return E_INVALIDARG;  

    HRESULT hr;  
    UINT          valueSize = 0;  
    BYTE*         pvalueBits = NULL;  
    IDebugObject* pobject    = NULL;  

    //get the value as bits  
    hr = pbinder->Bind( NULL, pfield, &pobject );  
    if (FAILED(hr))  
        return hr;  

    hr = pobject->GetSize( &valueSize );  
    if (FAILED(hr))  
    {  
        pobject->Release();  
        return hr;  
    }  

    pvalueBits = reinterpret_cast<BYTE *>(malloc(valueSize * sizeof(BYTE)));  
    if (!pvalueBits)  
    {  
        pobject->Release();  
        return E_OUTOFMEMORY;  
    }  

    hr = pobject->GetValue( pvalueBits, valueSize );  
    pobject->Release();  
    if (FAILED(hr))  
    {  
        free(pvalueBits);  
        return hr;  
    }  

    //get the type  
    VARIANT     valueType;  

    hr = FieldGetType( pfield, &valueType );  
    if (FAILED(hr))  
    {  
        free(pvalueBits);  
        return hr;  
    }  

    //copy a primitive value  
    switch (valueType.vt)  
    {  
    case VT_BSTR:  
        {  
            pvarValue->vt = VT_BSTR;  
            if (valueSize == 0)  
                pvarValue->bstrVal = SysAllocString( OLE("") );  
            else  
                pvarValue->bstrVal =  
                    SysAllocStringByteLen( reinterpret_cast<char*>(pvalueBits),  
                                           valueSize );  
        }  

    case VT_BOOL:  
    case VT_I1:  
    case VT_I2:  
    case VT_I4:  
    case VT_I8:  
    case VT_UI1:  
    case VT_UI2:  
    case VT_UI4:  
    case VT_UI8:  
    case VT_R4:  
    case VT_R8:  
        pvarValue->vt = valueType.vt;  

        if (valueSize > 8)  
            valueSize = 8;  
        memcpy( &(pvarValue->iVal), pvalueBits, valueSize );  
        break;  

    case VT_VOID:  
    case VT_EMPTY:  
        pvarValue->vt = valueType.vt;  
        break;  

    default:  
        //not a primitive type  
        VariantClear(&valueType);  
        free(pvalueBits);  
        return E_FAIL;  
    }  

    free(pvalueBits);  
    VariantClear(&valueType);  
    return S_OK;  
}  

Voir aussiSee also

Exemple d’implémentation des variables locales Sample implementation of locals
Obtenir les valeurs locales Get local values
Contexte d’évaluationEvaluation context