GCHandle

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\CharacterBuffer.cs (1)

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\GCHandle.cs (3)

65public static GCHandle Alloc(object? value) => new GCHandle(value, GCHandleType.Normal); 72public static GCHandle Alloc(object? value, GCHandleType type) => new GCHandle(value, type); 161return new GCHandle(value);

Processes\DetachedProcessLauncher.Windows.cs (2)

61var pinnedHandles = GCHandle.Alloc(handles, GCHandleType.Pinned);

RequestProcessing\ResponseBody.cs (7)

144Span<GCHandle> pinnedBuffers = default; 183private unsafe void BuildDataChunks(scoped ref UnmanagedBufferAllocator allocator, bool endOfRequest, ArraySegment<byte> data, out Span<HTTP_DATA_CHUNK> dataChunks, out Span<GCHandle> pins) 228pins = allocator.AllocAsSpan<GCHandle>(2); 272out GCHandle handle) 274handle = GCHandle.Alloc(buffer.Array, GCHandleType.Pinned); 292private static void FreeDataBuffers(Span<GCHandle> pinnedBuffers) 294foreach (var pin in pinnedBuffers)

Core\IISHttpContext.cs (2)

59private GCHandle _thisHandle = default!; 156_thisHandle = GCHandle.Alloc(this);

Core\IISHttpServer.cs (7)

26private GCHandle _httpServerHandle; 98_httpServerHandle = GCHandle.Alloc(this); 157server = (IISHttpServer?)GCHandle.FromIntPtr(pvRequestContext).Target; 188server = (IISHttpServer?)GCHandle.FromIntPtr(pvRequestContext).Target; 212context = (IISHttpContext?)GCHandle.FromIntPtr(pvManagedHttpContext).Target; 234context = (IISHttpContext?)GCHandle.FromIntPtr(pvManagedHttpContext).Target; 259server = (IISHttpServer?)GCHandle.FromIntPtr(serverContext).Target;

Core\IO\WebSocketsAsyncIOEngine.Read.cs (3)

17var context = (WebSocketReadOperation)GCHandle.FromIntPtr(completionContext).Target!; 29private readonly GCHandle _thisHandle; 36_thisHandle = GCHandle.Alloc(this);

Core\IO\WebSocketsAsyncIOEngine.Write.cs (3)

16var context = (WebSocketWriteOperation)GCHandle.FromIntPtr(completionContext).Target!; 27private readonly GCHandle _thisHandle; 31_thisHandle = GCHandle.Alloc(this);

Utilities\TypeInfo.cs (2)

54GCHandle handle = GCHandle.Alloc(default(T), GCHandleType.Pinned);

CodeGeneration\SyntaxGeneratorTests.cs (1)

1070var gcHandleType = _emptyCompilation.GetTypeByMetadataName(typeof(GCHandle).FullName);

BlindAggregatorFactory.cs (1)

70GCHandle.FromIntPtr(_gcHandle).Free();

WrappedLightGbmDataset.cs (6)

52GCHandle[] gcValues = new GCHandle[numCol]; 53GCHandle[] gcIndices = new GCHandle[numCol]; 60gcValues[i] = GCHandle.Alloc(sampleValuePerColumn[i], GCHandleType.Pinned); 62gcIndices[i] = GCHandle.Alloc(sampleIndicesPerColumn[i], GCHandleType.Pinned);

SymSgdClassificationTrainer.cs (12)

341public GCHandle GcHandle; 346GcHandle = GCHandle.Alloc(Buffer, GCHandleType.Pinned); 487public void GiveArrayOfSize(int size, out GCHandle? outGcHandle, out int outArrayStartIndex) 663public bool GiveNextInstance(out InstanceProperties? prop, out GCHandle? indicesGcHandle, out int indicesStartIndex, 664out GCHandle? valuesGcHandle, out int valuesStartIndex) 736GCHandle stateGCHandle = default; 739stateGCHandle = GCHandle.Alloc(state, GCHandleType.Pinned); 863int numThreads, bool tuneNumLocIter, ref int numLocIter, float tolerance, bool needShuffle, bool shouldInitialize, GCHandle stateGCHandle, ChannelCallBack info) 878while (inputDataManager.GiveNextInstance(out InstanceProperties? prop, out GCHandle? indicesGcHandle, out int indicesStartIndex, out GCHandle? valuesGcHandle, out int valuesStartIndex)) 917public static void MapBackWeightVector(Span<float> weightVector, GCHandle stateGCHandle) 926public static void DeallocateSequentially(GCHandle stateGCHandle)

