// Instanz der BinaryCopiers
BinaryCopy bCopy = new BinaryCopy();

private void backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
{
      // Event des BinaryCopiers registrieren
     bCopy.BinaryCopyEvent += new BinaryCopyEventHandler(bCopy_BinaryCopyEvent);
     // Kopie der Datei starten
     bCopy.Copy(tbSource.Text, tbDestination.Text, true);
}

void bCopy_BinaryCopyEvent(object sender, BinaryCopyEventArgs e)
{
     // Auf das BinaryCopy Event reagieren und beim BGW das ProgressChanged Event auslösen und die BinaryCopyEventArgs übergeben
      backgroundWorker.ReportProgress(e.Percent, (object)e);
}

private void backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
       // EventArgs abfragen
       BinaryCopyEventArgs binaryArgs = (e.UserState as BinaryCopyEventArgs);
       // Prozessbar aktualisiern
       tsProgressBar.Value = e.ProgressPercentage;
       // Datendurchsatz in einem Label anzeigen
       tsslRate.Text = binaryArgs.KbPSec.ToString("N").Substring(0, binaryArgs.KbPSec.ToString("N").Length - 3) + " Kb/sec"; 
       // Restzeit in einem Label anzeigen
       tsslRemaning.Text = binaryArgs.Remaning.ToString();
}

 if (newFileName != string.Empty)
            {
                if (File.Exists(destination + @"\" + newFileName) && !overwrite)
                    throw new IOException("Die im Zielverzeichnis vorhandene Zieldatei kann nicht überschrieben werden");
            }
            else
            {
                if (File.Exists(destination + @"\" + srcFileInfo.Name) && !overwrite)
                    throw new IOException("Die im Zielverzeichnis vorhandene Zieldatei kann nicht überschrieben werden");
            }

            if ( newFileName != string.Empty )
            {
                if ( File.Exists( Path.Combine( destination, newFileName ) ) && !overwrite )
                    throw new IOException( "Die im Zielverzeichnis vorhandene Zieldatei kann nicht überschrieben werden" );
            }
            else
            {
                if ( File.Exists( Path.Combine( destination, srcFileInfo.Name ) )&& !overwrite )
                    throw new IOException( "Die im Zielverzeichnis vorhandene Zieldatei kann nicht überschrieben werden" );
            }

                if ( sec > 0 )
                    kbPSec = bytesReceived / sec;

                if ( sec > 0 )
                    kbPSec = 1.0 * bytesReceived / sec;

public void Copy( string source, string destination, string newFileName, bool overwrite )
{
    FileInfo srcFileInfo = new FileInfo( source );

    // Verify that the source file exists
    if ( !srcFileInfo.Exists )
        throw new IOException( "Source file does not exist" );

    // Verify that the destionation folder exists
    if ( !Directory.Exists( destination ) )
        throw new IOException( "Target directory does not exist." );

    // Verify that the given new file name does not exist ( if overwrite is forbidden )
    if ( !string.IsNullOrEmpty( newFileName ) && File.Exists( Path.Combine( destination, newFileName ) ) && !overwrite )
        throw new IOException( "The target file exists and can not be overwritten." );

    // Verify that the source file does not exist ( if overwrite is forbidden )
    if ( File.Exists( Path.Combine( destination, srcFileInfo.Name ) ) && !overwrite )
        throw new IOException( "The target file exists and can not be overwritten." );

    // Standard target file
    FileInfo currentTargetFileInfo = new FileInfo( Path.Combine( destination, srcFileInfo.Name ) );

    // Change target file to given new file name
    if ( !string.IsNullOrEmpty( newFileName ) )
        currentTargetFileInfo = new FileInfo( Path.Combine( destination, newFileName ) );

    // Creating Streams
    FileStream destStream = new FileStream( currentTargetFileInfo.FullName, FileMode.Create, FileAccess.Write );
    FileStream srcStream = new FileStream( source, FileMode.Open, FileAccess.Read );

    // Standard buffer
    byte[ ] streamBuffer = new byte[ 32768 ];

    // Increase buffer
    if ( srcFileInfo.Length < 32768 )
        streamBuffer = new byte[ srcFileInfo.Length ];


    const int offset = 0;
    int remainSec = 0;
    int remain = streamBuffer.Length;
    long iMax = srcFileInfo.Length;
    long bytesReceived = 0;
    double kbPSec = 0;

    DateTime start = DateTime.Now;

    while ( srcStream.Read( streamBuffer, offset, remain ) > 0 )
    {
        // Bufferinhalt in die Zieldatei schreiben
        destStream.Write( streamBuffer, offset, remain );

        // Prozentualen Fortschritt berechnen
        double percent = 1.0 * ( bytesReceived * 100 ) / iMax;

        // Datendurchsatz berechnen (Empfangene Bytes / verstrichene Zeit)
        bytesReceived += streamBuffer.Length;
        int sec = ( int ) Math.Round( DateTime.Now.Subtract( start ).TotalMilliseconds, MidpointRounding.AwayFromZero );

        if ( sec > 0 )
            kbPSec = 1.0 * bytesReceived / sec;

        // Restzeit des Kopiervorgangs berechnen (verbleibende Bytes / Datendurchsatz)
        if ( kbPSec > 0 )
        {
            remainSec = ( int ) Math.Round( ( ( ( ( iMax - bytesReceived ) / kbPSec ) / 1000 ) ), MidpointRounding.AwayFromZero );
        }
        TimeSpan remaning = new TimeSpan( 0, 0, remainSec );

        // Kopierevent feuern
        OnBinaryCopy( new BinaryCopyEventArgs( bytesReceived, percent, kbPSec, remaning ) );

        // StreamBuffer ggf. anpassen, um keine Nullen in die Datei zu schreiben
        if ( ( iMax - bytesReceived ) ≥ 32768 ) continue;

        streamBuffer = new byte[ iMax - bytesReceived ];
        remain = streamBuffer.Length;
    }

    destStream.Close( );
    srcStream.Close( );
}

public class BinaryCopyEventArgs : EventArgs
{
    public BinaryCopyEventArgs(long bytesReceived, double percent, double kbPSec, TimeSpan remaning)
    {
        this.BytesReceived = bytesReceived;
        this.Percent = percent;
        this.KbPSec = kbPSec;
        this.Remaning = remaning;
    }

    /// <summary>
    /// Fortschrittsangabe des Kopiervorgangs in Prozent
    /// </summary>
    public double Percent { private set; get; }

    /// <summary>
    /// Datendurchsatz des Kopiervorgangs in KB pro Sekunde
    /// </summary>
    public double KbPSec{ private set; get; }

    /// <summary>
    /// Verbleibende Zeitspanne des aktuellen Kopiervorgangs
    /// </summary>
    public TimeSpan Remaning{ private set; get; }

    /// <summary>
    /// Gets or sets the bytes received.
    /// </summary>
    /// <value>The bytes received.</value>
    public long BytesReceived { private set; get; }
}

OnFileListCopy(new FileListCopyEventArgs((runner * 100) / sourceFiles.Length, sourceFile.Name));