Очень большой string[] buf

            
            StreamReader ds = new StreamReader(newstrFile);  // открыли поток
            string TextFile = ds.ReadToEnd();                           // прочитали весь файл
            ds.Close(); 
 
            int strLength = TextFile.Length;        // длина строки
 
            TextFile = TextFile.Replace("МЕТКА", ".");  // меняем метку на символ
 
            if (TextFile != null)
            {
                string[] buf = TextFile.Split('.'); //разбиваем огромную строку на массив string и вот тут возникает проблема.
             }

string[] buf = TextFile.Split(new[] { "МЕТКА" }, StringSplitOptions.None);

using (FileStream fs = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
using (BufferedStream bs = new BufferedStream(fs))
using (StreamReader sr = new StreamReader(bs))
{
    string line;
    while ((line = sr.ReadLine()) != null)
    {
 
    }
}

 using (Stream stream = System.IO.File.OpenRead(newstrFile))
            {
                using (StreamReader streamReader = new
                StreamReader(stream, System.Text.Encoding.ASCII))
                {
                    string[] buffer = new string[100];
                    string read = "";
                    while (streamReader.Peek() > -1)
                    {
                        string[] buf = read.Split(new[] { "@" }, StringSplitOptions.None);
 
                    }
                }
            }

using (Stream stream = System.IO.File.OpenRead(fileName))
{
       using (StreamReader streamReader = new
        StreamReader(stream,    System.Text.Encoding.ASCII))
         {
            char[] buffer = new char[202];
              int read = 0;
                while (streamReader.Peek() > -1)
                 {
                   read = streamReader.Read(buffer, 0, 202);
                }
                     }
             }

var path = "c:/test.txt";
            var blockLenght = 4096;
            var buff=new byte[blockLenght];
            int offset = 0;
            var list=new List<string>();
            using (FileStream fs = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
            {
                var len = blockLenght;
                while ((len=fs.Read(buff, 0, blockLenght)) >0)
                {
                    var dataStr = Encoding.ASCII.GetString(buff);
                    offset += dataStr.LastIndexOf("MTK1CTR", StringComparison.Ordinal);
                    var dataArr = dataStr.Split(new string[] { "MTK1CTR" },StringSplitOptions.RemoveEmptyEntries);
                    //или
                    //dataStr=dataStr.Replace("MTK1CTR", ".");
                    //dataArr = dataStr.Split('.',StringSplitOptions.RemoveEmptyEntries);
                    list.AddRange(dataArr);
                    list.RemoveAt(list.Count-1);
                    if(len<blockLenght)break;
 
                    fs.Seek(offset, SeekOrigin.Begin);
                    buff=new byte[blockLenght];
                }
            }

static IEnumerable<string> ReadParts(string path, string separator)
{
    using (var fstream = File.OpenRead(path))
    using (var reader = new BinaryReader(fstream))
    {
        StringBuilder sb = new StringBuilder(50);
        char[] buffer = new char[32000];
        int idx = 0;
        while (fstream.Position < fstream.Length)
        {
            int charsRead = reader.Read(buffer, 0, buffer.Length);
            for (int i=0; i<charsRead; i++)            
            {
                char ch = buffer[i];
                if (ch == separator[idx])
                {
                    idx++;
                    if (idx == separator.Length)
                    {
                        yield return sb.ToString();
                        sb.Clear();
                        idx = 0;
                    }
                }
                else
                {
                    sb.Append(ch);
                }
            }
        }
        
        if (sb.Length>0) yield return sb.ToString();
    }
}

            foreach (string n in ReadParts(newstrFile, "@")) {
 
            }

fs.Seek(offset, SeekOrigin.Begin);
buff = new byte[blockLenght];

int strBuf = dataArr.Length;
int[] arr = new int[strBuf];

    List<string> stringlist = new List<string>();
            string[] mybuf = {};
 
            foreach (string n in ReadParts(newstrFile, "@")) {
 
               stringlist.Add(n);
               mybuf = stringlist.ToArray();
 
            }

List<string> stringlist = new List<string>();
            string[] mybuf = {};
            byte[] mybytes1 = { };
            int j = 0;
            foreach (string n in ReadParts(newstrFile, "@")) {
 
               stringlist.Add(n);
               mybuf = stringlist.ToArray();
 
            }
            
            mybuf = stringlist.ToArray();
            int strBuf = mybuf.Length;
            int[] arr = new int[strBuf];
 
            for (int i = 0; i < strBuf; i++)
            {
                arr[i] = Convert.ToInt32(mybuf[i]);
             }

            int nCols = 16;
            FileStream fs = new FileStream(newstrFile, FileMode.Open, FileAccess.Read);
            long nBytesRead = fs.Length;
           
            int nLines = (int)(nBytesRead / nCols) + 1;   // вот тут что-то не так
          //  int nLines = (int)(nBytesRead);
            string[] lines = new string[nLines];
            int nBytesToRead = 0;
            byte[] mybytes1;
 
            int strBuf = lines.Length;
            int[] arr = new int[strBuf];
 
 
            for (int i = 0; i < nLines; i++)
            {
                StringBuilder nextLine = new StringBuilder();
                nextLine.Capacity = 4 * nCols;
                
                for (int j = 0; j < nLines; j++)
                {
                    int nextByte = fs.ReadByte();
                    nBytesToRead++;
                    char nextChar = (char)nextByte;  // получаем байт
                    
                    if (nextChar == '@'){ 
                        break;   // исключаем метку, выходим из цикла и заставляем StringBuilder заполнять новую строку
                    }
                        else {
                    nextLine.Append(nextChar);
                  }
 
                }
                // далее просто преобразования для тестирования
                lines[i] = nextLine.ToString();
                arr[i] = Convert.ToInt32(lines[i]);
            }
            fs.Close();
                mybytes1 = arr.Select(x => (byte)x).ToArray();
 
 
                using (FileStream fileStream = new FileStream(newPathFile, FileMode.Append, FileAccess.Write))
                {
 
                    fileStream.Write(mybytes1, 0, mybytes1.Length); 
 
                    fileStream.Flush();
                    fileStream.Close();
                }

            int nLines = (int)(nBytesRead / nCols) + 1;

            int nLines = (int)(nBytesRead);

int nextByte = fs.ReadByte();