ImageClassificationTrainer.cs (4)

975var featureBufferHandle = GCHandle.Alloc(featuresBuffer, GCHandleType.Pinned); 977var labelBufferHandle = GCHandle.Alloc(labelBuffer, GCHandleType.Pinned);

WeakStringCache.cs (2)

36private GCHandle weakHandle; 80weakHandle = GCHandle.Alloc(str, GCHandleType.Weak);

WeakStringCache.cs (2)

36private GCHandle weakHandle; 80weakHandle = GCHandle.Alloc(str, GCHandleType.Weak);

Windows\Win32\PInvokeCore.EnumChildWindows.cs (3)

23GCHandle gcHandle = GCHandle.Alloc(callback); 44return ((EnumChildWindowsCallback)((GCHandle)(nint)lParam).Target!)(hWnd);

Windows\Win32\PInvokeCore.EnumDisplayMonitors.cs (3)

19GCHandle gcHandle = GCHandle.Alloc(callBack); 39return ((EnumDisplayMonitorsCallback)((GCHandle)(nint)lParam).Target!)(monitor, hdc);

Windows\Win32\PInvokeCore.EnumThreadWindows.cs (3)

25GCHandle gcHandle = GCHandle.Alloc(callback); 48return ((EnumThreadWindowsCallback)((GCHandle)(nint)lParam).Target!)(hWnd);

Windows\Win32\PInvokeCore.EnumWindows.cs (3)

22GCHandle gcHandle = GCHandle.Alloc(callback); 42return ((EnumWindowsCallback)((GCHandle)(nint)lParam).Target!)(hWnd);

Windows\Win32\System\Com\Lifetime.cs (5)

31GCHandle.FromIntPtr((nint)lifetime->_handle).Free(); 44/// This creates a <see cref="GCHandle"/> to root the <paramref name="object"/> until ref 58wrapper->_handle = (void*)GCHandle.ToIntPtr(GCHandle.Alloc(@object)); 75return (TObject?)GCHandle.FromIntPtr((IntPtr)lifetime->_handle).Target;

Interop\ComAggregate.cs (4)

58var handle = GCHandle.FromIntPtr(comWrapper.GCHandlePtr); 83var handle = GCHandle.FromIntPtr(comWrapper.GCHandlePtr);

Interop\IComWrapperFixed.cs (1)

20/// <returns>An <see cref="IntPtr"/> which can be passed to <see cref="GCHandle.FromIntPtr(IntPtr)"/> to obtain

src\libraries\shims\mscorlib\ref\mscorlib.cs (1)

691[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Runtime.InteropServices.GCHandle))]

netstandard.cs (1)

1696[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Runtime.InteropServices.GCHandle))]

MS\Internal\FontCache\FontSource.cs (2)

397_memoryHandle = GCHandle.Alloc(bits, GCHandleType.Pinned); 423private GCHandle _memoryHandle;

MS\Internal\Shaping\TypefaceMap.cs (1)

91GCHandle gcHandle;

src\Microsoft.DotNet.Wpf\src\Shared\MS\Internal\CharacterBuffer.cs (10)

System\Windows\Media\EventProxy.cs (5)

31((System.Runtime.InteropServices.GCHandle)(pEPD.m_handle)).Free(); 34internal System.Runtime.InteropServices.GCHandle m_handle; 105System.Runtime.InteropServices.GCHandle handle = (System.Runtime.InteropServices.GCHandle)(epd.m_handle); 138m_handle = System.Runtime.InteropServices.GCHandle.Alloc(epw, System.Runtime.InteropServices.GCHandleType.Normal)

System\Windows\Media\StreamAsIStream.cs (5)

55((System.Runtime.InteropServices.GCHandle)(pSD.m_handle)).Free(); 58internal System.Runtime.InteropServices.GCHandle m_handle; 510System.Runtime.InteropServices.GCHandle handle = (System.Runtime.InteropServices.GCHandle)(sd.m_handle); 657sd.m_handle = System.Runtime.InteropServices.GCHandle.Alloc(sais, System.Runtime.InteropServices.GCHandleType.Normal);

MS\Internal\WindowsRuntime\Generated\WinRT\Marshalers.cs (5)

