【问题标题】:Asynchronously and parallelly downloading files异步和并行下载文件
【发布时间】:2013-10-11 22:15:10
【问题描述】:

编辑

我已经更改了问题的标题,以反映我遇到的问题,以及如何轻松实现这一目标的答案。


我正在尝试使第二种方法返回Task<TResult> 而不是第一种方法中的Task,但是由于尝试修复它,我遇到了一系列错误。

  • 我在await body(partition.Current); 之前添加了return
  • 反过来,它要求我在下面添加一个退货声明,所以我在下面添加了return null
  • 但现在 select 语句抱怨它无法从查询中推断类型参数
  • 我将Task.Run 更改为Task.Run<TResult>,但没有成功。

我该如何解决?

第一种方法来自http://blogs.msdn.com/b/pfxteam/archive/2012/03/05/10278165.aspx,第二种方法是我正在尝试创建的重载。

public static class Extensions
{
    public static Task ForEachAsync<T>(this IEnumerable<T> source, int dop, Func<T, Task> body)
    {
        return Task.WhenAll(
            from partition in Partitioner.Create(source).GetPartitions(dop)
            select Task.Run(async delegate
            {
                using (partition)
                    while (partition.MoveNext())
                        await body(partition.Current);
            }));
    }

    public static Task ForEachAsync<T, TResult>(this IEnumerable<T> source, int dop, Func<T, Task<TResult>> body)
    {
        return Task.WhenAll(
            from partition in Partitioner.Create(source).GetPartitions(dop)
            select Task.Run(async delegate
            {
                using (partition)
                    while (partition.MoveNext())
                        await body(partition.Current);
            }));
    }
}

使用示例:

通过这种方法,我想并行和异步下载多个文件:

private async void MainWindow_Loaded(object sender, RoutedEventArgs e)
{
    Artist artist = await GetArtist();
    IEnumerable<string> enumerable = artist.Reviews.Select(s => s.ImageUrl);
    string[] downloadFile = await DownloadFiles(enumerable);
}

public static async Task<string[]> DownloadFiles(IEnumerable<string> enumerable)
{
    if (enumerable == null) throw new ArgumentNullException("enumerable");
    await enumerable.ForEachAsync(5, s => DownloadFile(s));
    // Incomplete, the above statement is void and can't be returned
}

public static async Task<string> DownloadFile(string address)
{
    /* Download a file from specified address, 
        * return destination file name on success or null on failure */

    if (address == null)
    {
        return null;
    }

    Uri result;
    if (!Uri.TryCreate(address, UriKind.Absolute, out result))
    {
        Debug.WriteLine(string.Format("Couldn't create URI from specified address: {0}", address));
        return null;
    }

    try
    {
        using (var client = new WebClient())
        {
            string fileName = Path.GetTempFileName();
            await client.DownloadFileTaskAsync(address, fileName);
            Debug.WriteLine(string.Format("Downloaded file saved to: {0} ({1})", fileName, address));
            return fileName;
        }
    }
    catch (WebException webException)
    {
        Debug.WriteLine(string.Format("Couldn't download file from specified address: {0}", webException.Message));
        return null;
    }
}

【问题讨论】:

  • 完全不清楚您期望的结果是什么。您正在传递整个T 值序列,并对它们执行相同的函数 - 您希望从返回的Task&lt;TResult&gt; 中得到什么结果?
  • 在这种情况下我想获得一个任务,我在我的问题上添加了一个示例。
  • “使用这种方法我想并行异步下载多个文件” : Parallel.Foreach 还不够吗?
  • @Aybe,在你的情况下你希望它是一个Task&lt;IEnumerable&lt;string&gt;&gt;,或者如果你真的想要Task&lt;string&gt;,你会返回什么字符串?
  • @Aybe 我想你还是不明白。假设您正在下载两个页面,一个包含foo,另一个包含bar。如果您的ForEachAsync() 要返回Task&lt;string&gt;,您希望它包含什么字符串?鉴于您的代码,如果它返回 Task&lt;string[]&gt; 会更有意义。

标签: c# foreach task async-await


【解决方案1】:

我解决了它并在此处发布,可能会对遇到相同问题的任何人有所帮助。

我最初需要一个小帮手,它可以快速下载图像,但如果服务器没有快速响应,也可以断开连接,所有这些并行和异步

此帮助器将返回一个元组,其中包含远程路径、本地路径以及发生异常时的异常;非常有用,因为知道错误下载的原因总是很好。我想我没有忘记下载可能发生的任何情况,但欢迎您发表评论。

  • 您指定要下载的网址列表
  • 您可以指定一个本地文件名来保存它,如果没有,将为您生成一个
  • (可选)取消下载的持续时间(适用于速度较慢或无法访问的服务器)

您可以只使用DownloadFileTaskAsync 本身或使用ForEachAsync 帮助程序进行并行和异步下载。

代码以及如何使用它的示例:

private async void MainWindow_Loaded(object sender, RoutedEventArgs e)
{
    IEnumerable<string> enumerable = your urls here;
    var results = new List<Tuple<string, string, Exception>>();
    await enumerable.ForEachAsync(s => DownloadFileTaskAsync(s, null, 1000), (url, t) => results.Add(t));
}

