Соединение двух потоков

using (var cs = new CryptoStream(fs, sa.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Read))
                    cs.Read(buff, 0, buff.Length);
 
using (var fsw = File.Open(fileOut, FileMode.Create, FileAccess.Write))
                {
                    fsw.Write(buff, 0, buff.Length);
                    fsw.Flush();
                }

using System;
using System.Security.Cryptography;
using System.IO;
 
namespace GeneralExperiments
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var dd = File.Open("adsfadsf", FileMode.Append);
 
            using (var cs = new CryptoStream(dd, null, CryptoStreamMode.Read))
            {
                using (var fsw = File.Open("dasdas", FileMode.Create, FileAccess.Write))
                {
                    cs.CopyTo(fsw);
                }
            }
 
            Console.WriteLine("\nDONE");
            Console.ReadKey();
        }
    }
}

                
        public void CopyTo(Stream destination)
        {
            if (destination == null)
                throw new ArgumentNullException("destination");
            if (!CanRead && !CanWrite)
                throw new ObjectDisposedException(null, Environment.GetResourceString("ObjectDisposed_StreamClosed"));
            if (!destination.CanRead && !destination.CanWrite)
                throw new ObjectDisposedException("destination", Environment.GetResourceString("ObjectDisposed_StreamClosed"));
            if (!CanRead)
                throw new NotSupportedException(Environment.GetResourceString("NotSupported_UnreadableStream"));
            if (!destination.CanWrite)
                throw new NotSupportedException(Environment.GetResourceString("NotSupported_UnwritableStream"));
            Contract.EndContractBlock();
 
            InternalCopyTo(destination, _DefaultCopyBufferSize);
        }
 
 
 
        private void InternalCopyTo(Stream destination, int bufferSize)
        {
            Contract.Requires(destination != null);
            Contract.Requires(CanRead);
            Contract.Requires(destination.CanWrite);
            Contract.Requires(bufferSize > 0);
            
            byte[] buffer = new byte[bufferSize];
            int read;
            while ((read = Read(buffer, 0, buffer.Length)) != 0)
                destination.Write(buffer, 0, read);
        }

        //We pick a value that is the largest multiple of 4096 that is still smaller than the large object heap threshold (85K).
        // The CopyTo/CopyToAsync buffer is short-lived and is likely to be collected at Gen0, and it offers a significant
        // improvement in Copy performance.
        private const int _DefaultCopyBufferSize = 81920;