/// <summary>
/// Gets an enumerator for all objects that are to be garbage-collected
/// in a process.
/// </summary>
/// <param name="enumerateWeakReferences">
/// A <c>Boolean</c> value that indicates whether weak references are also
/// to be enumerated. If <c>enumerateWeakReferences</c> is <c>true</c>, the
/// <c>ppEnum</c> enumerator includes both strong references and weak references.
/// If <c>enumerateWeakReferences</c> is <c>false</c>, the enumerator includes
/// only strong references.
/// </param>
/// <param name="ppEnum">
/// A pointer to the address of an <c>ICorDebugGCReferenceEnum</c> that is an
/// enumerator for the objects to be garbage-collected.
/// </param>
/// <remarks>
/// This method provides a way to determine the full rooting chain
/// for any managed object in a process and can be used to determine
/// why an object is still alive.
/// </remarks>
public int EnumerateGCReferences(bool enumerateWeakReferences, out CorDebugStructEnum <COR_GC_REFERENCE> ppEnum)
{
void **pppEnum = default;
int hResult = Calli(_this, This[0]->EnumerateGCReferences, enumerateWeakReferences.ToNativeInt(), &pppEnum);
ppEnum = ComFactory.Create <CorDebugStructEnum <COR_GC_REFERENCE> >(pppEnum, hResult);
return(hResult);
}
/// <summary>
/// Gets an enumerator for the memory ranges of the managed heap.
/// </summary>
/// <param name="ppRegions">
/// A pointer to the address of an <c>ICorDebugHeapSegmentEnum</c>
/// interface object that is an enumerator for the ranges of memory
/// in which objects reside in the managed heap.
/// </param>
/// <remarks>
/// Before calling the <c>ICorDebugProcess5::EnumerateHeapRegions</c>
/// method, you should call the <c>ICorDebugProcess5::GetGCHeapInformation</c>
/// method and examine the value of the <c>areGCStructuresValid</c>
/// field of the returned <c>COR_HEAPINFO</c> object to ensure that
/// the garbage collection heap in its current state is enumerable.
/// In addition, the <c>ICorDebugProcess5::EnumerateHeapRegions</c>
/// method returns <c>E_FAIL</c> if you attach too early in the lifetime
/// of the process, before memory regions are created.
///
/// This method is guaranteed to enumerate all memory regions that may
/// contain managed objects, but it does not guarantee that managed objects
/// actually reside in those regions. The <c>ICorDebugHeapSegmentEnum</c>
/// collection object may include empty or reserved memory regions.
///
/// The <c>ICorDebugHeapSegmentEnum</c> interface object is a standard
/// enumerator derived from the <c>ICorDebugEnum</c> interface that allows
/// you to enumerate <c>COR_SEGMENT</c> objects. Each <c>COR_SEGMENT</c>
/// object provides information about the memory range of a particular
/// segment, along with the generation of the objects in that segment.
/// </remarks>
public int EnumerateHeapRegions(out CorDebugStructEnum <COR_SEGMENT> ppRegions)
{
void **ptr = default;
int hResult = Calli(_this, This[0]->EnumerateHeapRegions, &ptr);
ppRegions = ComFactory.Create <CorDebugStructEnum <COR_SEGMENT> >(ptr, hResult);
return(hResult);
}
/// <summary>
/// Gets an enumerator for the objects on the managed heap.
/// </summary>
/// <param name="ppObject">
/// A pointer to the address of an <c>ICorDebugHeapEnum</c> interface object
/// that is an enumerator for the objects that reside on the managed heap.
/// </param>
/// <remarks>
/// Before calling the <c>ICorDebugProcess5::EnumerateHeap</c> method,
/// you should call the <c>ICorDebugProcess5::GetGCHeapInformation</c> method and
/// examine the value of the <c>areGCStructuresValid</c> field of the returned
/// <c>COR_HEAPINFO</c> object to ensure that the garbage collection heap in its
/// current state is enumerable. In addition, the <c>ICorDebugProcess5::EnumerateHeap</c>
/// returns <c>E_FAIL</c> if you attach too early in the lifetime of the process,
/// before memory for the managed heap is allocated.
///
/// The <c>ICorDebugHeapEnum</c> interface object is a standard enumerator
/// derived from the <c>ICorDebugEnum</c> interface that allows you to enumerate
/// <c>COR_HEAPOBJECT</c> objects. This method populates the <c>ICorDebugHeapEnum</c>
/// collection object with <c>COR_HEAPOBJECT</c> instances that provide information
/// about all objects. The collection may also include <c>COR_HEAPOBJECT</c> instances
/// that provide information about objects that are not rooted by any object but
/// have not yet been collected by the garbage collector.
/// </remarks>
public int EnumerateHeap(out CorDebugStructEnum <COR_HEAPOBJECT> ppObjects)
{
void **pointer = default;
int hResult = Calli(_this, This[0]->EnumerateHeap, &pointer);
ppObjects = ComFactory.Create <CorDebugStructEnum <COR_HEAPOBJECT> >(pointer, hResult);
return(hResult);
}
/// <summary>
/// Gets an enumerator for object handles in a process.
/// </summary>
/// <param name="types">
/// A bitwise combination of <c>CorGCReferenceType</c> values that
/// specifies the type of handles to include in the collection.
/// </param>
/// <param name="ppENum">
/// A pointer to the address of an <c>ICorDebugGCReferenceEnum</c> that
/// is an enumerator for the objects to be garbage-collected.
/// </param>
/// <remarks>
/// <c>EnumerateHandles</c> is a helper function that supports inspection
/// of the handle table. It is similar to the <c>ICorDebugProcess5::EnumerateGCReferences</c>
/// method, except that rather than populating an <c>ICorDebugGCReferenceEnum</c>
/// collection with all objects to be garbage-collected, it includes only
/// objects that have handles from the handle table.
///
/// The <c>types</c> parameter specifies the handle types to include
/// in the collection. <c>types</c> can be any of the following three
/// members of the <c>CorGCReferenceType</c> enumeration:
///
/// - <c>CorHandleStrongOnly</c> (handles to strong references only).
/// - <c>CorHandleWeakOnly</c> (handles to weak references only).
/// - <c>CorHandleAll</c> (all handles).
/// </remarks>
public int EnumerateHandles(CorGCReferenceType types, out CorDebugStructEnum <COR_GC_REFERENCE> ppEnum)
{
void **pointer = default;
int hResult = Calli(_this, This[0]->EnumerateHandles, (uint)types, &pointer);
ppEnum = ComFactory.Create <CorDebugStructEnum <COR_GC_REFERENCE> >(pointer, hResult);
return(hResult);
}
internal Enumerator(CorDebugStructEnum <T> parent)
{
int hResult = parent.Clone(out _parent);
_ownsParent = hResult != HResult.E_NOTIMPL;
if (_ownsParent)
{
hResult.MaybeThrowHr();
}
else
{
_parent = parent;
}
_obj = default;
}
/// <summary> /// Gets an enumerator for all cached Windows Runtime types. /// </summary> /// <param name="guidToTypeEnum"> /// A pointer to an <c>ICorDebugGuidToTypeEnum</c> interface object that /// can enumerate the managed representations of Windows Runtime types /// currently loaded in the application domain. /// </param> public int GetCachedWinRTTypes(out CorDebugStructEnum <CorDebugGuidToTypeMapping> guidToTypeEnum) => InvokeGetObject(_this, This[0]->GetCachedWinRTTypes, out guidToTypeEnum);