16public static void Dispose(this GCHandle handle) 35public GCHandle _gchandle; 51m._gchandle = GCHandle.Alloc(value, GCHandleType.Pinned); 276public MarshalerArray(Array array) => _gchandle = GCHandle.Alloc(array, GCHandleType.Pinned); 279public GCHandle _gchandle;

System\Windows\Documents\WinEventHandler.cs (2)

33_gchThis = GCHandle.Alloc(_winEventProc); 162private GCHandle _gchThis;

System\Windows\Standard\MessageWindow.cs (5)

56GCHandle gcHandle = default(GCHandle); 59gcHandle = GCHandle.Alloc(this); 149GCHandle gcHandle = GCHandle.FromIntPtr(createStruct.lpCreateParams);

Shared\DummyMetadataImport.cs (4)

22private readonly List<GCHandle> _pinnedBuffers; 41foreach (var pinnedBuffer in _pinnedBuffers) 66GCHandle pinnedBuffer = GCHandle.Alloc(signature, GCHandleType.Pinned);

System\Drawing\Font.cs (2)

293GCHandle handle = GCHandle.Alloc(logFont, GCHandleType.Pinned);

System\Net\Quic\Internal\MsQuicSafeHandle.cs (2)

91private GCHandle _context; 112public unsafe MsQuicContextSafeHandle(QUIC_HANDLE* handle, GCHandle context, SafeHandleType safeHandleType, MsQuicSafeHandle? parent = null)

System\Net\Quic\Internal\ResettableValueTaskSource.cs (5)

34private GCHandle _keepAlive; 102_keepAlive = GCHandle.Alloc(keepAlive); 324GCHandle handle = GCHandle.Alloc(keepAlive); 327((GCHandle)state!).Free();

System\Net\Quic\Internal\ValueTaskSource.cs (2)

28private GCHandle _keepAlive; 85_keepAlive = GCHandle.Alloc(keepAlive);

System\Net\Quic\QuicConnection.cs (10)

319GCHandle context = GCHandle.Alloc(this, GCHandleType.Weak); 326(void*)GCHandle.ToIntPtr(context), 353GCHandle context = GCHandle.Alloc(this, GCHandleType.Weak); 361(void*)GCHandle.ToIntPtr(context)); 572GCHandle keepObject = GCHandle.Alloc(this); 784GCHandle stateHandle = GCHandle.FromIntPtr((IntPtr)context);

System\Net\Quic\QuicListener.cs (7)

123GCHandle context = GCHandle.Alloc(this, GCHandleType.Weak); 130(void*)GCHandle.ToIntPtr(context), 182GCHandle keepObject = GCHandle.Alloc(this); 373GCHandle stateHandle = GCHandle.FromIntPtr((IntPtr)context);

System\Net\Quic\QuicStream.cs (8)

198GCHandle context = GCHandle.Alloc(this, GCHandleType.Weak); 206(void*)GCHandle.ToIntPtr(context), 240GCHandle context = GCHandle.Alloc(this, GCHandleType.Weak); 251(void*)GCHandle.ToIntPtr(context)); 708GCHandle stateHandle = GCHandle.FromIntPtr((IntPtr)context);

System\Net\TimerThread.cs (2)

207_thisHandle = (IntPtr)GCHandle.Alloc(this); 247((GCHandle)_thisHandle).Free();

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.OpenSsl.cs (4)

1106GCHandle gch = GCHandle.FromIntPtr(ptr); 1138GCHandle gch = GCHandle.FromIntPtr(ptr);

src\libraries\Common\src\Interop\Unix\System.Security.Cryptography.Native\Interop.SslCtx.cs (2)

84private GCHandle _gch; 172_gch = GCHandle.Alloc(this);

System\Net\Sockets\SocketPal.Unix.cs (12)

299Span<GCHandle> handles = allocOnStack ? stackalloc GCHandle[IovStackThreshold] : new GCHandle[maxBuffers]; 311handles[i] = GCHandle.Alloc(buffer.Array, GCHandleType.Pinned); 411Span<GCHandle> handles = allocOnStack ? stackalloc GCHandle[IovStackThreshold] : new GCHandle[maxBuffers]; 425handles[i] = GCHandle.Alloc(buffer.Array, GCHandleType.Pinned); 553Span<GCHandle> handles = allocOnStack ? stackalloc GCHandle[IovStackThreshold] : new GCHandle[buffersCount]; 564handles[i] = GCHandle.Alloc(buffer.Array, GCHandleType.Pinned);

