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;
}
