private void WriteByParts(BlockingQueue <BlockingWorkItem <byte[]> > inputBlockingQueue,
                                  Action onFinished,
                                  Cancellation cancellation = null)
        {
            new Thread(() =>
            {
                _target.WriteByParts(CompressedParts());

                if (!cancellation.IsCancelled())
                {
                    onFinished();
                }

                IEnumerable <byte[]> CompressedParts()
                {
                    while (inputBlockingQueue.Dequeue(out var part))
                    {
                        if (cancellation?.IsCancelled() ?? false)
                        {
                            yield break;
                        }

                        yield return(part.GetResult());
                    }
                }
            }).Start();
        }
Esempio n. 2
0
        private async Task WriteByParts(ChannelReader <Task <byte[]> > channelReader, CancellationToken cancellationToken)
        {
            await Task.Run(async() =>
            {
                await _fileTarget.WriteByParts(Parts());
            }, cancellationToken);

            async IAsyncEnumerable <byte[]> Parts()
            {
                while (await channelReader.WaitToReadAsync(cancellationToken))
                {
                    var processedPartTask = await channelReader.ReadAsync(cancellationToken);

                    var processedPart = await processedPartTask;
                    yield return(processedPart);
                }
            }
        }