Перевести код с PHP на C#

<?php
 
class BlockBasedExternalSort {
        
        private $block;
        private $blockCount = 0;
        private $blockSize;
        private $fileDirectory;
        private $outputFile;
        private $blockIndex = 0;
        private $mergedBlocks = 0;
        private $queue;
        
        public function __construct($outputFile, $directory = '/tmp', $blockSize = 100000) {
                $this->outputFile = $outputFile;
                $this->fileDirectory = $directory;
                $this->blockSize = $blockSize;
        }
        
        public function addTerm($documentID, $termID) {
                if(!isset($this->block[$termID][$documentID])) {
                        $this->block[$termID][$documentID] = 1;
                } else {
                        $this->block[$termID][$documentID]++; 
                }
                $this->blockCount++;
                if($this->blockCount >= $this->blockSize) {
                        $this->writeBlock();
                }
        }
        
        public function merge() {
                for($i = 0; $i < $this->blockIndex; $i++) {
                        $reads[] = fopen($this->getBlockFile($i), 'r');
                }
                $write = fopen($this->outputFile, 'w');
                $this->buildQueue($reads);
                $lastTerm = 0;
                $combinedPostings = array();
                while(count($this->queue) > 0) {
                        list($termID, $postings) = $this->getLowest($reads);
                        $combinedPostings = 
                                array_merge($combinedPostings, unserialize($postings));
                        if($termID != $lastTerm) {
                                ksort($combinedPostings);
                                $lastTerm = $termID;
                                fwrite($write,  $termID . "\n" . 
                                                serialize($combinedPostings) . "\n");
                                unset($postings);
                                $combinedPostings = array();
                        }
                }
                
                foreach($reads as $read) {
                        fclose($read);
                }
                fclose($write);
                for($i = 0; $i < $this->blockIndex; $i++) {
                        unlink($this->getBlockFile($i));
                }
        }
        
        private function buildQueue($reads) {
                // if in 5.3, a SplPriorityQueue would be lovely here
                $this->queue = array();
                foreach($reads as $fID => $read) {
                        $this->queue[$fID] = (int)fgets($read);
                }
                asort($this->queue);
        }
        
        private function getLowest($reads) {
                list($fID, $termID) = each($this->queue);
                $postings = fgets($reads[$fID]);                
                $id = fgets($reads[$fID]);
                if($id === false) {
                        unset($this->queue[$fID]);
                } else {
                        $this->queue[$fID] = (int)$id; 
                }
                asort($this->queue);
                reset($this->queue);
                return array($termID, $postings);
        }
        
        private function writeBlock() {
                $this->blockCount = 0;
                ksort($this->block);
                $fh = fopen($this->getBlockfile($this->blockIndex++), 'w');
                foreach($this->block as $termID => $postings) {
                        // we could retrieve bytes written here
                        // which we could store in the dictionary
                        // for efficient lookup
                        fwrite($fh, $termID . "\n" . serialize($postings) . "\n");
                }
                unset($this->block);
                fclose($fh);
        }
        
        private function getBlockFile($index) {
                return $this->fileDirectory . '/index' . $index . '.idx';
        }
}
?>

<?php
        $bbes = new BlockBasedExternalSort(dirname(__FILE__) . '/index.idx', '/tmp');
        $dictionary = array();
        $termCount = 1;
        $docCount = 1;
        foreach(glob('*.txt') as $file) {
                $fileContents = file_get_contents($file);
                preg_match_all('/[a-zA-z]+/', $fileContents, $matches);
                unset($fileContents);
                foreach($matches[0] as $match) {
                        $match = strtolower($match);
                        if(!isset($dictionary[$match])) {
                                $dictionary[$match] = $termCount++;
                        }
                        $bbes->addTerm($docCount, $dictionary[$match]);
                }
                unset($matches);
                $docCount++;
        } 
        $bbes->merge();
?>