Выделить потоку польше памяти

cs.Write(data, 0, data.Length/2);
cs.Write(data, data.Length / 2, data.Length - (data.Length / 2));
cs.FlushFinalBlock();

public void Decrypt(byte[] data, string password, string put) 
        {
            using (MemoryStream ms = new MemoryStream(data, false))
            using (RijndaelManaged m = new RijndaelManaged())
            using (SHA256Managed h = new SHA256Managed())
            {
                try
                {
                    m.KeySize = 256;
                    m.BlockSize = 256;
 
                    byte[] hash = new byte[32];
                    ms.Read(hash, 0, 32);
                    byte[] salt = new byte[32];
                    ms.Read(salt, 0, 32);
 
                    Rfc2898DeriveBytes derivedKey = new Rfc2898DeriveBytes(password, salt) { IterationCount = 10000 };
                    m.Key = derivedKey.GetBytes(m.KeySize / 8);
                    m.IV = derivedKey.GetBytes(m.BlockSize / 8);
                    using (var output = new MemoryStream())
                    using (MemoryStream result = new MemoryStream())
                    {
                        using (CryptoStream cs = new CryptoStream(ms, m.CreateDecryptor(), CryptoStreamMode.Read))
                        {
                          //  byte[] buffer = new byte[1024];              
                           // int len;
                           // while ((len = cs.Read(buffer, 0, buffer.Length)) > 0)
                           //     result.Write(buffer, 0, len);
                            var buffer = new byte[1024];
                            var read = cs.Read(buffer, 0, buffer.Length);
                            while (read > 0)
                            {
                                output.Write(buffer, 0, read);
                                read = cs.Read(buffer, 0, buffer.Length);
                            }
                            cs.Flush();
                             
 
                        }
 
                        byte[] final = output.ToArray();
                        if (Convert.ToBase64String(hash) != Convert.ToBase64String(h.ComputeHash(final)))
                            throw new UnauthorizedAccessException();
 
                        File.WriteAllBytes(openFileDialog2.FileName + ".dicr", output.ToArray());
                        MessageBox.Show(" decrypt ok");
                    }
                }
                catch
                {
                    //never leak the exception type...
                    throw new UnauthorizedAccessException();
                }
            }
        }

