This topic shows you how to use multiple threads to connect to an FTP server and download a file. First, we need to define a class which contains information about the file, and the threads. In this example, it’s named GlobalInfo. And then we define a class for Ftp Threads, it’s named FtpThread. Finally, in the main routine, we create and start 3 threads to download the parts of the file. As a result, the download speed is improved if the file is large. We take advantage of the GetDownloadStream method with the following example code:

C#:

// Example Description : Shows how to use GetDownloadStream method to download multiple parts of a remote file using 3 threads.
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using ComponentPro.Net;
using System.Threading;

namespace Samples
{
    // Main Code
    class GlobalInfo
    {
        // Maintain some information about the threads.
        public int CompletedThreads;
        public int Threads;
        public ManualResetEvent Event;
        public byte[][] Streams;
        public long Length = -1;
        public int BlockSize;
        public bool Finish;
    }

    class FtpThread
    {
        int _offset;
        int _blockSize;
        GlobalInfo _info;
        Ftp _client;
        int _index;
        
        public FtpThread(GlobalInfo info, int index)
        {
            _info = info;
            _index = index;
        }

        public void Start()
        {
            const string remoteFile = "/pub/test.zip";
            _client = new Ftp();
            _client.Connect("demo.componentpro.com");
            _client.Authenticate("test", "test");

            byte[] buf;

            lock (_info)
            {
                if (_info.Length == -1)
                {
                    // Get file length.
                    _info.Length = _client.GetFileLength(remoteFile);
                    // Calculate block size.
                    _info.BlockSize = (int)(_info.Length / _info.Threads);
                    _info.Streams = new byte[_info.Threads][];
                }

                // Calculate offset.
                _offset = _info.BlockSize * _index;
                _blockSize = (int)((_index == _info.Threads - 1) ? (_info.Length - _index * _info.BlockSize) : _info.BlockSize);

                buf = new byte[_blockSize];
                _info.Streams[_index] = buf;            
            }

            // Get download stream.
            Stream downloader = _client.GetDownloadStream(remoteFile, SeekOrigin.Begin, _offset);
            int count = 0;
            // Download data.
            while (true)
            {
                int size = (count + 4048 > _blockSize) ? (_blockSize - count) : 4048;
                int read = downloader.Read(buf, count, size);
                if (count + read >= _blockSize || read == 0)
                    break;
                count += read;
            } 
            downloader.Close();            

            _client.Disconnect();

            lock (_info)
            {
                _info.CompletedThreads++;
                if (_info.CompletedThreads == _info.Threads && !_info.Finish)
                {
                    _info.Event.Set();
                    // All threads have completed.

                    // Combine
                    using (FileStream sw = System.IO.File.OpenWrite(@"c:\temp\test.zip"))
                    {
                        foreach (byte[] s in _info.Streams)
                        {
                            sw.Write(s, 0, (int)s.Length);
                        }
                    }

                    _info.Finish = true;
                }
            }
        }
    }

    class MultiParts
    {
        static ManualResetEvent _event = new ManualResetEvent(false);
        static Ftp client;

        static void Main()
        {
            const int threads = 3;

            // Use 3 threads to download a remote file to streams and then save the streams into a local file.
            int offset = 0;
            
            GlobalInfo ginfo = new GlobalInfo();
            ginfo.Threads = threads;
            ginfo.Event = _event;

            for (int i = 0; i < threads; i++)
            {
                FtpThread fthread = new FtpThread(ginfo, i);
                Thread th = new Thread(fthread.Start);
                th.Start();
            }
            _event.WaitOne();
        }
    }
    // End Main Code
}

VB.NET:

' Example Description : Shows how to use GetDownloadStream method to download multiple parts of a remote file using 3 threads.

' Imports Microsoft.VisualBasic
Imports System
Imports System.Collections.Generic
Imports System.Text
Imports System.IO
Imports ComponentPro.Net
Imports System.Threading

Namespace Samples
	' Main Code
	Friend Class GlobalInfo
		' Maintain some information about the threads.
		Public CompletedThreads As Integer
		Public Threads As Integer
		Public [Event] As ManualResetEvent
		Public Streams()() As Byte
		Public Length As Long = -1
		Public BlockSize As Integer
		Public Finish As Boolean
	End Class

	Friend Class FtpThread
		Private _offset As Integer
		Private _blockSize As Integer
		Private _info As GlobalInfo
		Private _client As Ftp
		Private _index As Integer

		Public Sub New(ByVal info As GlobalInfo, ByVal index As Integer)
			_info = info
			_index = index
		End Sub

		Public Sub Start()
			Const remoteFile As String = "/pub/test.zip"
			_client = New Ftp()
            _client.Connect("demo.componentpro.com")
			_client.Authenticate("test", "test")

			Dim buf() As Byte

			SyncLock _info
				If _info.Length = -1 Then
					' Get file length.
					_info.Length = _client.GetFileLength(remoteFile)
					' Calculate block size.
					_info.BlockSize = CInt(Fix(_info.Length \ _info.Threads))
					_info.Streams = New Byte(_info.Threads - 1)(){}
				End If

				' Calculate offset.
				_offset = _info.BlockSize * _index
                If (_index = _info.Threads - 1) Then
                    _blockSize = CInt(Fix(_info.Length - _index * _info.BlockSize))
                Else
                    _blockSize = CInt(Fix(_info.BlockSize))
                End If

				buf = New Byte(_blockSize - 1){}
				_info.Streams(_index) = buf
			End SyncLock

			' Get download stream.
			Dim downloader As Stream = _client.GetDownloadStream(remoteFile, SeekOrigin.Begin, _offset)
			Dim count As Integer = 0
			' Download data.
			Do
				Dim size As Integer
				If (count + 4048 > _blockSize) Then
					size = _blockSize - count
				Else
					size = 4048
				End If
				Dim read As Integer = downloader.Read(buf, count, size)
				If count + read >= _blockSize OrElse read = 0 Then
					Exit Do
				End If
				count += read
			Loop
			downloader.Close()

			_client.Disconnect()

			SyncLock _info
				_info.CompletedThreads += 1
                If _info.CompletedThreads = _info.Threads AndAlso (Not _info.Finish) Then
                    _info.Event.Set()
                    ' All threads have completed.

                    ' Combine
                    Using sw As FileStream = System.IO.File.OpenWrite("c:\temp\test.zip")
                        For Each s As Byte() In _info.Streams
                            sw.Write(s, 0, CInt(Fix(s.Length)))
                        Next s
                    End Using

                    _info.Finish = True
                End If
			End SyncLock
		End Sub
	End Class

	Friend Class MultiParts
		Private Shared _event As New ManualResetEvent(False)
		Private Shared client As Ftp

		Shared Sub Main()
			Const threads As Integer = 3

			' Use 3 threads to download a remote file to streams and then save the streams into a local file.
			Dim offset As Integer = 0

			Dim ginfo As New GlobalInfo()
			ginfo.Threads = threads
			ginfo.Event = _event

			For i As Integer = 0 To threads - 1
				Dim fthread As New FtpThread(ginfo, i)
                Dim th As New Thread(AddressOf fthread.Start)
				th.Start()
			Next i
			_event.WaitOne()
		End Sub
	End Class
	' End Main Code
End Namespace

Click here to download the Ultimate FTP Component for .NET, or here to download the .NET CF version.