internal unsafe Enumerator(CorDebugComEnum <TUnknown> parent) { int hResult = parent.Clone(out _parent); _ownsParent = hResult != HResult.E_NOTIMPL; if (_ownsParent) { hResult.MaybeThrowHr(); } else { _parent = parent; } _ptr = default; }
/// <summary> /// Gets an enumerator for cached Windows Runtime types in an application /// domain based on their interface identifiers. /// </summary> /// <param name="cReqTypes"> /// The number of required types. /// </param> /// <param name="iidsToResolve"> /// A pointer to an array that contains the interface identifiers /// corresponding to the managed representations of the Windows Runtime /// types to be retrieved. /// </param> /// <param name="typesEnum"> /// A pointer to the address of an <c>ICorDebugTypeEnum</c> interface object /// that allows enumeration of the cached managed representations of the /// Windows Runtime types retrieved, based on the interface identifiers in /// <c>iidsToResolve</c>. /// </param> /// <remarks> /// If the method fails to retrieve information for a specific interface /// identifier, the corresponding entry in the <c>ICorDebugTypeEnum</c> /// collection will have a type of <c>ELEMENT_TYPE_END</c> for errors due /// to data retrieval issues, or <c>ELEMENT_TYPE_VOID</c> for unknown /// interface identifiers. /// </remarks> public int GetCachedWinRTTypesForIIDs( Span <Guid> iidsToResolve, out CorDebugComEnum <CorDebugType> typesEnum) { void **pTypesEnum = default; fixed(void *piidsToResolve = iidsToResolve) { int hResult = Calli( _this, This[0]->GetCachedWinRTTypesForIIDs, iidsToResolve.Length, piidsToResolve, &pTypesEnum); ComFactory.Create(pTypesEnum, hResult, out typesEnum); return(hResult); } }
/// <summary> /// Gets an enumerator to the local variables and arguments in /// a function. /// </summary> /// <param name="enum"> /// A pointer to the address of an <c>ICorDebugVariableHomeEnum</c> /// interface object that is an enumerator for the local variables /// and arguments in a function. /// </param> /// <remarks> /// The <c>ICorDebugVariableHomeEnum</c> interface object is a standard /// enumerator derived from the <c>ICorDebugEnum</c> interface that allows /// you to enumerate <c>ICorDebugVariableHome</c> objects. The collection /// may include multiple <c>ICorDebugVariableHome</c> objects for the same /// slot or argument index if they have different homes at different points /// in the function. /// </remarks> public int EnumerateVariableHomes(out CorDebugComEnum <CorDebugVariableHome> @enum) => InvokeGetObject(_this, This[0]->EnumerateVariableHomes, out @enum);
/// <summary> /// Gets an enumerator for the local variables in this frame. /// </summary> /// <param name="valueEnum"> /// A pointer to the address of an <c>ICorDebugValueEnum</c> object that /// is the enumerator for the local variables in this frame. /// </param> /// <remarks> /// <c>EnumerateLocalVariables</c> gets an enumerator that can list the /// local variables available in the call frame that is represented by /// this <c>ICorDebugILFrame</c> object. The list may not include all /// of the local variables in the running function, because some of /// them may not be active. /// </remarks> public int EnumerateLocalVariables(out CorDebugComEnum <CorDebugValue> valueEnum) => InvokeGetObject(_this, This[0]->EnumerateLocalVariables, out valueEnum);
/// <summary> /// Gets an enumerator for the arguments in this frame. /// </summary> /// <param name="valueEnum"> /// A pointer to the address of an <c>ICorDebugValueEnum</c> object that /// is the enumerator for the arguments in this frame. /// </param> /// <remarks> /// <c>EnumerateArguments</c> gets an enumerator that can list the /// arguments available in the call frame that is represented by this /// <c>ICorDebugILFrame</c> object. The list will include arguments /// that are vararg (that is, a variable number of arguments) as well /// as arguments that are not <c>vararg</c>. /// </remarks> public int EnumerateArguments(out CorDebugComEnum <CorDebugValue> valueEnum) => InvokeGetObject(_this, This[0]->EnumerateArguments, out valueEnum);
/// <summary> /// Gets an enumerator that contains all the managed stack frames in the chain, /// starting with the most recent frame. /// </summary> /// <remarks> /// The chain represents the physical call stack for the thread. /// /// This method should be called only for managed chains. The debugging API does not /// provide methods for obtaining frames contained in unmanaged chains. The debugger /// must use other means to obtain this information. /// </remarks> public int EnumerateFrames(out CorDebugComEnum <CorDebugFrame> frames) => InvokeGetObject(_this, This[0]->EnumerateFrames, out frames);
/// <summary> /// Gets the modules contained in this instance. /// </summary> public int EnumerateModules(out CorDebugComEnum <CorDebugModule> modules) => InvokeGetObject(_this, This[0]->EnumerateModules, out modules);
/// <summary> /// Gets an enumerator for the active managed threads in the process. /// </summary> /// <remarks> /// A thread is considered active after the <c>ICorDebugManagedCallback::CreateThread</c> /// callback has been dispatched and before the <c>ICorDebugManagedCallback::ExitThread</c> /// callback has been dispatched. A managed thread may not necessarily have any managed /// frames on its stack. Threads can be enumerated even before the <c>ICorDebugManagedCallback::CreateProcess</c> /// callback. The enumeration will naturally be empty. /// </remarks> public int EnumerateThreads(out CorDebugComEnum <CorDebugThread> threads) => InvokeGetObject(_this, This[0]->EnumerateThreads, out threads);
public int EnumerateNativeCode(out CorDebugComEnum <CorDebugCode> pCodeEnum) => InvokeGetObject(_this, This[0]->EnumerateNativeCode, out pCodeEnum);
/// <summary> /// Gets all of the stack chains in this thread. /// </summary> /// <param name="chains"> /// An enumerable containing all of the stack chains in this /// thread, starting at the active (most recent) chain. /// </param> /// <returns></returns> /// <remarks> /// The stack chain represents the physical call stack for /// the thread. The following circumstances create a stack /// chain boundary: /// /// - A managed-to-unmanaged or unmanaged-to-managed transition. /// - A context switch. /// - A debugger hijacking of a user thread. /// /// In the simple case for a thread that is running purely /// managed code in a single context, a one-to-one correspondence /// will exist between threads and stack chains. /// /// A debugger may want to rearrange the physical call stacks of /// all threads into logical call stacks. This would involve sorting /// all the threads' chains by their caller/callee relationships and /// regrouping them. /// </remarks> public int EnumerateChains(out CorDebugComEnum <CorDebugChain> chains) => InvokeGetObject(_this, This[0]->EnumerateChains, out chains);
/// <summary> /// Gets all active steppers in the application domain. /// </summary> public int EnumerateSteppers(out CorDebugComEnum <CorDebugStepper> steppers) => InvokeGetObject(_this, This[0]->EnumerateSteppers, out steppers);
/// <summary> /// Gets all active breakpoints in the application domain. /// </summary> public int EnumerateBreakpoints(out CorDebugComEnum <CorDebugBreakpoint> breakpoints) => InvokeGetObject(_this, This[0]->EnumerateBreakpoints, out breakpoints);
/// <summary> /// Gets all of the assemblies in the application domain. /// </summary> public int EnumerateAssemblies(out CorDebugComEnum <CorDebugAssembly> assemblies) => InvokeGetObject(_this, This[0]->EnumerateAssemblies, out assemblies);
/// <summary> /// Provides an ordered list of threads that are queued on the event /// that is associated with a monitor lock. /// </summary> /// <param name="threadEnum"> /// The <c>ICorDebugThreadEnum</c> enumerator that provides the ordered /// list of threads. /// </param> /// <returns> /// This method returns the following specific HRESULTs as well as /// HRESULT errors that indicate method failure. /// /// - <c>S_OK</c>: The list is not empty. /// /// - <c>S_FALSE</c>: The list is empty. /// </returns> /// <remarks> /// The first thread in the list is the first thread that is released by the /// next call to <c>System.Threading.Monitor.Pulse(System.Object)</c>. The /// next thread in the list is released on the following call, and so on. /// /// If the list is not empty, this method returns <c>S_OK</c>. If the list is /// empty, the method returns <c>S_FALSE</c>; in this case, the enumeration is /// still valid, although it is empty. /// /// In either case, the enumeration interface is usable only for the duration /// of the current synchronized state. However, the thread's interfaces /// dispensed from it are valid until the thread exits. /// /// If <see paramref="ppThreadEnum" /> is not a valid pointer, the result is /// undefined. /// /// If an error occurs such that it cannot be determined which, if any, threads /// are waiting for the monitor, the method returns an HRESULT that indicates /// failure. /// </remarks> public int GetMonitorEventWaitList(out CorDebugComEnum <CorDebugThread> threadEnum) => InvokeGetObject(_this, This[0]->GetMonitorEventWaitList, out threadEnum);
/// <summary> /// Enumerates all the application domains in this process. /// </summary> /// <remarks> /// This method can be used before the <c>ICorDebugManagedCallback::CreateProcess</c> /// callback. /// </remarks> public int EnumerateAppDomains(out CorDebugComEnum <CorDebugAppDomain> appDomains) => InvokeGetObject(_this, This[0]->EnumerateAppDomains, out appDomains);
/// <summary> /// Gets the Type parameters of the class referenced by this type. /// </summary> /// <remarks> /// You can use this method if the <see cref="GetType(out CorElementType)" /> is /// any of the following: /// /// - <see cref="CorElementType.ELEMENT_TYPE_CLASS" /> /// - <see cref="CorElementType.ELEMENT_TYPE_VALUETYPE" /> /// - <see cref="CorElementType.ELEMENT_TYPE_ARRAY" /> /// - <see cref="CorElementType.ELEMENT_TYPE_SZARRAY" /> /// - <see cref="CorElementType.ELEMENT_TYPE_BYREF" /> /// - <see cref="CorElementType.ELEMENT_TYPE_PTR" /> /// - <see cref="CorElementType.ELEMENT_TYPE_FNPTR" /> /// /// The number of parameters and their order depends on the type: /// /// - <see cref="CorElementType.ELEMENT_TYPE_CLASS" /> or <see cref="CorElementType.ELEMENT_TYPE_VALUETYPE" />: /// The number of type parameters contained will depend on the number /// of formal type parameters for the corresponding class. For example, /// if the type is class Dict{String,int32}, then EnumerateTypeParameters /// will return an enumerable that contains objects representing String and /// int32 in sequence. /// /// - <see cref="CorElementType.ELEMENT_TYPE_FNPTR" />: The number of /// type parameters contained will be one greater than the number of arguments /// accepted by the function. The first type parameter contained in the enumerable /// is the return type for the function, and the subsequent type parameters are /// the function's parameters. /// /// - <see cref="CorElementType.ELEMENT_TYPE_ARRAY" />, /// <see cref="CorElementType.ELEMENT_TYPE_SZARRAY" />, /// <see cref="CorElementType.ELEMENT_TYPE_BYREFARRAY" />, /// <see cref="CorElementType.ELEMENT_TYPE_PTR" />: One type parameter will be /// returned. For example, if the type is an array type such as int32[], /// then this method will return an enumerable that contains an object /// representing int32. /// </remarks> public int EnumerateTypeParameters(out CorDebugComEnum <CorDebugType> tyParEnum) => InvokeGetObject(_this, This[0]->EnumerateTypeParameters, out tyParEnum);