Многопоточная генерация сигнатуры файла

    class Controller
    {
        //Хранит текущую точку чтения файла
        int _blockNumber;
        //Хранит предыдущее значение _blockNumber
        int _temp;
        //Длинна буфера
        int _bufferSize;
        //путь к файлу для чтения
        string _filePath;
        //Длинна файла
        long _fileLength;
 
        //Объект который будем блокировать
        object _toLock = new object();
 
        //Номер блока
        private int blockNumber
        {
            get
            {
                _temp = _blockNumber;
                _blockNumber++;
                return _temp;
            }
        }
 
        public Controller(string filePath, int bufferSize)
        {
            _bufferSize = bufferSize;
            _filePath = filePath;
 
            FileInfo file = new FileInfo(filePath);
            _fileLength = file.Length;
 
            if (!file.Exists)
            {
                Console.WriteLine("Файл по указанному пути не найден");
                return;
            }
 
            //Получаем к-во процессоров/ядер
            int _threadsCount = Environment.ProcessorCount;
            //Один поток главный, все остальное работники
            _threadsCount = _threadsCount > 2 ? _threadsCount - 1 : 1;
 
            for (int i = 0; i < _threadsCount; i++)
                new Thread(new ThreadStart(TODO)).Start();
        }
 
        //Пока не решил как назову этот метод :)
        private void TODO()
        {
            while (true)
            {
                long currentPoint;
 
                lock (_toLock)
                {
                    currentPoint = blockNumber;
                }
 
                if (currentPoint * _bufferSize > _fileLength)
                    return;
 
                byte[] _buffer = new byte[_bufferSize];
 
                using (BinaryReader br = new BinaryReader(File.Open(_filePath, FileMode.Open, FileAccess.Read, FileShare.Read)))
                {
                    try
                    {
                        br.BaseStream.Position = currentPoint * _bufferSize;
                        br.Read(_buffer, 0, _bufferSize);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.Message + "\n" + ex.StackTrace);
                    }
                }
 
                SHA256 sha = SHA256Managed.Create();
 
                byte[] hash = sha.ComputeHash(_buffer);
 
                Console.Clear();
                Console.Write(currentPoint + " - ");
                PrintByteArray(hash);
            }
        }
 
        public static void PrintByteArray(byte[] array)
        {
            int i;
            for (i = 0; i < array.Length; i++)
            {
                Console.Write(String.Format("{0:X2}", array[i]));
                if ((i % 4) == 3) Console.Write(" ");
            }
            Console.WriteLine();
        }
    }

using System;
using System.Diagnostics;
using System.IO;
using System.Security.Cryptography;
using System.Threading;
 
namespace Test1V3
{
    class Program
    {
        static void Main(string[] args)
        {
            something s = new something("d:/123.txt", 1000);
        }
    }
 
    class something
    {
        //Длинна буфера
        int _bufferSize;
        //путь к файлу для чтения
        string _filePath;
        //Длинна файла
        long _fileLength;
        //Текущая позиция чтения
        long _blocknumber;
 
        //Объект который будем блокировать
        object _toLock = new object();
 
        protected struct block
        {
            public long Number;
            public byte[] Data;
 
            public block(long number, byte[] data)
            {
                Number = number;
                Data = data;
            }
        }
 
        public something(string filePath, int bufferSize)
        {
            _filePath = filePath;
            _bufferSize = bufferSize;
 
            FileInfo file = new FileInfo(filePath);
            _fileLength = file.Length;
 
            //Получаем к-во процессоров/ядер
            int _threadsCount = Environment.ProcessorCount; ;
 
            for (int i = 0; i < _threadsCount; i++)
            {
                new Thread(new ThreadStart(TODO)).Start();
            }
 
            Console.ReadKey();
        }
 
        private void TODO()
        {
            while (true)
            {
                block dataBlock = GetData();
 
                if (_bufferSize >= 20000000)
                    GC.Collect();
 
                if (dataBlock.Number < 0)
                    return;
 
                SHA256 sha = SHA256Managed.Create();
 
                byte[] hash = sha.ComputeHash(dataBlock.Data);
 
                Console.Clear();
                Console.Write(dataBlock.Number + " - ");
                PrintByteArray(hash);
            }
        }
 
        public static void PrintByteArray(byte[] array)
        {
            int i;
            for (i = 0; i < array.Length; i++)
            {
                Console.Write(String.Format("{0:X2}", array[i]));
                if ((i % 4) == 3) Console.Write(" ");
            }
            Console.WriteLine();
        }
 
        protected block GetData()
        {
            block temp = new block(-1, new byte[_bufferSize]);
            long position = _blocknumber * _bufferSize;
 
            lock (_toLock)
            {
                using (BinaryReader br = new BinaryReader(File.Open(_filePath, FileMode.Open, FileAccess.Read, FileShare.Read)))
                {
                    if (position > _fileLength)
                        return temp;
 
                    try
                    {
                        br.BaseStream.Position = position;
                        br.Read(temp.Data, 0, _bufferSize);
                        temp.Number = _blocknumber;
                        _blocknumber++;
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.Message + "\n" + ex.StackTrace);
                    }
                }
 
                return temp;
            }
        }
    }
}