System\Numerics\Tensors\netcore\Tensor_1.cs (2)

210GCHandle handle = GCHandle.Alloc(_values, GCHandleType.Pinned);

src\libraries\System.Private.CoreLib\src\System\Buffers\MemoryHandle.cs (2)

14private GCHandle _handle; 24public MemoryHandle(void* pointer, GCHandle handle = default, IPinnable? pinnable = default)

src\libraries\System.Private.CoreLib\src\System\ComAwareWeakReference.cs (11)

86GCHandle.InternalFree(_weakHandle); 98GCHandle.InternalSet(_weakHandle, target); 103internal object? Target => GCHandle.InternalGet(_weakHandle); 115target = Unsafe.As<T>(GCHandle.InternalGet(_weakHandle)); 122GCHandle.InternalSet(_weakHandle, target); 136nint newHandle = GCHandle.InternalAlloc(newRef, GCHandleType.Normal); 145GCHandle.InternalFree(newHandle); 149return Unsafe.As<ComAwareWeakReference>(GCHandle.InternalGet(taggedHandle & ~HandleTagBits)!); 156return Unsafe.As<ComAwareWeakReference>(GCHandle.InternalGet(taggedHandle & ~HandleTagBits)!); 164Unsafe.As<ComAwareWeakReference>(GCHandle.InternalGet(taggedHandle & ~HandleTagBits)!); 174nint newHandle = GCHandle.InternalAlloc(comAwareRef, GCHandleType.Normal);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventProvider.cs (3)

617GCHandle[] rgGCHandle = new GCHandle[refObjIndex]; 622rgGCHandle[i] = GCHandle.Alloc(dataRefObj[i], GCHandleType.Pinned);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\TraceLogging\DataCollector.cs (5)

27private GCHandle* pinsEnd; 31private GCHandle* pins; 42GCHandle* pins, 312GCHandle* pinsTemp = this.pins; 327*pinsTemp = GCHandle.Alloc(value, GCHandleType.Pinned);

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\TraceLogging\TraceLoggingEventSource.cs (5)

431GCHandle* pins = stackalloc GCHandle[pinCount]; 609GCHandle* pins = stackalloc GCHandle[pinCount]; 720private static unsafe void WriteCleanup(GCHandle* pPins, int cPins)

src\libraries\System.Private.CoreLib\src\System\IO\PinnedBufferMemoryStream.cs (2)

15private GCHandle _pinningHandle; 22_pinningHandle = GCHandle.Alloc(array, GCHandleType.Pinned);

src\libraries\System.Private.CoreLib\src\System\Memory.cs (4)

401GCHandle handle = GCHandle.Alloc(tmpObject, GCHandleType.Pinned); 420GCHandle handle = GCHandle.Alloc(tmpObject, GCHandleType.Pinned);

src\libraries\System.Private.CoreLib\src\System\ReadOnlyMemory.cs (4)

316GCHandle handle = GCHandle.Alloc(tmpObject, GCHandleType.Pinned); 335GCHandle handle = GCHandle.Alloc(tmpObject, GCHandleType.Pinned);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\ComWrappers.cs (26)

