C# HttpWebRequest下载文件和进度条

我在网上搜索了一下，但在下载带有HttpWebRequest的文件时找不到任何取得进展的方法。这门课支持进步吗？任何链接，教程，提示将不胜感激

谢谢

还有，这是密码

    private static Task<HttpResponse> MakeAsyncRequest(string requestString)
    {
        var request = (HttpWebRequest)WebRequest.Create(requestString);
        Task<WebResponse> requestTask = Task.Factory.FromAsync(
            request.BeginGetResponse,
            asyncResult => request.EndGetResponse(asyncResult),
            null);
        return requestTask.ContinueWith(t => ReadStreamFromResponce(t.Result));
    }

    private static HttpResponse ReadStreamFromResponce(WebResponse result)
    {
        var responseobject = new HttpResponse();
        var response = (HttpWebResponse)result;
        responseobject.StatusCode = (short)response.StatusCode;

        if (!IsSuccess(responseobject.StatusCode))
            return responseobject;

        using (var responseStream = response.GetResponseStream())
        using (var ms = new MemoryStream())
        {
            responseStream.CopyTo(ms);
            responseobject.SetResponse(ms.ToArray());
            return responseobject;
        }
    }

私有静态任务MakeAsyncRequest（string requestString）
{
var request=（HttpWebRequest）WebRequest.Create（requestString）；
Task requestTask=Task.Factory.FromAsync(
request.BeginGetResponse，
asyncResult=>request.EndGetResponse（asyncResult），
无效）；
返回requestTask.ContinueWith（t=>ReadStreamFromResponse（t.Result））；
}
私有静态HttpResponse ReadStreamFromResponse（WebResponse结果）
{
var responseobject=新的HttpResponse（）；
var响应=（HttpWebResponse）结果；
responseobject.StatusCode=（短）response.StatusCode；
如果（！IsSuccess（responseobject.StatusCode））
返回响应对象；
使用（var responseStream=response.GetResponseStream（））
使用（var ms=new MemoryStream（））
{
响应团队副本（ms）；
responseobject.SetResponse（ms.ToArray（））；
返回响应对象；
}
}

不要以同步方式复制响应流，而是尝试以异步方式复制，并在下面的函数中钩住代理，您应该能够以下载的字节数获取进度，并将其显示在进度栏中

    public static void CopyToStreamAsync(this Stream source, Stream destination,
        Action<Stream, Stream, Exception> completed, Action<uint> progress,
        uint bufferSize, uint? maximumDownloadSize, TimeSpan? timeout)
    {
        byte[] buffer = new byte[bufferSize];

        Action<Exception> done = exception =>
            {
                if (completed != null)
                {
                    completed(source, destination, exception);
                }
            };

        int maxDownloadSize = maximumDownloadSize.HasValue
            ? (int)maximumDownloadSize.Value
            : int.MaxValue;
        int bytesDownloaded = 0;
        IAsyncResult asyncResult = source.BeginRead(buffer, 0, new[] { maxDownloadSize, buffer.Length }.Min(), null, null);
        Action<IAsyncResult, bool> endRead = null;
        endRead = (innerAsyncResult, innerIsTimedOut) =>
            {
                try
                {
                    int bytesRead = source.EndRead(innerAsyncResult);
                    if (innerIsTimedOut)
                    {
                        done(new TimeoutException());
                    }

                    int bytesToWrite = new[] { maxDownloadSize - bytesDownloaded, buffer.Length, bytesRead }.Min();
                    destination.Write(buffer, 0, bytesToWrite);
                    bytesDownloaded += bytesToWrite;

                    if (!progress.IsNull() && bytesToWrite > 0)
                    {
                        progress((uint)bytesDownloaded);
                    }

                    if (bytesToWrite == bytesRead && bytesToWrite > 0)
                    {
                        asyncResult = source.BeginRead(buffer, 0, new[] { maxDownloadSize, buffer.Length }.Min(), null, null);
                        // ReSharper disable PossibleNullReferenceException
                        // ReSharper disable AccessToModifiedClosure
                        asyncResult.FromAsync((ia, isTimeout) => endRead(ia, isTimeout), timeout);
                        // ReSharper restore AccessToModifiedClosure
                        // ReSharper restore PossibleNullReferenceException
                    }
                    else
                    {
                        done(null);
                    }
                }
                catch (Exception exc)
                {
                    done(exc);
                }
            };

        asyncResult.FromAsync((ia, isTimeout) => endRead(ia, isTimeout), timeout);
    }

public static void CopyToStreamAsync（此流源、流目标、，
行动完成，行动进展，
uint缓冲区大小、uint？最大下载大小、TimeSpan？超时）
{
字节[]缓冲区=新字节[bufferSize]；
操作完成=异常=>
{
如果（已完成！=null）
{
已完成（来源、目的地、异常）；
}
};
int maxDownloadSize=maximumDownloadSize.HasValue
？（int）maximumDownloadSize.Value
：int.MaxValue；
int字节=0；
IAsyncResult asyncResult=source.BeginRead（buffer，0，new[]{maxDownloadSize，buffer.Length}.Min（），null，null）；
Action endRead=null；
endRead=（innerAsyncResult，InnerIstimeOut）=>
{
尝试
{
int bytesRead=source.EndRead（innerAsyncResult）；
如果（InnerIstimeOut）
{
完成（新的TimeoutException（））；
}
int bytesToWrite=new[]{maxDownloadSize-bytesloadded，buffer.Length，bytesRead}.Min（）；
写入（缓冲区，0，bytesToWrite）；
bytesDownloaded+=bytesToWrite；
如果（！progress.IsNull（）&&bytesToWrite>0）
{
进度（（uint）字节下载）；
}
if（bytesToWrite==bytesRead&&bytesToWrite>0）
{
asyncResult=source.BeginRead（缓冲区，0，新[]{maxDownloadSize，buffer.Length}.Min（），null，null）；
//ReSharper禁用PossibleNullReferenceException
//ReSharper禁用AccessToModifiedClose
asyncResult.FromAsync（（ia，isTimeout）=>endRead（ia，isTimeout），超时）；
//ReSharper restore AccessToModified闭包
//ReSharper还原可能的NullReferenceException
}
其他的
{
完成（空）；
}
}
捕获（异常exc）
{
完成（exc）；
}
};
asyncResult.FromAsync（（ia，isTimeout）=>endRead（ia，isTimeout），超时）；
}

谢谢，不幸的是，我使用的是PCL（可移植类库）项目，我们没有Begin****方法。你知道在PCL中是否可以做类似的事情吗？谢谢