Работа с потоками данных

using System;
using System.IO;
using System.Text;
using System.Security.Cryptography;
    
namespace Demo1
{
    class ExecuteCryptography
    {
        // Создаем кодировщик символов
        private UTF7Encoding utf7 = new UTF7Encoding();
    
        // Объявляем ссылки на шифровальщик,
        // на массивы Key и IV (Initialization Vector) 
        private SymmetricAlgorithm codec;
        private byte[] key;
        private byte[] initVector;// IV
    
        // Конструктор
        public ExecuteCryptography(SymmetricAlgorithm codec)
        {
            this.key = codec.Key;
            this.initVector = codec.IV;
            this.codec = codec;
        }
    
        public string Encrypt(string text)
        {
            byte[] input = utf7.GetBytes(text);
            byte[] output = Transform(input,
                            codec.CreateEncryptor(key, initVector));
            return Convert.ToBase64String(output);
        }
        public string Decrypt(string text)
        {
            byte[] input = Convert.FromBase64String(text);
            byte[] output = Transform(input,
                            codec.CreateDecryptor(key, initVector));
            return utf7.GetString(output);
        }
    
        private byte[] Transform(byte[] input, ICryptoTransform cryptoTransform)
        {
            // Создаем потоки
            MemoryStream memoryStream = // Поток памяти
                new MemoryStream();
            CryptoStream cryptoStream = // Шифропоток-оболочка
                new CryptoStream(memoryStream, 
                    cryptoTransform, CryptoStreamMode.Write);
    
            // Кодируем в поток памяти через шифропоток
            cryptoStream.Write(input, 0, input.Length);
            cryptoStream.FlushFinalBlock();
    
            // Преобразуем заполненный поток памяти в массив байтов
            byte[] result = memoryStream.ToArray();
    
            // Останавливаем потоки
            memoryStream.Close();
            cryptoStream.Close();
    
            // Возвращаем кодированное/раскодированное
            return result;
        }
    
        // Перегруженные методы
        public byte[] Encrypt(byte[] input)
        {
            return Transform(input,
                   codec.CreateEncryptor(key, initVector));
        }
        public byte[] Decrypt(byte[] input)
        {
            return Transform(input,
                   codec.CreateDecryptor(key, initVector));
        }
    }
}

MemoryStream memoryStream = // Поток памяти
                new MemoryStream();
            CryptoStream cryptoStream = // Шифропоток-оболочка
                new CryptoStream(memoryStream, 
                    cryptoTransform, CryptoStreamMode.Write);
            StreamWriter streamWriter = new StreamWriter(cryptoStream);
            streamWriter.Write(txtSourceData.Text);
            streamWriter.Flush();            
            cryptoStream.FlushFinalBlock();

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
    
// Дополнительные пространства имен
using System.Security.Cryptography;
using System.IO;
    
namespace Demo1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
    
            // Подписываемся на событие Click кнопки
            btnExecute.Click += btnExecute_Click;
        }
           
        // Обработчик кнопки 
        private void btnExecute_Click(object sender, EventArgs e)
        {
            // Создаем объект симметричного шифрования
            SymmetricAlgorithm codec = null;// Тип общего предка 
            switch (SelectedRadio().Trim())
            {
                case "DES":
                    codec = new DESCryptoServiceProvider();
                    break;
                case "RC2":
                    codec = new RC2CryptoServiceProvider();
                    break;
                case "Rijndael":
                    codec = new RijndaelManaged();
                    break;
                case "TripleDES":
                    codec = new TripleDESCryptoServiceProvider();
                    break;
                case "SymmetricAlgorithm":
                    codec = SymmetricAlgorithm.Create();
                    break;
                default:
                    MessageBox.Show("Выделите провайдер шифрования");
                    return;
            }
    
            // Создаем экземпляр нашего класса
            // и передаем ему выбранный шифровальшик
            ExecuteCryptography executeCryptography =
                new ExecuteCryptography(codec);
    
            // Шифруем текст
            string sourceData = txtSourceData.Text;
            string encryptedData = executeCryptography.Encrypt(sourceData);
            txtEncryptedData.Text = encryptedData;
    
            // Расшифровываем текст
            string decryptedData = executeCryptography.Decrypt(encryptedData);
            txtDecryptedData.Text = decryptedData;
    
            //////////////////////////////////////////////////
            // Показываем характеристики алгоритма шифрования
            //////////////////////////////////////////////////
            {
                txtKey.Text = Encoding.UTF7.GetString(codec.Key);// Key
                txtIV.Text = Encoding.UTF7.GetString(codec.IV);// Initialization Vector
    
                txtKeySize.Text = codec.KeySize.ToString();// KeySize
                StringBuilder sb = new StringBuilder();
                foreach (KeySizes sizes in codec.LegalKeySizes)
                {
                    sb.Append(sizes.MinSize.ToString() + "-" +
                        sizes.MaxSize.ToString() + 
                        " (" + sizes.SkipSize.ToString() + ") ");
                }
                txtLegalKeySizes.Text = sb.ToString();// LegalKeySizes
    
                txtBlockSize.Text = codec.BlockSize.ToString();// BlockSize
                sb = new StringBuilder();
                foreach (KeySizes sizes in codec.LegalBlockSizes)
                {
                    sb.Append(sizes.MinSize.ToString() + "-" +
                        sizes.MaxSize.ToString() + 
                        " (" + sizes.SkipSize.ToString() + ") ");
                }
                txtLegalBlockSizes.Text = sb.ToString();// LegalBlockSizes
            }
        }
    
        // Динамически ищем включенный RadioButton
        string SelectedRadio()
        {
            string tag = "";
            foreach (Control ctrl in groupBox1.Controls)
            {
                RadioButton radio = ctrl as RadioButton;// Приводим ссылку
                if (radio.Checked)
                {
                    tag = (String)radio.Tag;// Приводим ссылку
                    break;
                }
            }
    
            return tag;
        }
    
        // Блокировка редактирования всех целевых TextBox
        private void txtTarget_KeyDown(object sender, KeyEventArgs e)

        {
            e.Handled = true;
        }
        private void txtTarget_KeyPress(object sender, KeyPressEventArgs e)
        {
            e.Handled = true;
        }
    }
}