WebClient upload file error

Question

I am using VSTS 2008 + C# + .Net 3.5 + ASP.Net + IIS 7.0 to develop a console application at client side to upload a file, and at server side I receive this file using an aspx file.

From client side, I always notice (from console output) the upload percetage of the file increase from 1% to 50%, then to 100% suddenly. Any ideas what is wrong?

Here is my client side code,

class Program
{
    private static WebClient client = new WebClient();
    private static ManualResetEvent uploadLock = new ManualResetEvent(false);

    private static void Upload()
    {
        try
        {
            Uri uri = new Uri("http://localhost/Default.aspx");
            String filename = @"C:\test\1.dat";

            client.Headers.Add("UserAgent", "TestAgent");
            client.UploadProgressChanged += new UploadProgressChangedEventHandler(UploadProgressCallback);
            client.UploadFileCompleted += new UploadFileCompletedEventHandler(UploadFileCompleteCallback);
            client.UploadFileAsync(uri, "POST", filename);
        }
        catch (Exception e)
        {
            Console.WriteLine(e.StackTrace.ToString());
        }
    }

    public static void UploadFileCompleteCallback(object sender, UploadFileCompletedEventArgs e)
    {
        Console.WriteLine("Completed! ");
        uploadLock.Set();
    }

    private static void UploadProgressCallback(object sender, UploadProgressChangedEventArgs e)
    {
        Console.WriteLine (e.ProgressPercentage);
    }

    static void Main(string[] args)
    {
        Upload();

        uploadLock.WaitOne();

        return;
    }
}

Here is my server side code,

    protected void Page_Load(object sender, EventArgs e)
    {
        string agent = HttpContext.Current.Request.Headers["UserAgent"];
        using (FileStream file = new FileStream(@"C:\Test\Agent.txt", FileMode.Append, FileAccess.Write))
        {
            byte[] buf = Encoding.UTF8.GetBytes(agent);
            file.Write(buf, 0, buf.Length);
        }

        foreach (string f in Request.Files.AllKeys)
        {
            HttpPostedFile file = Request.Files[f];
            file.SaveAs("C:\\Test\\UploadFile.dat");
        }
    }

thanks in advance, George

Answer 1

This is a known bug in the WebClient class. It will be fixed in .NET 4.0. Until then you could use HttpWebRequest to implement this functionality.

---

UPDATE: Here's an example of using synchronous HttpWebRequest to upload a file and track the progress:

public sealed class Uploader
{
    public const int CHUNK_SIZE = 1024; // 1 KB

    public void Upload(string url, string filename, Stream streamToUpload, Action<int> progress)
    {
        var request = (HttpWebRequest)WebRequest.Create(url);
        request.Method = "POST";
        string boundary = string.Format("---------------------{0}", DateTime.Now.Ticks.ToString("x"));
        request.ContentType = string.Format("multipart/form-data; boundary={0}", boundary);
        request.KeepAlive = true;

        using (var requestStream = request.GetRequestStream())
        {
            var header = string.Format("--{0}\r\nContent-Disposition: form-data; name=\"file\"; filename=\"{1}\"\r\nContent-Type: application/octet-stream\r\n\r\n", boundary, filename);
            var headerBytes = Encoding.ASCII.GetBytes(header);
            requestStream.Write(headerBytes, 0, headerBytes.Length);

            byte[] buffer = new byte[CHUNK_SIZE];
            int bytesRead;
            long total = streamToUpload.Length;
            long totalBytesRead = 0;
            while ((bytesRead = streamToUpload.Read(buffer, 0, buffer.Length)) > 0)
            {
                totalBytesRead += bytesRead;
                progress((int)(100 * totalBytesRead / total));
                byte[] actual = new byte[bytesRead];
                Buffer.BlockCopy(buffer, 0, actual, 0, bytesRead);
                requestStream.Write(actual, 0, actual.Length);
            }
        }
        using (var response = request.GetResponse()) { }
    }
}

class Program
{
    static void Main(string[] args)
    {
        var url = "http://localhost:2141/Default.aspx";
        var filename = "1.dat";
        var uploader = new Uploader();
        using (var fileStream = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
        {
            uploader.Upload(url, filename, fileStream, progress => Console.WriteLine("{0}% of \"{1}\" uploaded to {2}", progress, filename, url));
        }
    }
}

Answer 2

This beheavior is by design, its 50% upload the file and 50% the response of the server. Not a bug.

Answer 3

You can read webclient.UploadProgressChanged code.Then you will know the reason.Code below.

private void PostProgressChanged(AsyncOperation asyncOp, WebClient.ProgressData progress)
  {
      if (asyncOp == null || progress.BytesSent + progress.BytesReceived <= 0L)
          return;
      if (progress.HasUploadPhase)
      {
          int progressPercentage = progress.TotalBytesToReceive >= 0L || progress.BytesReceived != 0L
              ? (progress.TotalBytesToSend < 0L
                  ? 50
                  : (progress.TotalBytesToReceive == 0L
                      ? 100
                      : (int) (50L*progress.BytesReceived/progress.TotalBytesToReceive + 50L)))
              : (progress.TotalBytesToSend < 0L
                  ? 0
                  : (progress.TotalBytesToSend == 0L ? 50 : (int) (50L*progress.BytesSent/progress.TotalBytesToSend)));




          asyncOp.Post(this.reportUploadProgressChanged,
              (object)
                  new UploadProgressChangedEventArgs(progressPercentage, asyncOp.UserSuppliedState,
                      progress.BytesSent, progress.TotalBytesToSend, progress.BytesReceived,
                      progress.TotalBytesToReceive));
      }
      else
      {
          int progressPercentage = progress.TotalBytesToReceive < 0L
              ? 0
              : (progress.TotalBytesToReceive == 0L
                  ? 100
                  : (int) (100L*progress.BytesReceived/progress.TotalBytesToReceive));
          asyncOp.Post(this.reportDownloadProgressChanged,
              (object)
                  new DownloadProgressChangedEventArgs(progressPercentage, asyncOp.UserSuppliedState,
                      progress.BytesReceived, progress.TotalBytesToReceive));
      }
  }