229return Unsafe.As<ManagedObjectWrapperHolder>(GCHandle.FromIntPtr(handle).Target); 380GCHandle.InternalFree(handle); 520if (refCountedHandle != IntPtr.Zero && GCHandle.InternalGet(refCountedHandle) != null) 550private GCHandle _proxyHandle; 551private GCHandle _proxyHandleTrackingResurrection; 596_proxyHandle = GCHandle.Alloc(comProxy, GCHandleType.Weak); 603_proxyHandleTrackingResurrection = GCHandle.Alloc(comProxy, GCHandleType.WeakTrackResurrection); 619internal GCHandle ProxyHandle => _proxyHandle; 672internal readonly GCHandle _nativeObjectWrapperWeakHandle; 704_nativeObjectWrapperWeakHandle = GCHandle.Alloc(this, GCHandleType.Weak); 1302private readonly Dictionary<IntPtr, GCHandle> _cache = []; 1317ref GCHandle rcwEntry = ref CollectionsMarshal.GetValueRefOrAddDefault(_cache, comPointer, out bool exists); 1322rcwEntry = GCHandle.Alloc(wrapper, GCHandleType.Weak); 1360if (!_cache.TryGetValue(comPointer, out GCHandle existingHandle)) 1385if (_cache.TryGetValue(comPointer, out GCHandle existingHandle) 1440if (_cache.TryGetValue(comPointer, out GCHandle cachedRef) 1679internal sealed class GCHandleSet : IEnumerable<GCHandle> 1689public void Add(GCHandle handle) 1763public void Remove(GCHandle handle) 1792private static int GetBucket(GCHandle handle, int numBuckets) 1800IEnumerator<GCHandle> IEnumerable<GCHandle>.GetEnumerator() => GetEnumerator(); 1802IEnumerator IEnumerable.GetEnumerator() => ((IEnumerable<GCHandle>)this).GetEnumerator(); 1807public GCHandle _value; 1810public struct Enumerator : IEnumerator<GCHandle> 1825public GCHandle Current

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\GCHandle.cs (13)

28public partial struct GCHandle : IEquatable<GCHandle> 65public static GCHandle Alloc(object? value) => new GCHandle(value, GCHandleType.Normal); 72public static GCHandle Alloc(object? value, GCHandleType type) => new GCHandle(value, type); 156public static explicit operator GCHandle(IntPtr value) => FromIntPtr(value); 158public static GCHandle FromIntPtr(IntPtr value) 165public static explicit operator IntPtr(GCHandle value) => ToIntPtr(value); 167public static IntPtr ToIntPtr(GCHandle value) => value._handle; 171public override readonly bool Equals([NotNullWhen(true)] object? o) => o is GCHandle other && Equals(other); 176public readonly bool Equals(GCHandle other) => _handle == other._handle; 178public static bool operator ==(GCHandle a, GCHandle b) => a._handle == b._handle; 180public static bool operator !=(GCHandle a, GCHandle b) => a._handle != b._handle;

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\GCHandle.T.cs (9)

21/// <seealso cref="GCHandle" /> 35_handle = GCHandle.InternalAlloc(target, GCHandleType.Normal); 50GCHandle.CheckUninitialized(handle); 52return Unsafe.As<T>(GCHandle.InternalGet(handle)!); 57GCHandle.CheckUninitialized(handle); 58GCHandle.InternalSet(handle, value); 71/// interchangable with <see cref="GCHandle"/>. 83/// interchangable with <see cref="GCHandle"/>. 97GCHandle.InternalFree(handle);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\ObjectiveC\ObjectiveCMarshal.PlatformNotSupported.cs (2)

90/// The caller is responsible for freeing the returned <see cref="GCHandle"/>. 92public static GCHandle CreateReferenceTrackingHandle(

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\PinnedGCHandle.T.cs (9)

22/// <seealso cref="GCHandle" /> 37_handle = GCHandle.InternalAlloc(target, GCHandleType.Pinned); 52GCHandle.CheckUninitialized(handle); 54return Unsafe.As<T>(GCHandle.InternalGet(handle)!); 59GCHandle.CheckUninitialized(handle); 61GCHandle.InternalSet(handle, value); 105/// interchangable with <see cref="GCHandle"/>. 117/// interchangable with <see cref="GCHandle"/>. 131GCHandle.InternalFree(handle);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\TrackerObjectManager.cs (1)

74foreach (GCHandle weakNativeObjectWrapperHandle in s_referenceTrackerNativeObjectWrapperCache)

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\WeakGCHandle.T.cs (9)

21/// <seealso cref="GCHandle" /> 36_handle = GCHandle.InternalAlloc(target, trackResurrection ? GCHandleType.WeakTrackResurrection : GCHandleType.Weak); 54GCHandle.CheckUninitialized(handle); 56T? obj = Unsafe.As<T>(GCHandle.InternalGet(handle)); 67GCHandle.CheckUninitialized(handle); 68GCHandle.InternalSet(handle, target); 80/// interchangable with <see cref="GCHandle"/>. 92/// interchangable with <see cref="GCHandle"/>. 106GCHandle.InternalFree(handle);

src\libraries\System.Private.CoreLib\src\System\Runtime\Loader\AssemblyLoadContext.cs (7)

102var thisHandle = GCHandle.Alloc(this, IsCollectible ? GCHandleType.WeakTrackResurrection : GCHandleType.Normal); 103var thisHandlePtr = GCHandle.ToIntPtr(thisHandle); 148var thisStrongHandle = GCHandle.Alloc(this, GCHandleType.Normal); 149var thisStrongHandlePtr = GCHandle.ToIntPtr(thisStrongHandle); 610AssemblyLoadContext context = (AssemblyLoadContext)(GCHandle.FromIntPtr(gchAssemblyLoadContext).Target)!;

src\libraries\System.Private.CoreLib\src\System\Threading\Overlapped.cs (6)

151(nuint)(sizeof(NativeOverlapped) + sizeof(nuint)) + handleCount * (nuint)sizeof(GCHandle)); 161GCHandleRef(pNativeOverlapped, 0) = GCHandle.Alloc(this); 171GCHandleRef(pNativeOverlapped, (nuint)(i + 1)) = GCHandle.Alloc(objArray[i], GCHandleType.Pinned); 177GCHandleRef(pNativeOverlapped, 1) = GCHandle.Alloc(userData, GCHandleType.Pinned); 222private static ref GCHandle GCHandleRef(NativeOverlapped* pNativeOverlapped, nuint index) 223=> ref *((GCHandle*)((nuint*)(pNativeOverlapped + 1) + 1) + index);

src\libraries\System.Private.CoreLib\src\System\Threading\WaitSubsystem.HandleManager.Unix.cs (4)

49IntPtr handle = GCHandle.ToIntPtr(GCHandle.Alloc(waitableObject, GCHandleType.Normal)); 66return (IWaitableObject)GCHandle.FromIntPtr(handle).Target!; 82GCHandle.FromIntPtr(handle).Free();

src\libraries\System.Private.CoreLib\src\System\Threading\WaitSubsystem.Unix.cs (1)

105/// - <see cref="HandleManager"/> currently uses <see cref="Runtime.InteropServices.GCHandle"/> in the interest of

src\libraries\System.Private.CoreLib\src\System\WeakReference.cs (5)

83nint h = GCHandle.InternalAlloc(target, trackResurrection ? GCHandleType.WeakTrackResurrection : GCHandleType.Weak); 130bool result = GCHandle.InternalGetBridgeWait(wh) != null; 181target = GCHandle.InternalGetBridgeWait(th); 216GCHandle.InternalSet(th, value); 238GCHandle.InternalFree(handle);

src\libraries\System.Private.CoreLib\src\System\WeakReference.T.cs (3)

83nint h = GCHandle.InternalAlloc(target, trackResurrection ? GCHandleType.WeakTrackResurrection : GCHandleType.Weak); 120GCHandle.InternalSet(th, target); 157target = Unsafe.As<T>(GCHandle.InternalGetBridgeWait(th));

src\System\GC.CoreCLR.cs (1)

299object? obj = GCHandle.InternalGet(wo.WeakHandle);

src\System\MulticastDelegate.CoreCLR.cs (3)

602this._methodBase = GCHandle.InternalGet(gchandle); 612this._methodBase = GCHandle.InternalGet(gchandle); 621this._methodBase = GCHandle.InternalGet(gchandle);

src\System\Runtime\CompilerServices\AsyncHelpers.CoreCLR.cs (1)

327Unsafe.As<byte, object?>(ref Unsafe.Add(ref RuntimeHelpers.GetRawData(newContinuation), keepAliveOffset)) = GCHandle.FromIntPtr(loaderAllocatorHandle).Target;

src\System\Runtime\CompilerServices\StaticsHelpers.cs (1)

206object? threadStaticObject = GCHandle.InternalGet(objHandle);

src\System\Runtime\InteropServices\GCHandle.CoreCLR.cs (1)

49if (GCHandle.InternalTryGetBridgeWait(handle, ref target))

src\System\Runtime\InteropServices\Java\JavaMarshal.CoreCLR.cs (10)

59/// with the handle and can be retrieved by the runtime via <see cref="GetContext(GCHandle)"/>. 62/// <returns>A <see cref="GCHandle"/> that represents the allocated reference-tracking handle.</returns> 65public static unsafe GCHandle CreateReferenceTrackingHandle(object obj, void* context) 70return GCHandle.FromIntPtr(handle); 77/// <param name="obj">The <see cref="GCHandle"/> whose context should be returned.</param> 85public static unsafe void* GetContext(GCHandle obj) 87IntPtr handle = GCHandle.ToIntPtr(obj); 104/// <param name="unreachableObjectHandles">A span of <see cref="GCHandle"/> values that were determined to be unreachable from the native side.</param> 108ReadOnlySpan<GCHandle> unreachableObjectHandles) 110fixed (GCHandle* pHandles = unreachableObjectHandles)

src\System\Runtime\Loader\AssemblyLoadContext.CoreCLR.cs (3)

118AssemblyLoadContext context = (AssemblyLoadContext)(GCHandle.FromIntPtr(gchAssemblyLoadContext).Target)!; 135AssemblyLoadContext context = (AssemblyLoadContext)(GCHandle.FromIntPtr(gchAssemblyLoadContext).Target)!; 169loadContextForAssembly = (AssemblyLoadContext)(GCHandle.FromIntPtr(ptrAssemblyLoadContext).Target)!;

src\System\RuntimeType.CoreCLR.cs (5)

2449object? cache = GCHandle.InternalGet(m_cache); 2464object? cache = GCHandle.InternalGet(m_cache); 2487RuntimeTypeCache? cache = (RuntimeTypeCache?)GCHandle.InternalGet(m_cache); 2491RuntimeTypeCache? existingCache = (RuntimeTypeCache?)GCHandle.InternalCompareExchange(m_cache, cache, null); 2509GCHandle.InternalSet(m_cache, null);

Windows\Win32\PInvokeCore.EnumChildWindows.cs (3)

23GCHandle gcHandle = GCHandle.Alloc(callback); 44return ((EnumChildWindowsCallback)((GCHandle)(nint)lParam).Target!)(hWnd);

Windows\Win32\PInvokeCore.EnumDisplayMonitors.cs (3)

19GCHandle gcHandle = GCHandle.Alloc(callBack); 39return ((EnumDisplayMonitorsCallback)((GCHandle)(nint)lParam).Target!)(monitor, hdc);

Windows\Win32\PInvokeCore.EnumThreadWindows.cs (3)

25GCHandle gcHandle = GCHandle.Alloc(callback); 48return ((EnumThreadWindowsCallback)((GCHandle)(nint)lParam).Target!)(hWnd);

Windows\Win32\PInvokeCore.EnumWindows.cs (3)

22GCHandle gcHandle = GCHandle.Alloc(callback); 42return ((EnumWindowsCallback)((GCHandle)(nint)lParam).Target!)(hWnd);

Windows\Win32\System\Com\Lifetime.cs (5)

31GCHandle.FromIntPtr((nint)lifetime->_handle).Free(); 44/// This creates a <see cref="GCHandle"/> to root the <paramref name="object"/> until ref 58wrapper->_handle = (void*)GCHandle.ToIntPtr(GCHandle.Alloc(@object)); 75return (TObject?)GCHandle.FromIntPtr((IntPtr)lifetime->_handle).Target;

Windows\Win32\System\Variant\VARIANT.cs (2)

272GCHandle pin = default; 276pin = GCHandle.Alloc(array, GCHandleType.Pinned);

System\Reflection\Internal\Utilities\PinnedObject.cs (2)

13private GCHandle _handle; 28_handle = GCHandle.Alloc(obj, GCHandleType.Pinned);

System\Reflection\Metadata\Internal\VirtualHeap.cs (3)

24public GCHandle Handle; 28public PinnedBlob(GCHandle handle, int length) 103var blob = new PinnedBlob(GCHandle.Alloc(value, GCHandleType.Pinned), value.Length);

src\libraries\System.Private.CoreLib\src\System\IO\PinnedBufferMemoryStream.cs (2)

15private GCHandle _pinningHandle; 22_pinningHandle = GCHandle.Alloc(array, GCHandleType.Pinned);

artifacts\obj\System.Runtime\Debug\net11.0\System.Runtime.Forwards.cs (1)

679[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Runtime.InteropServices.GCHandle))]

