public async Task <long> WriteAsync([CanBeNull] IFileReader reader, CancellationToken token)
        {
            if (reader == null)
            {
                return(-1);
            }
            HandleWriteStart();
            m_SetMaxProcess?.Invoke(-1);

            try
            {
                var sourceAccess = new SourceAccess(m_FullPath, false, recipient: m_Recipient, keepEnencyrpted: m_KeepUnencrypted);
                if (!string.IsNullOrEmpty(m_IdentifierInContainer))
                {
                    sourceAccess.IdentifierInContainer = m_IdentifierInContainer;
                }

                using (var improvedStream = FunctionalDI.OpenStream(sourceAccess))
                    await WriteReaderAsync(reader, improvedStream as Stream, token).ConfigureAwait(false);
            }
            catch (Exception exc)
            {
                Logger.Error(exc, "Could not write file {filename}", FileSystemUtils.GetShortDisplayFileName(m_FullPath));
                throw new FileWriterException($"Could not write file '{FileSystemUtils.GetShortDisplayFileName(m_FullPath)}'\n{exc.SourceExceptionMessage()}",
                                              exc);
            }
            finally
            {
                Logger.Debug("Finished writing {filesetting} Records: {records}", m_FileSettingDisplay, Records);
                WriteFinished?.Invoke(this, null);
            }

            return(Records);
        }
        private async Task WriteToFile()
        {
            while (true)
            {
                _isWriting = true;
                var fileSegment = await FileSegmentList.DequeueAsync();

                try
                {
                    Stream.Seek(fileSegment.FileStartPoint, SeekOrigin.Begin);

                    await Stream.WriteAsync(fileSegment.Data, fileSegment.DataOffset, fileSegment.DataLength);
                }
                catch (Exception e)
                {
                    Exception = e;
                    WriteFinished?.Invoke(this, EventArgs.Empty);
                    return;
                }

                _isWriting = false;

                try
                {
                    fileSegment.TaskCompletionSource?.SetResult(true);

                    StepWriteFinished
                    (
                        this,
                        new StepWriteFinishedArgs
                        (
                            fileSegment.FileStartPoint,
                            fileSegment.DataOffset,
                            fileSegment.Data,
                            fileSegment.DataLength
                        )
                    );
                }
                catch (Exception)
                {
                    // 执行业务代码
                }

                var isEmpty = FileSegmentList.Count == 0;

                if (isEmpty)
                {
                    WriteFinished?.Invoke(this, EventArgs.Empty);
                    if (_isDispose)
                    {
                        return;
                    }
                }
            }
        }
 void OnWriteFinished(EventArgs e)
 => WriteFinished?.Invoke(this, e);