/// <summary>
/// Gets the value of the specified global variable.
/// </summary>
/// <param name="fieldDef">
/// An <c>mdFieldDef</c> token that references the metadata
/// describing the global variable.
/// </param>
/// <param name="value">The value of the specified global variable.</param>
public int GetGlobalVariableValue(uint fieldDef, out CorDebugValue value)
{
void **pValue = default;
int result = Calli(_this, This[0]->GetGlobalVariableValue, fieldDef, &pValue);
ComFactory.Create(pValue, out value);
return(result);
}
/// <summary>
/// Gets the value of the specified argument in this Microsoft intermediate
/// language (MSIL) stack frame.
/// </summary>
/// <param name="dwIndex">
/// The index of the argument in this MSIL stack frame.
/// </param>
/// <param name="value">
/// A pointer to the address of an <c>ICorDebugValue</c> object that
/// represents the retrieved value.
/// </param>
/// <remarks>
/// The <c>GetArgument</c> method can be used either in an MSIL stack frame
/// or in a just-in-time (JIT) compiled frame.
/// </remarks>
public int GetArgument(uint dwIndex, out CorDebugValue value)
{
void **pValue = default;
int hResult = Calli(_this, This[0]->GetArgument, dwIndex, &pValue);
ComFactory.Create(pValue, hResult, out value);
return(hResult);
}
/// <summary>
/// Gets the element at the given position, treating the array as
/// a zero-based, single-dimensional array.
/// </summary>
/// <param name="position">
/// The position of the element to be retrieved.
/// </param>
/// <param name="value">
/// A pointer to the address of an <c>ICorDebugValue</c> object that
/// represents the value of the element.
/// </param>
/// <remarks>
/// The layout of a multi-dimension array follows the C++ style of
/// array layout.
/// </remarks>
public int GetElementAtPosition(uint position, out CorDebugValue value)
{
void **pValue = default;
int hResult = Calli(_this, This[0]->GetElementAtPosition, position, &pValue);
ComFactory.Create(pValue, hResult, out value);
return(hResult);
}
/// <summary>
/// Gets a managed object from a COM callable wrapper (CCW) pointer.
/// </summary>
/// <param name="ccwPointer">
/// A COM callable wrapper (CCW) pointer.
/// </param>
/// <param name="managedObject">
/// A pointer to the address of an <c>ICorDebugValue</c> object that
/// represents the managed object that corresponds to the given CCW pointer.
/// </param>
public int GetObjectForCCW(long ccwPointer, out CorDebugValue managedObject)
{
void **pManagedObject = default;
int hResult = Calli(_this, This[0]->GetObjectForCCW, ccwPointer, &pManagedObject);
ComFactory.Create(pManagedObject, hResult, out managedObject);
return(hResult);
}
/// <summary>
/// Gets the value of the specified static field.
/// </summary>
/// <param name="fieldDef">
/// A FieldDef token that references the field to be retrieved.
/// </param>
/// <param name="frame">
/// The frame to be used to disambiguate among thread, context, or application
/// domain statics.
///
/// If the static field is relative to a thread, a context, or an application domain,
/// the frame will determine the proper value.
/// </param>
/// <param name="value">The value of the static field.</param>
/// <remarks>
/// For parameterized types, the value of a static field is relative to the particular
/// instantiation. Therefore, if the class constructor takes parameters of type
/// <see cref="Type" />, call <see cref="CorDebugType.GetStaticFieldValue" /> instead.
/// </remarks>
public int GetStaticFieldValue(uint fieldDef, CorDebugFrame frame, out CorDebugValue value)
{
using var pFrame = frame.AcquirePointer();
void *pValue = default;
int result = Calli(_this, This[0]->GetStaticFieldValue, fieldDef, pFrame, &pValue);
ComFactory.Create(pValue, out value);
return(result);
}
/// <summary>
/// Gets the value of the specified field of the specified class for this object value.
/// </summary>
/// <remarks>
/// The class, specified in <see paramref="class" />, must be in
/// the hierarchy of the object value's class, and the field must
/// be a field of that class.
///
/// This method will still succeed for generic objects and generic
/// classes. For example, if <c>MyDictionary{V}</c> inherits from
/// <c>Dictionary{string,V}</c>, and the object value is of type
/// <c>MyDictionary{int32}</c>, passing the <see cref="CorDebugClass" />
/// object for <c>Dictionary{K,V}</c> will successfully get a
/// field of <c>Dictionary{string,int32}</c>.
/// </remarks>
public int GetFieldValue(CorDebugClass @class, uint fieldDef, out CorDebugValue value)
{
using var pClass = @class.AcquirePointer();
void **pValue = default;
int result = Calli(_this, This[0]->GetFieldValue, pClass, fieldDef, &pValue);
ComFactory.Create(pValue, out value);
return(result);
}
/// <summary>
/// Gets the value of the given array element.
/// </summary>
/// <param name="indices">
/// An array of index values, each of which specifies a position within a dimension
/// of the <c>ICorDebugArrayValue</c> object.
///
/// This value must not be null.
/// </param>
/// <param name="value">
/// A pointer to the address of an <c>ICorDebugValue</c> object that represents
/// the value of the specified element.
/// </param>
public int GetElement(Span <uint> indices, out CorDebugValue value)
{
void **pValue = default;
fixed(void *pIndices = indices)
{
int hResult = Calli(_this, This[0]->GetElement, indices.Length, pIndices, &pValue);
ComFactory.Create(pValue, hResult, out value);
return(hResult);
}
}
/// <summary> /// Gets a <see cref="CorDebugValue" /> representing the common /// language runtime (CLR) thread. /// </summary> public int GetObject(out CorDebugValue @object) => InvokeGetObject(_this, This[0]->GetObject, out @object);
/// <summary> /// Gets the exception that is currently being thrown by /// managed code. /// </summary> /// <remarks> /// The exception object will exist from the time the exception /// is thrown until the end of the catch block. A function /// evaluation, which is performed by the <see cref="CorDebugEval" /> /// methods, will clear out the exception object on setup and /// restore it on completion. /// /// Exceptions can be nested (for example, if an exception is /// thrown in a filter or in a function evaluation), so there /// may be multiple outstanding exceptions on a single thread. /// This method returns the most current exception. /// /// The exception object and type may change throughout the /// life of the exception. For example, after an exception of /// type x is thrown, the common language runtime (CLR) may /// run out of memory and promote it to an out-of-memory /// exception. /// </remarks> public int GetCurrentException(out CorDebugValue exceptionObject) => InvokeGetObject(_this, This[0]->GetCurrentException, out exceptionObject);
/// <summary> /// Gets the value of the object on which the breakpoint is set. /// </summary> public int GetValue(out CorDebugValue value) => InvokeGetObject(_this, This[0]->GetValue, out value);
public int DereferenceStrong(out CorDebugValue pValue) => InvokeGetObject(_this, This[0]->DereferenceStrong, out pValue);
public int CreateValue(CorElementType elementType, CorDebugClass elementClass, out CorDebugValue value)
{
using var pElementClass = elementClass.AcquirePointer();
void *pValue = default;
int result = Calli(_this, This[0]->CreateValue, (int)elementType, pElementClass, &pValue);
ComFactory.Create(pValue, out value);
return(result);
}
/// <summary> /// Gets the results of this evaluation. /// </summary> /// <param name="result"></param> /// <returns></returns> /// <remarks> /// This method is valid only after the evaluation is completed. /// /// If the evaluation completes normally, <see paramref="result" /> specifies the /// results. If it terminates with an exception, the result is the exception thrown. /// If the evaluation was for a new object, the result is the reference to the new object. /// </remarks> public int GetResult(out CorDebugValue result) => InvokeGetObject(_this, This[0]->GetResult, out result);