System\Runtime\Caching\SRef.cs (2)

31private GCHandle _handle; 36_handle = GCHandle.Alloc(t);

artifacts\obj\System.Runtime.InteropServices\Debug\net11.0\System.Runtime.InteropServices.Forwards.cs (1)

91[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Runtime.InteropServices.GCHandle))]

System\Security\Cryptography\CryptoStream.cs (2)

724GCHandle pinHandle = GCHandle.Alloc(rentedBuffer, GCHandleType.Pinned);

System\Windows\Forms\Control.ControlNativeWindow.cs (2)

13private GCHandle _rootRef; // We will root the control when we do not want to be eligible for garbage collection. 43_rootRef = GCHandle.Alloc(GetControl(), GCHandleType.Normal);

System\Windows\Forms\Dialogs\CommonDialogs\FolderBrowserDialog.cs (4)

453GCHandle handle = GCHandle.Alloc(this); 463GCHandle.ToIntPtr(handle)); 494var instance = (FolderBrowserDialog)GCHandle.FromIntPtr(lpData).Target!;

System\Windows\Forms\Dialogs\TaskDialog\TaskDialog.cs (4)

81/// The <see cref="IntPtr"/> of a <see cref="GCHandle"/> that represents this 276(((GCHandle)lpRefData).Target as TaskDialog)!.HandleTaskDialogCallback( 559var instanceHandle = GCHandle.Alloc(this);