/// <summary>
///     Downloads a file from a specified Internet address.
/// </summary>
/// <param name="remotePath">Internet address of the file to download.</param>
/// <param name="localPath">
///     Local file name where to store the content of the download, if null a temporary file name will
///     be generated.
/// </param>
/// <param name="timeOut">Duration in miliseconds before cancelling the  operation.</param>
/// <returns>A tuple containing the remote path, the local path and an exception if one occurred.</returns>
private static async Task<Tuple<string, string, Exception>> DownloadFileTaskAsync(string remotePath,
    string localPath = null, int timeOut = 3000)
{
    try
    {
        if (remotePath == null)
        {
            Debug.WriteLine("DownloadFileTaskAsync (null remote path): skipping");
            throw new ArgumentNullException("remotePath");
        }

        if (localPath == null)
        {
            Debug.WriteLine(
                string.Format(
                    "DownloadFileTaskAsync (null local path): generating a temporary file name for {0}",
                    remotePath));
            localPath = Path.GetTempFileName();
        }

        using (var client = new WebClient())
        {
            TimerCallback timerCallback = c =>
            {
                var webClient = (WebClient) c;
                if (!webClient.IsBusy) return;
                webClient.CancelAsync();
                Debug.WriteLine(string.Format("DownloadFileTaskAsync (time out due): {0}", remotePath));
            };
            using (var timer = new Timer(timerCallback, client, timeOut, Timeout.Infinite))
            {
                await client.DownloadFileTaskAsync(remotePath, localPath);
            }
            Debug.WriteLine(string.Format("DownloadFileTaskAsync (downloaded): {0}", remotePath));
            return new Tuple<string, string, Exception>(remotePath, localPath, null);
        }
    }
    catch (Exception ex)
    {
        return new Tuple<string, string, Exception>(remotePath, null, ex);
    }
}

public static class Extensions
{
    public static Task ForEachAsync<TSource, TResult>(
        this IEnumerable<TSource> source,
        Func<TSource, Task<TResult>> taskSelector, Action<TSource, TResult> resultProcessor)
    {
        var oneAtATime = new SemaphoreSlim(5, 10);
        return Task.WhenAll(
            from item in source
            select ProcessAsync(item, taskSelector, resultProcessor, oneAtATime));
    }

    private static async Task ProcessAsync<TSource, TResult>(
        TSource item,
        Func<TSource, Task<TResult>> taskSelector, Action<TSource, TResult> resultProcessor,
        SemaphoreSlim oneAtATime)
    {
        TResult result = await taskSelector(item);
        await oneAtATime.WaitAsync();
        try
        {
            resultProcessor(item, result);
        }
        finally
        {
            oneAtATime.Release();
        }
    }
}

我没有更改ForEachAsync的签名来选择并行度,我让你随意调整。

输出示例:

DownloadFileTaskAsync (null local path): generating a temporary file name for http://cache.thephoenix.com/secure/uploadedImages/The_Phoenix/Music/CD_Review/main_OTR_Britney480.jpg
DownloadFileTaskAsync (null local path): generating a temporary file name for http://ssimg.soundspike.com/artists/britneyspears_femmefatale_cd.jpg
DownloadFileTaskAsync (null local path): generating a temporary file name for http://a323.yahoofs.com/ymg/albumreviewsuk__1/albumreviewsuk-526650850-1301400550.jpg?ymm_1xEDE5bu0tMi
DownloadFileTaskAsync (null remote path): skipping
DownloadFileTaskAsync (time out due): http://hangout.altsounds.com/geek/gars/images/3/9/8/5/2375.jpg
DownloadFileTaskAsync (time out due): http://www.beat.com.au/sites/default/files/imagecache/630_315sr/images/article/header/2011/april/britney-spears-femme-fatale.jpg
DownloadFileTaskAsync (time out due): http://cache.thephoenix.com/secure/uploadedImages/The_Phoenix/Music/CD_Review/main_OTR_Britney480.jpg
DownloadFileTaskAsync (downloaded): http://newblog.thecmuwebsite.com/wp-content/uploads/2009/12/britneyspears1.jpg
DownloadFileTaskAsync (downloaded): http://newblog.thecmuwebsite.com/wp-content/uploads/2009/12/britneyspears1.jpg
DownloadFileTaskAsync (downloaded): http://static.guim.co.uk/sys-images/Music/Pix/site_furniture/2011/3/22/1300816812640/Femme-Fatale.jpg
DownloadFileTaskAsync (downloaded): http://www.sputnikmusic.com/images/albums/72328.jpg

过去需要长达 1 分钟的时间现在只需 10 秒即可获得相同的结果 :)

非常感谢这 2 篇文章的作者:

http://blogs.msdn.com/b/pfxteam/archive/2012/03/05/10278165.aspx

http://blogs.msdn.com/b/pfxteam/archive/2012/03/04/10277325.aspx

【讨论】:

  • 很棒的扩展方法!
  • 不应该把await oneAtATime.WaitAsync();写在TResult result = await taskSelector(item);之前吗?否则,您只会立即为“源”的每个项目运行任务,并且基本上无视信号量限制(一次只运行 x 个任务)?
  • @BornToCode 是绝对正确的。上面的代码,如所写,实际上将启动与没有信号量的 TPL 一样多的任务,而是只允许 resultProcessor 具有最大 DOP。 如果您剪切并粘贴上述代码,请将 .WaitAsync() 移到执行任务选择器的上方。 此外,不要在信号量上调用 .Release(n),仅 5(不是 10 ) 并发任务将永远运行。我建议将信号量创建为 ... = new SemaphoneSlim(10,10)
猜你喜欢
  • 1970-01-01
  • 1970-01-01
  • 2016-01-09
  • 2021-09-27
  • 2020-03-07
  • 2018-09-20
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
相关资源
最近更新 更多