InterceptionStream

FileCopy.cs

using (var inputStream = File.OpenRead(@"TestFiles/Example.txt"))
using (var outputStream = File.OpenWrite(@"TestFiles/Output.txt"))
{
    inputStream.CopyTo(outputStream);
}

FileCopyWithLog.cs

using (var logStream = File.OpenWrite(@"TestFiles/Log.txt"))
using (var inputStream = File.OpenRead(@"TestFiles/Example.txt"))
using (var outputStream = new InterceptionStream(File.OpenWrite(@"TestFiles/Output.txt"), logStream))
{
    inputStream.CopyTo(outputStream);
}

FileCopyWithLogOnInput.cs

using (var logStream = File.OpenWrite(@"TestFiles/Log.txt"))
using (var inputStream = new InterceptionStream(File.OpenRead(@"TestFiles/Example.txt"), logStream))
using (var outputStream = File.OpenWrite(@"TestFiles/Output.txt"))
{
    inputStream.CopyTo(outputStream);
}

FileCopyWithLogToString.cs

using (var logStream = new MemoryStream())
using (var inputStream = new InterceptionStream(File.OpenRead(@"TestFiles/Example.txt"), logStream))
using (var outputStream = File.OpenWrite(@"TestFiles/Output.txt"))
{
    inputStream.CopyTo(outputStream);

    var logText = Encoding.UTF8.GetString(logStream.GetBuffer());

    Console.Out.WriteLine(logText);
}

InterceptionStream.cs

public class InterceptionStream : Stream
{
    public Stream InnerStream { get; private set; }
    public Stream CopyStream { get; private set; }

    public InterceptionStream(Stream innerStream, Stream copyStream)
    {
        if (innerStream == null) throw new ArgumentNullException("innerStream");
        if (copyStream == null) throw new ArgumentNullException("copyStream");

        if (!copyStream.CanWrite)
        {
            throw new ArgumentException("copyStream is not writable");
        }

        InnerStream = innerStream;
        CopyStream = copyStream;
    }

    public override void Flush()
    {
        InnerStream.Flush();
    }

    public override long Seek(long offset, SeekOrigin origin)
    {
        return InnerStream.Seek(offset, origin);
    }

    public override void SetLength(long value)
    {
        InnerStream.SetLength(value);
    }

    public override int Read(byte[] buffer, int offset, int count)
    {
        var bytesRead = InnerStream.Read(buffer, offset, count);

        if (bytesRead != 0)
        {
            CopyStream.Write(buffer, offset, bytesRead);
        }
        return bytesRead;
    }

    public override void Write(byte[] buffer, int offset, int count)
    {
        InnerStream.Write(buffer, offset, count);
        CopyStream.Write(buffer, offset, count);
    }

    public override bool CanRead
    {
        get { return InnerStream.CanRead; }
    }

    public override bool CanSeek
    {
        get { return InnerStream.CanSeek; }
    }

    public override bool CanWrite
    {
        get { return InnerStream.CanWrite; }
    }

    public override long Length
    {
        get { return InnerStream.Length; }
    }

    public override long Position
    {
        get { return InnerStream.Position; }
        set { InnerStream.Position = value; }
    }

    protected override void Dispose(bool disposing)
    {
        InnerStream.Dispose();
    }
}