System\Windows\Forms\NativeWindow.cs (8)

38private static readonly Dictionary<HWND, GCHandle> s_windowHandles = []; 245GCHandle root = GCHandle.Alloc(window, GCHandleType.Weak); 247if (s_windowHandles.TryGetValue(handle, out GCHandle oldRoot)) 561s_windowHandles.TryGetValue(handle, out GCHandle value) && value.IsAllocated 613foreach ((HWND handle, GCHandle gcHandle) in s_windowHandles) 708if (!s_windowHandles.TryGetValue(hwnd, out GCHandle root)) 735s_windowHandles[hwnd] = GCHandle.Alloc(window.PreviousWindow, GCHandleType.Weak);

System\Windows\Forms\NotifyIcon.NotifyIconNativeWindow.cs (2)

16private GCHandle _rootRef; // We will root the control when we do not want to be eligible for garbage collection. 43_rootRef = GCHandle.Alloc(_reference, GCHandleType.Normal);

System\Windows\Forms\Timer.cs (2)

25private GCHandle _timerRoot; 114_timerRoot = GCHandle.Alloc(this);

Windows\Win32\PInvoke.SendMessageCallback.cs (4)

19GCHandle gcHandle = GCHandle.Alloc(callback); 28GCHandle gcHandle = (GCHandle)(nint)dwData;

