public unsafe NativeOverlapped *AllocateNativeOverlapped(PreAllocatedOverlapped preAllocated) { if (preAllocated == null) { throw new ArgumentNullException(nameof(preAllocated)); } EnsureNotDisposed(); preAllocated.AddRef(); try { ThreadPoolBoundHandleOverlapped overlapped = preAllocated._overlapped; if (overlapped._boundHandle != null) { throw new ArgumentException(Environment.GetResourceString("Argument_PreAllocatedAlreadyAllocated"), nameof(preAllocated)); } overlapped._boundHandle = this; return(overlapped._nativeOverlapped); } catch { preAllocated.Release(); throw; } }
public unsafe void FreeNativeOverlapped(NativeOverlapped *overlapped) { if (overlapped == null) { throw new ArgumentNullException(nameof(overlapped)); } // Note: we explicitly allow FreeNativeOverlapped calls after the ThreadPoolBoundHandle has been Disposed. ThreadPoolBoundHandleOverlapped wrapper = GetOverlappedWrapper(overlapped, this); if (wrapper._boundHandle != this) { throw new ArgumentException(Environment.GetResourceString("Argument_NativeOverlappedWrongBoundHandle"), nameof(overlapped)); } if (wrapper._preAllocated != null) { wrapper._preAllocated.Release(); } else { Overlapped.Free(overlapped); } }
public unsafe NativeOverlapped *AllocateNativeOverlapped(PreAllocatedOverlapped preAllocated) { ArgumentNullException.ThrowIfNull(preAllocated); EnsureNotDisposed(); preAllocated.AddRef(); try { ThreadPoolBoundHandleOverlapped overlapped = preAllocated._overlapped; if (overlapped._boundHandle != null) { throw new ArgumentException(SR.Argument_PreAllocatedAlreadyAllocated, nameof(preAllocated)); } overlapped._boundHandle = this; return(overlapped._nativeOverlapped); } catch { preAllocated.Release(); throw; } }
public unsafe NativeOverlapped *AllocateNativeOverlapped(PreAllocatedOverlapped preAllocated) { if (preAllocated == null) { throw new ArgumentNullException("preAllocated"); } this.EnsureNotDisposed(); preAllocated.AddRef(); NativeOverlapped *nativeOverlapped; try { ThreadPoolBoundHandleOverlapped expr_21 = preAllocated._overlapped; if (expr_21._boundHandle != null) { throw new ArgumentException("Already Allocated", "preAllocated"); } expr_21._boundHandle = this; nativeOverlapped = expr_21._nativeOverlapped; } catch { preAllocated.Release(); throw; } return(nativeOverlapped); }
public PreAllocatedOverlapped(IOCompletionCallback callback, object state, object pinData) { if (callback == null) { throw new ArgumentNullException("callback"); } this._overlapped = new ThreadPoolBoundHandleOverlapped(callback, state, pinData, this); }
public static unsafe object?GetNativeOverlappedState(NativeOverlapped *overlapped) { ArgumentNullException.ThrowIfNull(overlapped); ThreadPoolBoundHandleOverlapped wrapper = GetOverlappedWrapper(overlapped); Debug.Assert(wrapper._boundHandle != null); return(wrapper._userState); }
public unsafe static object GetNativeOverlappedState(NativeOverlapped *overlapped) { if (overlapped == null) { throw new ArgumentNullException("overlapped"); } ThreadPoolBoundHandleOverlapped overlappedWrapper = ThreadPoolBoundHandle.GetOverlappedWrapper(overlapped, null); return(overlappedWrapper._userState); }
private unsafe NativeOverlapped *AllocateNativeOverlapped(IOCompletionCallback callback, object?state, object?pinData, bool flowExecutionContext) { ArgumentNullException.ThrowIfNull(callback); EnsureNotDisposed(); ThreadPoolBoundHandleOverlapped overlapped = new ThreadPoolBoundHandleOverlapped(callback, state, pinData, preAllocated: null, flowExecutionContext); overlapped._boundHandle = this; return(overlapped._nativeOverlapped); }
public static unsafe object GetNativeOverlappedState(NativeOverlapped *overlapped) { if (overlapped == null) { throw new ArgumentNullException(nameof(overlapped)); } ThreadPoolBoundHandleOverlapped wrapper = GetOverlappedWrapper(overlapped, null); BCLDebug.Assert(wrapper._boundHandle != null, "_wrapper._boundHandle is null"); return(wrapper._userState); }
public unsafe NativeOverlapped *AllocateNativeOverlapped(IOCompletionCallback callback, object state, object pinData) { if (callback == null) { throw new ArgumentNullException(nameof(callback)); } EnsureNotDisposed(); ThreadPoolBoundHandleOverlapped overlapped = new ThreadPoolBoundHandleOverlapped(callback, state, pinData, preAllocated: null); overlapped._boundHandle = this; return(overlapped._nativeOverlapped); }
private unsafe static void CompletionCallback(uint errorCode, uint numBytes, NativeOverlapped *nativeOverlapped) { ThreadPoolBoundHandleOverlapped expr_0B = (ThreadPoolBoundHandleOverlapped)Overlapped.Unpack(nativeOverlapped); if (expr_0B._completed) { throw new InvalidOperationException("Native Overlapped reused"); } expr_0B._completed = true; if (expr_0B._boundHandle == null) { throw new InvalidOperationException("Already freed"); } expr_0B._userCallback.Invoke(errorCode, numBytes, nativeOverlapped); }
// Token: 0x06003B97 RID: 15255 RVA: 0x000E0480 File Offset: 0x000DE680 private unsafe static void CompletionCallback(uint errorCode, uint numBytes, NativeOverlapped *nativeOverlapped) { ThreadPoolBoundHandleOverlapped threadPoolBoundHandleOverlapped = (ThreadPoolBoundHandleOverlapped)Overlapped.Unpack(nativeOverlapped); if (threadPoolBoundHandleOverlapped._completed) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NativeOverlappedReused")); } threadPoolBoundHandleOverlapped._completed = true; if (threadPoolBoundHandleOverlapped._boundHandle == null) { throw new InvalidOperationException(Environment.GetResourceString("Argument_NativeOverlappedAlreadyFree")); } threadPoolBoundHandleOverlapped._userCallback(errorCode, numBytes, nativeOverlapped); }
public unsafe void FreeNativeOverlapped(NativeOverlapped *overlapped) { if (overlapped == null) { throw new ArgumentNullException("overlapped"); } ThreadPoolBoundHandleOverlapped overlappedWrapper = ThreadPoolBoundHandle.GetOverlappedWrapper(overlapped, this); if (overlappedWrapper._boundHandle != this) { throw new ArgumentException("Wrong bound handle", "overlapped"); } if (overlappedWrapper._preAllocated != null) { overlappedWrapper._preAllocated.Release(); return; } Overlapped.Free(overlapped); }
public unsafe void FreeNativeOverlapped(NativeOverlapped *overlapped) { ArgumentNullException.ThrowIfNull(overlapped); // Note: we explicitly allow FreeNativeOverlapped calls after the ThreadPoolBoundHandle has been Disposed. ThreadPoolBoundHandleOverlapped wrapper = GetOverlappedWrapper(overlapped); if (wrapper._boundHandle != this) { throw new ArgumentException(SR.Argument_NativeOverlappedWrongBoundHandle, nameof(overlapped)); } if (wrapper._preAllocated != null) { wrapper._preAllocated.Release(); } else { Overlapped.Free(overlapped); } }
private static unsafe void CompletionCallback(uint errorCode, uint numBytes, NativeOverlapped *nativeOverlapped) { ThreadPoolBoundHandleOverlapped overlapped = (ThreadPoolBoundHandleOverlapped)Overlapped.Unpack(nativeOverlapped); // // The Win32 thread pool implementation of ThreadPoolBoundHandle does not permit reuse of NativeOverlapped // pointers without freeing them and allocating new a new one. We need to ensure that code using the CLR // ThreadPool implementation follows those rules. // if (overlapped._completed) { throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NativeOverlappedReused")); } overlapped._completed = true; if (overlapped._boundHandle == null) { throw new InvalidOperationException(Environment.GetResourceString("Argument_NativeOverlappedAlreadyFree")); } overlapped._userCallback(errorCode, numBytes, nativeOverlapped); }
public unsafe NativeOverlapped* AllocateNativeOverlapped(IOCompletionCallback callback, object state, object pinData) { if (callback == null) throw new ArgumentNullException("callback"); EnsureNotDisposed(); ThreadPoolBoundHandleOverlapped overlapped = new ThreadPoolBoundHandleOverlapped(callback, state, pinData, preAllocated: null); overlapped._boundHandle = this; return overlapped._nativeOverlapped; }