"Wirtualny" podział pliku w pamięci

Piszę aplikację, która wysyła duże pliki. Każdy z tych plików musi być podzielony na mniejsze. Obecnie wykorzystuję funkcję:

        public static void SplitFile(string inputFile, int chunkSize, string path)
        {
            const int BUFFER_SIZE = 20 * 1024;
            byte[] buffer = new byte[BUFFER_SIZE];
            using (Stream input = File.OpenRead(inputFile))
            {
                int index = 0;
                while (input.Position < input.Length)
                {
                    using (Stream output = File.Create(path + "\\" + index + ".me"))
                    {
                        int remaining = chunkSize, bytesRead;
                        while (remaining > 0 && (bytesRead = input.Read(buffer, 0, Math.Min(remaining, BUFFER_SIZE))) > 0)
                        {
                            output.Write(buffer, 0, bytesRead);
                            remaining -= bytesRead;
                        }
                    }
                    index++;
                    Thread.Sleep(500);
                }
            }
        }

która dzieli mi duży plik na kilka małych i zapisuje te małe do jakiegoś folderu. Chciałbym, żeby ten podział odbywał się "wirtualnie", tzn. aplikacja wyodrębnia z dużego pliku pierwszą małą część i wysyła. Następnie wyodrębnia drugą część i wysyła. Wysyłany part ma być zapisywany gdzieś do pamięci, nie do folderu. I tak, aż wyśle wszystko, a postęp (którą obecnie część wyodrębnia) zapisuje. Wiem, że coś takiego da się zrobić, tylko nie wiem jak.

Będę wdzięczny za wszystkie rady, linki, podpowiedzi, przykłady...

To nie zapisuj go do pliku? O.o
Przecież masz go podzielonego w pamięci w postaci bloków o rozmiarze 20*1024 bajtów które wczytujesz do tablicy buffer.

Może coś takiego pomoże(zakładając że czytanie zajmuje znacznie miej czasu niż wysyłanie).

   public void ReadAndSend(string path, Action<byte[]> send)
        {
            int index = 0;
            int bufferSize = 1024;
            var buffer = PartialRead(path, index, bufferSize);

            while (buffer.Length != 0)
            {
                index += buffer.Length;
                send(buffer);
                buffer = PartialRead(path, index, bufferSize);
            }
        }
        private byte[] PartialRead(string path, int index, int count)
        {
            BinaryReader br;
            FileStream fs;
            using (fs = new FileStream(path, FileMode.Open))
            {
                fs.Position = index;
                using (br = new BinaryReader(fs))
                {
                   return br.ReadBytes(count);
                }
            }
        }