Metafiles\EmfScope.cs (4)

79GCHandle enumeratorHandle = GCHandle.Alloc(enumerator); 241GCHandle enumeratorHandle = GCHandle.FromIntPtr(data);

PropertyGridInternal\SubPropertyGrid.cs (4)

48var callbackHandle = GCHandle.Alloc(() => 66PInvokeCore.PostMessage(this, WM_DELAYEDEXECUTION, lParam: GCHandle.ToIntPtr(callbackHandle)); 102((Action)GCHandle.FromIntPtr(m.LParamInternal).Target!)();

HttpSys\HttpSysConfigurator.cs (6)

29var sockAddrHandle = CreateSockaddrStructure(ipPort); 34var handleHash = GCHandle.Alloc(hash, GCHandleType.Pinned); 86static GCHandle CreateSockaddrStructure(IPEndPoint ipEndPoint) 92var sockAddrHandle = GCHandle.Alloc(sockAddrStructureBytes, GCHandleType.Pinned);

MS\Internal\Automation\EventListenerClientSide.cs (2)

32_gch = GCHandle.Alloc(_callbackDelegate); 294private GCHandle _gch; // GCHandle to keep GCs from moving the callback

MS\Internal\Automation\HwndProxyElementProvider.cs (2)

1576GCHandle gch = GCHandle.Alloc(enumWindows);

MS\Internal\Automation\UiaCoreApi.cs (2)

1555private static GCHandle _gchandle; 1560_gchandle = GCHandle.Alloc(onGetProviderDelegate);

MS\Internal\Automation\WinEventWrap.cs (2)

240_gchThis = GCHandle.Alloc(_winEventProc); 280private GCHandle _gchThis; // GCHandle to keep GCs from moving this callback

MS\Internal\AutomationProxies\Misc.cs (2)

349GCHandle gch = GCHandle.Alloc(enumToolTipWindows);

MS\Internal\AutomationProxies\MSAAWinEventWrap.cs (2)

171_gchThis = GCHandle.Alloc(_winEventProc); 221private GCHandle _gchThis; // GCHandle to keep GCs from moving this callback

MS\Internal\AutomationProxies\WinEventTracker.cs (2)

124internal GCHandle _procHookHandle; 173hp._procHookHandle = GCHandle.Alloc (proc);