C#

public static class FTPQueue
{
    /// <summary>
    /// The maximum number of concurrent file uploads
    /// </summary>
    private const int MAX_FILE_UPLOADS = 3;
    /// <summary>
    /// The number of files being currently uploaded
    /// </summary>
    private static int _filesBeingUploaded = 0;
    /// <summary>
    /// Maintains a FIFO list of files to be uploaded
    /// </summary>
    private static Queue _fileQueue = new Queue();
    /// <summary>
    /// Maintains a list of the names of the files currently being
    /// uploaded. This prevents the process from attempting to upload
    /// the same multiple times
    /// </summary>
    private static List<string> _filesInProgress = new List<string>();
    /// <summary>
    /// Called from the FileSystemWatcher when file(s) are received in the ap's target folder
    /// </summary>
    /// <param name="fileName">Name of the received file.</param>
    public static void FileReceived(string fileName)
    {
        Console.WriteLine("Received file {0}", fileName);

        // Add the file recieved to the queue of files
        _fileQueue.Enqueue(fileName);

        UploadNextFile();
    }
    /// <summary>
    /// Uploads the next file.
    /// </summary>
    private static async void UploadNextFile()
    {
        // Get the next file from the list
        if (_fileQueue.Count == 0)
        {
            return;
        }
        string fileName = (string)_fileQueue.Peek();

        if (!string.IsNullOrEmpty(fileName))
        {
            // If we've reached the max number of uploads tyhen return
            if (_filesBeingUploaded >= MAX_FILE_UPLOADS)
            {
                return;
            }

            // See if the file is a already being transferred, and if so, exit
            if (_filesInProgress.Any(x => x == fileName))
            {
                return;
            }

            // Keep track of the number of files being uploaded
            _filesBeingUploaded++;
            Console.WriteLine("Files being uploaded {0}", _filesBeingUploaded);

            // Create the upload task
            Task<bool> upload = TransferFile(fileName);

            // Wait for the file upload to complete
            bool result = await upload;

            // Call the completed method
            Console.WriteLine("Files {0} upload complete", _filesBeingUploaded);

            FileUploadComplete(fileName, result);
        }
    }
    /// <summary>
    /// Performs a file transfer operation
    /// </summary>
    /// <param name="fileName">Name of the file to transfer.</param>
    /// <returns></returns>
    private static async Task<bool> TransferFile(string fileName)
    {
        Console.WriteLine("Tranfering file {0}", fileName);

        // 10 second delay to simulate a long running FTP operation
        await Task.Delay(10000);

        // Set return value from FTP process
        bool result = true;

        return result;
    }
    /// <summary>
    /// Called when a file upload is complete.
    /// </summary>
    /// <param name="fileName">Name of the file uploaded.</param>
    /// <param name="result">True if the file upload was sucesseful, otherwise false.</param>
    private static void FileUploadComplete(string fileName, bool result)
    {
        // If the file was FTP'd ok, the remove it from the list
        if (result)
        {
            Console.WriteLine(string.Format("File {0} upload complete", fileName));

            if (_fileQueue.Count > 0)
            {
                // Remove the file name from the queue and InProgress list
                Console.WriteLine("Removing file {0} from the queue", fileName);

                _fileQueue.Dequeue();
                _filesInProgress.Remove(fileName);
            }

            // Decrement the number of files being uploaded
            _filesBeingUploaded--;
            Console.WriteLine("Files being uploaded {0}", _filesBeingUploaded);
        }
        else
        {
            Console.WriteLine(string.Format("File {0} upload failed", fileName));
        }

        // Start the next file
        UploadNextFile();
    }
}

class Program
{
    private static Timer _timer;

    static void Main(string[] args)
    {
        _timer = new Timer();
        _timer.Interval = 3000;
        _timer.Elapsed += _timer_Elapsed;
        _timer.Enabled = true;

        Console.ReadLine();
    }

    // The timer creates a dummy file to mock a file being dropped into the target folder. In
    // the real app a FileSystemWatcher would handle this
    private static void _timer_Elapsed(object sender, ElapsedEventArgs e)
    {
        var fileName = Path.GetRandomFileName();
        Console.WriteLine("Created new file {0}", fileName);

        FTPQueue.FileReceived(fileName);
    }
}