' Split File
    ' By Elektro
    '
    ' Example Usage:
    ' SplitFile(InputFile:="C:\Test.mp3", ChunkSize:=(1024L ^ 2L), ChunkName:="Test.Part", ChunkExt:="mp3", Overwrite:=True)
 
    ''' <summary>
    ''' Splits a file into chunks.
    ''' </summary>
    ''' <param name="InputFile">
    ''' Indicates the input file to split.
    ''' </param>
    ''' <param name="ChunkSize">
    ''' Indicates the size of each chunk.
    ''' </param>
    ''' <param name="ChunkName">
    ''' Indicates the chunk filename format.
    ''' Default format is: 'FileName.ChunkIndex.FileExt'
    ''' </param>
    ''' <param name="ChunkExt">
    ''' Indicates the chunk file-extension.
    ''' If this value is <c>Null</c>, the input file-extension will be used.
    ''' </param>
    ''' <param name="Overwrite">
    ''' If set to <c>true</c>, chunk files will replace any existing file;
    ''' Otherwise, an exception will be thrown.
    ''' </param>
    ''' <exception cref="System.OverflowException">'ChunkSize' should be smaller than the Filesize.</exception>
    ''' <exception cref="System.IO.IOException"></exception>
    Public Sub SplitFile(ByVal InputFile As String,
                         ByVal ChunkSize As Long,
                         Optional ByVal ChunkName As String = Nothing,
                         Optional ByVal ChunkExt As String = Nothing,
                         Optional ByVal Overwrite As Boolean = False)
 
        ' FileInfo instance of the input file.
        Dim fInfo As New IO.FileInfo(InputFile)
 
        ' The buffer to read data and write the chunks.
        Dim Buffer As Byte() = New Byte() {}
 
        ' The buffer length.
        Dim BufferSize As Integer = 1048576 ' 1048576 = 1 mb | 33554432 = 32 mb | 67108864 = 64 mb
 
        ' Counts the length of the current chunk file.
        Dim BytesWritten As Long = 0L
 
        ' The total amount of chunks to create.
        Dim ChunkCount As Integer = CInt(Math.Floor(fInfo.Length / ChunkSize))
 
        ' Keeps track of the current chunk.
        Dim ChunkIndex As Integer = 0I
 
        ' A zero-filled string to enumerate the chunk files.
        Dim Zeros As String = String.Empty
 
        ' The given filename for each chunk.
        Dim ChunkFile As String = String.Empty
 
        ' The chunk file basename.
        ChunkName = If(String.IsNullOrEmpty(ChunkName),
                       IO.Path.Combine(fInfo.DirectoryName, IO.Path.GetFileNameWithoutExtension(fInfo.Name)),
                       IO.Path.Combine(fInfo.DirectoryName, ChunkName))
 
        ' The chunk file extension.
        ChunkExt = If(String.IsNullOrEmpty(ChunkExt),
                      fInfo.Extension.Substring(1I),
                      ChunkExt)
 
        ' If ChunkSize is bigger than filesize then...
        If ChunkSize >= fInfo.Length Then
            Throw New OverflowException("'ChunkSize' should be smaller than the Filesize.")
            Exit Sub
 
            ' For cases where a chunksize is smaller than the buffersize.
        ElseIf ChunkSize < BufferSize Then
            BufferSize = CInt(ChunkSize)
 
        End If ' ChunkSize <>...
 
        ' If not file-overwrite is allowed then...
        If Not Overwrite Then
 
            For Index As Integer = 0I To (ChunkCount)
 
                ' Set chunk filename.
                Zeros = New String("0", CStr(ChunkCount).Length - CStr(Index + 1I).Length)
                ChunkFile = String.Format("{0}.{1}.{2}", ChunkName, Zeros & CStr(Index + 1I), ChunkExt)
 
                ' If chunk file already exists then...
                If IO.File.Exists(ChunkFile) Then
 
                    Throw New IO.IOException(String.Format("File already exist: {0}", ChunkFile))
                    Exit Sub
 
                End If ' IO.File.Exists(ChunkFile)
 
            Next Index
 
            Zeros = String.Empty
            ChunkFile = String.Empty
 
        End If ' Overwrite
 
        ' Open the file to start reading bytes.
        Using InputStream As New IO.FileStream(fInfo.FullName, IO.FileMode.Open)
 
            Using BinaryReader As New IO.BinaryReader(InputStream)
 
                While (InputStream.Position < InputStream.Length)
 
                    ' Set chunk filename.
                    Zeros = New String("0", CStr(ChunkCount).Length - CStr(ChunkIndex + 1I).Length)
                    ChunkFile = String.Format("{0}.{1}.{2}", ChunkName, Zeros & CStr(ChunkIndex + 1I), ChunkExt)
 
                    ' Reset written byte-length counter.
                    BytesWritten = 0L
 
                    ' Create the chunk file to Write the bytes.
                    Using OutputStream As New IO.FileStream(ChunkFile, IO.FileMode.Create)
 
                        Using BinaryWriter As New IO.BinaryWriter(OutputStream)
 
                            ' Read until reached the end-bytes of the input file.
                            While (BytesWritten < ChunkSize) AndAlso (InputStream.Position < InputStream.Length)
 
                                ' Read bytes from the original file (BufferSize byte-length).
                                Buffer = BinaryReader.ReadBytes(BufferSize)
 
                                ' Write those bytes in the chunk file.
                                BinaryWriter.Write(Buffer)
 
                                ' Increment the size counter.
                                BytesWritten += Buffer.Count
 
                            End While ' (BytesWritten < ChunkSize) AndAlso (InputStream.Position < InputStream.Length)
 
                            OutputStream.Flush()
 
                        End Using ' BinaryWriter
 
                    End Using ' OutputStream
 
                    ChunkIndex += 1I 'Increment file counter
 
                End While ' InputStream.Position < InputStream.Length
 
            End Using ' BinaryReader
 
        End Using ' InputStream
 
    End Sub