using System;
using System.Diagnostics;
using System.IO;
using System.IO.MemoryMappedFiles;

internal unsafe class Program
{
    private static void Main()
    {
        var filename = @"C:\Users\alexz\Desktop\H.VHDX"; // ~100 Гб
        var mmf = MemoryMappedFile.CreateFromFile(filename, FileMode.Open);
        var accessor = mmf.CreateViewAccessor();
        var length = accessor.Capacity;

        var handle = accessor.SafeMemoryMappedViewHandle;
        byte* start = default;
        handle.AcquirePointer(ref start);

        var timer = Stopwatch.StartNew();
        var result = CountBytes(0, start, start + length);
        timer.Stop();

        Console.WriteLine(result);
        Console.WriteLine(length * 1000 / timer.ElapsedMilliseconds / 1_000_000 + " Mb/s");
    }

    private static long CountBytes(byte reference, byte* startPointer, byte* endPointer)
    {
        long count = 0;
        byte* pointer = startPointer;
        while (pointer < endPointer)
        {
            if (*pointer++ == reference) count++;
        }
        return count;
    }
}

using System;
using System.Diagnostics;
using System.IO;
using System.Threading.Tasks;

internal class Program
{
    private static async Task Main()
    {
        var filename = @"C:\Users\alexz\Desktop\H.VHDX";
        var length = new FileInfo(filename).Length;
        var stream = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read);

        long result = 0;

        var timer = Stopwatch.StartNew();
        {
            const int BUFFER_SIZE = 256 * 1024;
            var buffers = new[] { new byte[BUFFER_SIZE], new byte[BUFFER_SIZE] };
            var activeBufferIndex = 0;
            var bytesRead = 0;
            do
            {
                var task = stream.ReadAsync(buffers[activeBufferIndex], 0, buffers[activeBufferIndex].Length);
                result += CountBytes(0, buffers[1 - activeBufferIndex], bytesRead);
                bytesRead = await task;
                activeBufferIndex = 1 - activeBufferIndex;
            } while (bytesRead > 0);
        }
        timer.Stop();

        Console.WriteLine(result);
        Console.WriteLine(length * 1000 / timer.ElapsedMilliseconds / 1_000_000 + " Mb/s");
    }

    private static long CountBytes(byte reference, byte[] buffer, int size)
    {
        var count = 0;
        for (var i = 0; i < size; i++)
        {
            if (buffer[i] == reference) count++;
        }
        return count;
    }
}

class Program
{
        static async Task Main(string[] args)
        {
                const int BufferSize = 128 * 1024;
                const string Path = @"c:\iso\myiso.iso";
                const int TaskNumber = 16;
                const byte Pattern = 42;

                var totalLength = new FileInfo(Path).Length;
                var timer = Stopwatch.StartNew();
                var tasks = new Task<int>[TaskNumber];
                for (int i = 0; i < TaskNumber; i++)
                {
                        var fs = new FileStream(Path, FileMode.Open, FileAccess.Read, FileShare.Read, BufferSize, FileOptions.SequentialScan);
                        var position = totalLength / TaskNumber * i;
                        fs.Seek(position, SeekOrigin.Begin);
                        var length = i == TaskNumber - 1 ? totalLength - position : totalLength / TaskNumber;
                        tasks[i] = Task.Run(() => Worker(fs, length, Pattern));
                }
                var result = await Task.WhenAll(tasks);
                var speed = totalLength * 1000 / timer.ElapsedMilliseconds / 1_000_000;
                Console.WriteLine($"Read {totalLength} bytes for {timer.ElapsedMilliseconds / 1000} seconds. Speed is {speed} Mb/s");
                Console.WriteLine($"Found {result.Sum()} occurences of byte {Pattern}");
        }

        static int Worker(FileStream fs, long length, byte pattern)
        {
                var count = 0;
                while (length > 0)
                {
                        if (fs.ReadByte() == pattern)
                        {
                                count++;
                        }
                        --length;
                }
                return count;
        }
}

class Program
{
    static async Task Main(string[] args)
    {
        const int FILE_FLAG_NO_BUFFERING = 0x20000000;
        const int BufferSize = 256 * 1024;
        const string Path = @"c:\iso\myiso.iso";
        const int TaskNumber = 16;
        const byte Pattern = 42;

        var totalLength = new FileInfo(Path).Length;
        var timer = Stopwatch.StartNew();
        var tasks = new Task<int>[TaskNumber];
        for (int i = 0; i < TaskNumber; i++)
        {
            var options = (FileOptions) FILE_FLAG_NO_BUFFERING | FileOptions.SequentialScan;
            var fs = new FileStream(Path, FileMode.Open, FileAccess.Read, FileShare.Read, BufferSize, options);
            var position = i * BufferSize;
            tasks[i] = Task.Run(() => Worker(fs, position, TaskNumber * BufferSize, BufferSize, Pattern));
        }
        var result = await Task.WhenAll(tasks);
        var speed = totalLength * 1000 / timer.ElapsedMilliseconds / 1_000_000;
        Console.WriteLine($"Read {totalLength} bytes for {timer.ElapsedMilliseconds / 1000.0} seconds. Speed is {speed} Mb/s");
        Console.WriteLine($"Found {result.Sum()} occurences of byte {Pattern}");
    }

    private static int Worker(FileStream fs, long position, int step, int size, byte pattern)
    {
        var totalLength = fs.Length;
        var result = 0;
        var buffer = new byte[Math.Min(1024, size)];
        while (position < totalLength)
        {
            fs.Seek(position, SeekOrigin.Begin);
            var count = (int) Math.Min(size, totalLength - position);
            while (count > 0)
            {
                var read = fs.Read(buffer, 0, buffer.Length);
                for (int i = 0; i < read; i++)
                {
                    if (buffer[i] == pattern)
                    {
                        result++;
                    }
                }
                count -= read;
            }
            position += step;
        }
        return result;
    }
}