AsyncModeCopyToAsync()

static unsafe async Task System.IO.Strategies.FileStreamHelpers.AsyncModeCopyToAsync ( SafeFileHandle handle, bool canSeek, long filePosition, Stream destination, int bufferSize, CancellationToken cancellationToken )

inlinestaticpackage

Definition at line 325 of file FileStreamHelpers.cs.

    {
        AsyncCopyToAwaitable readAwaitable = new AsyncCopyToAwaitable(handle);
        if (canSeek)
        {
            readAwaitable._position = filePosition;
        }
        byte[] copyBuffer = ArrayPool<byte>.Shared.Rent(bufferSize);
        PreAllocatedOverlapped awaitableOverlapped = new PreAllocatedOverlapped(AsyncCopyToAwaitable.s_callback, readAwaitable, copyBuffer);
        CancellationTokenRegistration cancellationReg = default(CancellationTokenRegistration);
        try
        {
            if (cancellationToken.CanBeCanceled)
            {
                cancellationReg = cancellationToken.UnsafeRegister(delegate(object s)
                {
                    AsyncCopyToAwaitable asyncCopyToAwaitable = (AsyncCopyToAwaitable)s;
                    lock (asyncCopyToAwaitable.CancellationLock)
                    {
                        if (asyncCopyToAwaitable._nativeOverlapped != null)
                        {
                            Interop.Kernel32.CancelIoEx(asyncCopyToAwaitable._fileHandle, asyncCopyToAwaitable._nativeOverlapped);
                        }
                    }
                }, readAwaitable);
            }
            while (true)
            {
                cancellationToken.ThrowIfCancellationRequested();
                readAwaitable.ResetForNextOperation();
                try
                {
                    readAwaitable._nativeOverlapped = handle.ThreadPoolBinding.AllocateNativeOverlapped(awaitableOverlapped);
                    if (canSeek)
                    {
                        readAwaitable._nativeOverlapped->OffsetLow = (int)readAwaitable._position;
                        readAwaitable._nativeOverlapped->OffsetHigh = (int)(readAwaitable._position >> 32);
                    }
                    if (ReadFileNative(handle, copyBuffer, readAwaitable._nativeOverlapped, out var errorCode) < 0)
                    {
                        switch (errorCode)
                        {
                        case 38:
                        case 109:
                            readAwaitable.MarkCompleted();
                            break;
                        default:
                            throw Win32Marshal.GetExceptionForWin32Error(errorCode, handle.Path);
                        case 997:
                            break;
                        }
                    }
                    await readAwaitable;
                    switch (readAwaitable._errorCode)
                    {
                    case 995u:
                        throw new OperationCanceledException(cancellationToken.IsCancellationRequested ? cancellationToken : new CancellationToken(canceled: true));
                    default:
                        throw Win32Marshal.GetExceptionForWin32Error((int)readAwaitable._errorCode, handle.Path);
                    case 0u:
                    case 38u:
                    case 109u:
                    {
                        int numBytes = (int)readAwaitable._numBytes;
                        if (numBytes == 0)
                        {
                            return;
                        }
                        if (canSeek)
                        {
                            readAwaitable._position += numBytes;
                        }
                        break;
                    }
                    }
                }
                finally
                {
                    NativeOverlapped* nativeOverlapped;
                    lock (readAwaitable.CancellationLock)
                    {
                        nativeOverlapped = readAwaitable._nativeOverlapped;
                        readAwaitable._nativeOverlapped = null;
                    }
                    if (nativeOverlapped != null)
                    {
                        handle.ThreadPoolBinding.FreeNativeOverlapped(nativeOverlapped);
                    }
                }
                await destination.WriteAsync(new ReadOnlyMemory<byte>(copyBuffer, 0, (int)readAwaitable._numBytes), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
            }
        }
        finally
        {
            cancellationReg.Dispose();
            awaitableOverlapped.Dispose();
            ArrayPool<byte>.Shared.Return(copyBuffer);
        }
    }

References Interop.Kernel32.CancelIoEx(), System.cancellationToken, System.destination, System.Runtime.Serialization.Dictionary, System.IO.Win32Marshal.GetExceptionForWin32Error(), System.handle, System.IO.Strategies.FileStreamHelpers.ReadFileNative(), System.s, System.IO.Strategies.FileStreamHelpers.AsyncCopyToAwaitable.s_callback, and System.Buffers.ArrayPool< T >.Shared.

Referenced by System.IO.Strategies.AsyncWindowsFileStreamStrategy.AsyncModeCopyToAsync(), and System.IO.Strategies.Net5CompatFileStreamStrategy.AsyncModeCopyToAsync().