Why some files result in 0KB when using WebClient.DownloadFileTaskAsync

I am trying to download multiple files from an FTP server using WebClient.DownloadFileTaskAsync and am repeatedly faced with the problem that multiple files end up being 0KB.

I tried different suggested solutions but I just can't get all the files. What am I doing wrong?

class Program
{
    static void Main()
    {
        Setup(); // This only sets up working folders etc

        Task t = ProcessAsync();
        t.ContinueWith(bl =>
        {
            if (bl.Status == TaskStatus.RanToCompletion)
                Logger.Info("All done.");
            else
                Logger.Warn("Something went wrong.");
        });
        t.Wait();
    }

    private static void Setup() {...}

    static async Task<bool> ProcessAsync()
    {
        var c = new Catalog();

        var maxItems = Settings.GetInt("maxItems");
        Logger.Info((maxItems == 0 ? "Processing all items" : "Processing first {0} items"), maxItems);

        await c.ProcessCatalogAsync(maxItems);
        return true; // This is not really used atm
    }
}

public class Catalog
{
    public async Task ProcessCatalogAsync(int maxItems)
    {
        var client = new Client();
        var d = await client.GetFoldersAsync(_remoteFolder, maxItems);
        var list = d as IList<string> ?? d.ToList();
        Logger.Info("Found {0} folders", list.Count());

        await ProcessFoldersAsync(list);
    }

    private async Task ProcessFoldersAsync(IEnumerable<string> list)
    {
        var client = new Client();
        foreach (var mFolder in list.Select(folder => _folder + "/" + folder))
        {
            var items = await client.GetItemsAsync(mFolder);
            var file = items.FirstOrDefault(n => n.ToLower().EndsWith(".xml"));

            if (string.IsNullOrEmpty(file))
            {
                Logger.Warn("No metadata file found in {0}", mFolder);
                continue;
            }

            await client.DownloadFileAsync(mFolder, file);

            // Continue processing the received file...
        }
    }
}

public class Client
{
    public async Task<IEnumerable<string>> GetItemsAsync(string subfolder)
    {
        return await GetFolderItemsAsync(subfolder, false);
    }

    public async Task<IEnumerable<string>> GetFoldersAsync(string subfolder, int maxItems)
    {
        var folders = await GetFolderItemsAsync(subfolder, true);
        return maxItems == 0 ? folders : folders.Take(maxItems);
    }

    private async Task<IEnumerable<string>> GetFolderItemsAsync(string subfolder, bool onlyFolders)
    {
        // Downloads folder contents using WebRequest
    }

    public async Task DownloadFileAsync(string path, string file)
    {
        var remote = new Uri("ftp://" + _hostname + path + "/" + file);
        var local = _workingFolder + @"\" + file;
        using (var ftpClient = new WebClient { Credentials = new NetworkCredential(_username, _password) })
        {
            ftpClient.DownloadFileCompleted += (sender, e) => DownloadFileCompleted(sender, e, file);
            await ftpClient.DownloadFileTaskAsync(remote, local);
        }
    }

    public void DownloadFileCompleted(object sender, AsyncCompletedEventArgs e, Uri remote, string local)
    {
        if (e.Error != null)
        {
            Logger.Warn("Failed downloading\n\t{0}\n\t{1}", file, e.Error.Message);
            return;
        }
        Logger.Info("Downloaded \n\t{1}", file);
    }
}