private static async Task ScanDirectoryAsync <T>(string path, ScannerOptions options, DependencyFound onDependencyFound, CancellationToken cancellationToken = default)
            where T : struct, IEnabledScannersArray
        {
            var fileSystem = options.FileSystem;

            using var enumerator = new ScannerFileEnumerator <T>(path, options);
            while (enumerator.MoveNext())
            {
                var entry           = enumerator.Current;
                var scanFileContext = new ScanFileContext(entry.FullPath, onDependencyFound, fileSystem, cancellationToken);
                try
                {
                    for (var i = 0; i < options.Scanners.Count; i++)
                    {
                        if (!entry.Scanners.Get(i))
                        {
                            continue;
                        }

                        var scanner = options.Scanners[i];

                        scanFileContext.ResetStream();
                        await scanner.ScanAsync(scanFileContext).ConfigureAwait(false);
                    }
                }
                finally
                {
                    await scanFileContext.DisposeAsync().ConfigureAwait(false);
                }
            }
        }
        private static async Task ScanDirectoryParallelAsync <T>(string path, ScannerOptions options, DependencyFound onDependencyFound, CancellationToken cancellationToken = default)
            where T : struct, IEnabledScannersArray
        {
            var fileSystem         = options.FileSystem;
            var filesToScanChannel = Channel.CreateBounded <FileToScan <T> >(new BoundedChannelOptions(10000)
            {
                AllowSynchronousContinuations = true,
                SingleWriter = true,
                SingleReader = false,
                FullMode     = BoundedChannelFullMode.Wait,
            });

            // Start enumerating
            var enumeratorTask = Task.Run(async() =>
            {
                using var enumerator = new ScannerFileEnumerator <T>(path, options);
                while (enumerator.MoveNext())
                {
                    await filesToScanChannel.Writer.WriteAsync(enumerator.Current, cancellationToken).ConfigureAwait(false);
                }
                filesToScanChannel.Writer.Complete();
            }, cancellationToken);

            // Parse files
            var tasks = new Task[options.DegreeOfParallelism + 1];

            tasks[0] = enumeratorTask;
            Array.Fill(tasks, Task.Run(async() =>
            {
                var reader = filesToScanChannel.Reader;
                while (await reader.WaitToReadAsync(cancellationToken).ConfigureAwait(false))
                {
                    while (reader.TryRead(out var entry))
                    {
                        var scanFileContext = new ScanFileContext(entry.FullPath, onDependencyFound, fileSystem, cancellationToken);
                        try
                        {
                            for (var i = 0; i < options.Scanners.Count; i++)
                            {
                                if (!entry.Scanners.Get(i))
                                {
                                    continue;
                                }

                                var scanner = options.Scanners[i];

                                scanFileContext.ResetStream();
                                await scanner.ScanAsync(scanFileContext).ConfigureAwait(false);
                            }
                        }
                        finally
                        {
                            await scanFileContext.DisposeAsync().ConfigureAwait(false);
                        }
                    }
                }
            }, cancellationToken), startIndex: 1, options.DegreeOfParallelism);

            await Task.WhenAll(tasks).ConfigureAwait(false);
        }
        private static async IAsyncEnumerable <Dependency> ScanDirectoryParallelAsync <T>(string path, ScannerOptions options, [EnumeratorCancellation] CancellationToken cancellationToken = default)
            where T : struct, IEnabledScannersArray
        {
            var fileSystem         = options.FileSystem;
            var filesToScanChannel = Channel.CreateBounded <FileToScan <T> >(new BoundedChannelOptions(1000)
            {
                AllowSynchronousContinuations = true,
                SingleWriter = true,
                SingleReader = false,
                FullMode     = BoundedChannelFullMode.Wait,
            });

            var dependenciesChannel = Channel.CreateUnbounded <Dependency>(new UnboundedChannelOptions
            {
                AllowSynchronousContinuations = true,
                SingleWriter = false,
                SingleReader = true,
            });

            // Start enumerating
            var enumeratorTask = Task.Run(async() =>
            {
                using var enumerator = new ScannerFileEnumerator <T>(path, options);
                while (enumerator.MoveNext())
                {
                    await filesToScanChannel.Writer.WriteAsync(enumerator.Current, cancellationToken).ConfigureAwait(false);
                }
                filesToScanChannel.Writer.Complete();
            }, cancellationToken);

            // Parse files
            var exceptions = new ConcurrentBag <Exception>();
            var tasks      = new Task[options.DegreeOfParallelism];

            Array.Fill(tasks, Task.Run(async() =>
            {
                var reader = filesToScanChannel.Reader;
                while (await reader.WaitToReadAsync(cancellationToken).ConfigureAwait(false))
                {
                    while (reader.TryRead(out var entry))
                    {
                        var scanFileContext = new ScanFileContext(entry.FullPath, d => dependenciesChannel.Writer.WriteAsync(d, cancellationToken), fileSystem, cancellationToken);
                        try
                        {
                            for (var i = 0; i < options.Scanners.Count; i++)
                            {
                                if (!entry.Scanners.Get(i))
                                {
                                    continue;
                                }

                                var scanner = options.Scanners[i];

                                scanFileContext.ResetStream();
                                await scanner.ScanAsync(scanFileContext).ConfigureAwait(false);
                            }
                        }
                        finally
                        {
                            await scanFileContext.DisposeAsync().ConfigureAwait(false);
                        }
                    }
                }
            }, cancellationToken));

            var whenAllTasks       = Task.WhenAll(tasks);
            var writerCompleteTask = whenAllTasks.ContinueWith(_ => dependenciesChannel.Writer.Complete(), cancellationToken);

            await foreach (var value in dependenciesChannel.Reader.ReadAllAsync(cancellationToken).WithCancellation(cancellationToken).ConfigureAwait(false))
            {
                yield return(value);
            }

            await writerCompleteTask.ConfigureAwait(false);

            await whenAllTasks.ConfigureAwait(false);
        }