Unless you can take advantage of multiple network connections by
downloading the pieces over those different network connections,
splitting them up isn't going to help at all.

Assuming you've saved all of the data and assuming you've reassembled
the pieces in the same order they were in the original data, it should
work.  However, before you spend any more time on this, I would
recommend you take advantage of the fact that you at least have now
multiple pieces of the original data.  Confirm, at least, that the
total size of the pieces is the same as the size of the original data
before splitting, and then compare download times for all of the
pieces with the download time for the original unsplit data.

Assuming you are like most of us and have a single network connection,
you will find no appreciable difference in download time.

Pete

What I would probably do here is to use either Winzip or WinRar with a batch
file (they have DOS companions that accept batch comands) with "Store only" -
no-compression for speed, to split up the files. This .bat or .cmd file can
be run on a scheduled basis through Task Scheduler.
-- Peter
Recursion: see Recursion
site:  http://www.eggheadcafe.com
unBlog:  http://petesbloggerama.blogspot.com
BlogMetaFinder:    http://www.blogmetafinder.com

BTW, this is my code, maybe i did something wrong:

//Note: this.ext is a string property which represents the file's
extension.
/
****************************************************************************
                               splitFile procedure
****************************************************************************/
private void splitFile( string path, string path_parts, long
size_part )
        {
            long parts=0;

            try
            {
                using ( FileStream fs = new FileStream( path, FileMode.Open ) )
                {

                    flength = fs.Length;

                    parts = fs.Length / long.Parse( size_part.ToString() );

                    if ( parts > 0 )
                    {
                        for ( int i = 0; i < parts; i++ )
                        {
                            string filename= Path.Combine( path_parts, "spfile" +
i.ToString() + this.ext );

                            using ( FileStream fsOut = new FileStream( filename,
FileMode.Create ) )
                            {
                                byte[] arrBytes = new byte[ flength ];

                                int offSet = ( int ) (size_part * i ) + ( ( i>0 ) ? 1 : 0 );
                                int count = ( int ) size_part;

                                int ret = fs.Read( arrBytes, offSet, count );

                                fsOut.Write( arrBytes, offSet, count );

                                arrBytes = null;
                            }
                        }
                    }
                }
            }
            catch            {
                throw;
            }
                               }

/
****************************************************************************
                               buildFile procedure
****************************************************************************/
private void buildFile( string path_parts, long size_part, long
flength, string path_out )
        {
            try
            {
                byte[] arrBytes=null;

                string filename_out= Path.Combine( path_out, "spfile_out" +
this.ext );

                long parts = ( size_part != 0 ) ? flength /
long.Parse( size_part.ToString() ) : 0;

                byte[] arrBytes_out= new byte[ flength ];

                for ( int i = 0; i < parts; i++ )
                {
                    string filename= Path.Combine( path_parts, "spfile" +
i.ToString() + this.ext );

                    using ( FileStream fs = new FileStream( filename,
FileMode.Open ) )
                    {
                        arrBytes = new byte[ size_part ];//fs.Length

                        int ret = fs.Read( arrBytes, 0, Convert.ToInt32( size_part ) );//
fs.Length

                        arrBytes.CopyTo( arrBytes_out, i * size_part );
                    }
                }

                using ( FileStream fsOut = new FileStream( filename_out,
FileMode.Create ) )
                    fsOut.Write( arrBytes_out, 0, Convert.ToInt32( flength ) );
            }
            catch( Exception ex )
            {
                throw;
            }
        }