new Thread(() => cs.Write(data, 0, data.Length/2)).Start();
new Thread(() => cs.Write(cs.Write(data, data.Length / 2, data.Length - (data.Length / 2))).Start();

    public sealed class Crypter :
        IDisposable
    {
        #region Constats
        private const int HeadSize = 8;
        #endregion
 
        #region Private Values
        private SymmetricAlgorithm CryptAlgorithm;
        private int BufferCoefficientValue;
        #endregion
 
        #region Properties
        /// <summary>
        /// Получает коэфициент, определяющий размер буффера (в пределах 10-100).
        /// </summary>
        public int BufferCoefficient
        {
            get 
            {
                if (Disposed)
                    throw new ObjectDisposedException("Object Disposed");
 
                return BufferCoefficientValue; 
            }
            set 
            {
                if (Disposed)
                    throw new ObjectDisposedException("Object Disposed");
 
                BufferCoefficientValue = (value >= 10 && value <= 100) ? value : 20; 
            }
        }
        #endregion
 
        #region Constructors
        /// <summary>
        /// Создает экемпляр класса FileCrypter.
        /// </summary>
        public Crypter(SymmetricAlgorithm SymmetricAlg)
        {
            if (SymmetricAlg == null)
                throw new ArgumentNullException();
 
            CryptAlgorithm = SymmetricAlg;
 
            BufferCoefficientValue = 10;
        }
        #endregion
 
        #region Public Methods
        /// <summary>
        /// Генерирует ключ и вектор инициализации.
        /// </summary>
        /// <returns>Ключ.</returns>
        public byte[] GenerateKey()
        {
            if (Disposed)
                throw new ObjectDisposedException("Object Disposed");
 
            CryptAlgorithm.GenerateKey();
            CryptAlgorithm.GenerateIV();
 
            return CryptAlgorithm.Key;
        }
 
        /// <summary>
        /// Производит шифрование потока.
        /// </summary>
        /// <param name="input_file">Поток, который будет зашифрован.</param>
        /// <param name="output_file">Поток, в который будет записан результат шифрования.</param>
        public void EncryptStream(Stream InputStream, Stream OutputStream)
        {
            if (Disposed)
                throw new ObjectDisposedException("Object Disposed");
 
            if (InputStream == null || OutputStream == null)
                throw new ArgumentNullException("One of the arguments (or two) equals null");
 
            ICryptoTransform encryptor = null;
            CryptoStream csEncrypt = null;
 
            try
            {
                int MaxBufferSizeValue = BufferCoefficientValue * 256 * 1024;
 
                encryptor = CryptAlgorithm.CreateEncryptor(CryptAlgorithm.Key, CryptAlgorithm.IV);
                csEncrypt = new CryptoStream(OutputStream, encryptor, CryptoStreamMode.Write);
 
                OutputStream.Write(BitConverter.GetBytes(InputStream.Length), 0, 8);
                OutputStream.Write(CryptAlgorithm.IV, 0, CryptAlgorithm.BlockSize / 8 );
                
                InputStream.Position = 0;
                byte[] DataBuffer = new byte[MaxBufferSizeValue];
 
                while (InputStream.Position < InputStream.Length)
                {
                    int DataSize = (InputStream.Length - InputStream.Position > MaxBufferSizeValue) ? MaxBufferSizeValue : (int)(InputStream.Length - InputStream.Position);
 
                    int WritedDataSize = CalculateDataSize(DataSize, MaxBufferSizeValue);
 
                    InputStream.Read(DataBuffer, 0, DataSize);
                    csEncrypt.Write(DataBuffer, 0, WritedDataSize);
                }     
            }
            finally
            {
                if (encryptor != null)
                    encryptor.Dispose();
            }
        }
 
        /// <summary>
        /// Производит дешифрование потока.
        /// </summary>
        /// <param name="input_file">Поток, который будет дешифрован.</param>
        /// <param name="output_file">Поток, в который будет записан результат дешифрования.</param>
        public void DecryptStream(Stream InputStream, Stream OutputStream, byte[] Key)
        {
            if (Disposed)
                throw new ObjectDisposedException("Object Disposed");
 
            if (InputStream == null || OutputStream == null)
                throw new ArgumentNullException("One of the arguments (or two) equals null");
 
            ICryptoTransform decryptor = null;
            CryptoStream csEncrypt = null;
 
            try
            {
                int MaxBufferSizeValue = BufferCoefficientValue * 256 * 1024;
 
                byte[] OriginFileLengthArray = new byte[8];
                byte[] IV = new byte[CryptAlgorithm.BlockSize / 8];
 
                InputStream.Read(OriginFileLengthArray, 0, 8);
                InputStream.Read(IV, 0, CryptAlgorithm.BlockSize / 8);
 
                long DeltaLength = InputStream.Length - HeadSize - CryptAlgorithm.BlockSize / 8 - BitConverter.ToInt64(OriginFileLengthArray, 0);
 
                decryptor = CryptAlgorithm.CreateDecryptor(Key, IV);
                csEncrypt = new CryptoStream(InputStream, decryptor, CryptoStreamMode.Read);
 
                byte[] DataBuffer = new byte[MaxBufferSizeValue];
 
                while (InputStream.Position < InputStream.Length)
                {
                    int DataSize = (InputStream.Length - InputStream.Position > MaxBufferSizeValue) ? MaxBufferSizeValue : (int)(InputStream.Length - InputStream.Position - DeltaLength);
 
                    csEncrypt.Read(DataBuffer, 0, DataSize);
                    OutputStream.Write(DataBuffer, 0, DataSize);
                }
            }
            finally
            {
                if (decryptor != null)
                    decryptor.Dispose();
            }
        }
        #endregion
 
        #region private methods
        private int CalculateDataSize(int DataSize, int MaxDataSize)
        {
            if (DataSize == MaxDataSize)
                return DataSize;
 
            int BlockSize = CryptAlgorithm.BlockSize / 8;
            DataSize = (int)Math.Ceiling((double)DataSize / BlockSize) * BlockSize;
 
            return DataSize;
        }
        #endregion
 
        #region IDisposable
        private bool Disposed = false;
 
        public void Dispose()
        {
            if (Disposed == true) return;
 
            DisposeManagedResources();
        }
 
        private void DisposeManagedResources()
        {
            CryptAlgorithm.Clear();
 
            Disposed = true;
        }
        #endregion
    }

            if (InputStream == null || OutputStream == null)
                throw new ArgumentNullException("One of the arguments (or two) equals null");

            if (Disposed)
                throw new ObjectDisposedException("Object Disposed");