Évaluer les variables localesEvaluating 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, please see CLR Expression Evaluators and Managed Expression Evaluator Sample.

GetPropertyInfo est appelée pour obtenir la valeur d’une variable locale, 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. Étant donné que la valeur des variables locales dépend de l’état actuel du programme, de l’ordinateur local 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 la IDebugField objet représentant l’ordinateur local à 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 dans la 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 des variables locales 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 dans 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 les type de l’ordinateur local.Formats the value based on the local's type.

  4. Retourne un objet générique qui contient les valeur de l’ordinateur local.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 des variables locales 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 des variables locales en code non managé.This is an implementation of a function that retrieves the value of a local in unmanaged code. FieldGetType figure 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
Obtention des valeurs locales Getting Local Values
Contexte d’évaluationEvaluation Context