C＃Backgroundworker在标签中下载进度，在标签中获取字节

Question

I've created an application that patches my game servers files. However, I've got 3 problems which I can't solve:

1. When downloading a new patch, it doesn't update the progressbar instantly, but refreshes it after around 30-40 seconds
2. I want a label to show how much mega bytes they are downloading, and how much they have so far (for example: 122Mb/750Mb
3. When downloading, I want a label to show ~% of how much it has downloaded so far

I am not sure how to add number 2 and 3, and the number 1 problem just seems ridiculous, because there's nothing that indicates it should refresh after 30-40 seconds in my coding (at least as far as I know)

My backgroundWorker1_DoWork:

private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
    {
        //Defines the server's update directory
        string Server = "http://localhost/dl/game-updates/";

        //Defines application root
        string Root = AppDomain.CurrentDomain.BaseDirectory;

        //Make sure version file exists
        FileStream fs = null;
        if (!File.Exists("version"))
        {
            using (fs = File.Create("version"))
            {

            }

            using (StreamWriter sw = new StreamWriter("version"))
            {
                sw.Write("1.0");
            }
        }
        //checks client version
        string lclVersion;
        using (StreamReader reader = new StreamReader("version"))
        {
            lclVersion = reader.ReadLine();
        }
        decimal localVersion = decimal.Parse(lclVersion);

        //server's list of updates
        XDocument serverXml = XDocument.Load(@Server + "Updates.xml");

        //The Update Process
        foreach (XElement update in serverXml.Descendants("update"))
        {
            string version = update.Element("version").Value;
            string file = update.Element("file").Value;

            decimal serverVersion = decimal.Parse(version);


            string sUrlToReadFileFrom = Server + file;

            string sFilePathToWriteFileTo = Root + file;

            if (serverVersion > localVersion)
            {
                Uri url = new Uri(sUrlToReadFileFrom);
                System.Net.HttpWebRequest request = (System.Net.HttpWebRequest)System.Net.WebRequest.Create(url);
                System.Net.HttpWebResponse response = (System.Net.HttpWebResponse)request.GetResponse();
                response.Close();

                Int64 iSize = response.ContentLength;

                Int64 iRunningByteTotal = 0;

                using (System.Net.WebClient client = new System.Net.WebClient())
                {
                    using (System.IO.Stream streamRemote = client.OpenRead(new Uri(sUrlToReadFileFrom)))
                    {
                        using (Stream streamLocal = new FileStream(sFilePathToWriteFileTo, FileMode.Create, FileAccess.Write, FileShare.None))
                        {
                            int iByteSize = 0;
                            byte[] byteBuffer = new byte[iSize];
                            while ((iByteSize = streamRemote.Read(byteBuffer, 0, byteBuffer.Length)) > 0)
                            {
                                streamLocal.Write(byteBuffer, 0, iByteSize);
                                iRunningByteTotal += iByteSize;

                                double dIndex = (double)(iRunningByteTotal);
                                double dTotal = (double)byteBuffer.Length;
                                double dProgressPercentage = (dIndex / dTotal);
                                int iProgressPercentage = (int)(dProgressPercentage * 100);

                                backgroundWorker1.ReportProgress(iProgressPercentage);
                            }

                            streamLocal.Close();
                        }

                        streamRemote.Close();
                    }
                }

                //unzip
                using (ZipFile zip = ZipFile.Read(file))
                {
                    foreach (ZipEntry zipFiles in zip)
                    {
                        zipFiles.Extract(Root + "\\", true);
                    }
                }

                //download new version file
                WebClient webClient = new WebClient();
                webClient.DownloadFile(Server + "version.txt", @Root + "version");

                //Delete Zip File
                deleteFile(file);
            }
        }
    }

My backgroundWorker1_ProgressChanged:

private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
    {
        progressBar1.Value = e.ProgressPercentage;
        label1.Text = "Downloading updates...";
    }

And my backgroundWorker1_RunWorkerCompleted:

private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
        settings_btn.Enabled = true;
        start_btn_disabled.Enabled = false;
        start_btn_disabled.Visible = false;
        start_btn.Visible = true;
        start_btn.Enabled = true;
        progressBar1.Value = 100;
        label1.Text = "Client is up to date!";
    }

Also, a side note: I'm also having a bit problems of updating labels in backgroundWorker2_DoWork? Any ideas?

Answer 1

Here's some working code which updates a label on Form1 using the BackgroundWorker.

Create a new Windows Form project and drop it in your code and it'll work. It's super ugly, but it works. After that, just plug your code into the DoWork method and calculate your value and send to ReportProgress.

Keep in mind that the work done in DoWork method is the actual Background Thread. That means that in that method (DoWork) you cannot access UI (form) elements because they are on the UI thread.

 public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            backgroundWorker1.DoWork += backgroundWorker1_DoWork;
            backgroundWorker1.ProgressChanged += backgroundWorker1_ProgressChanged;
            backgroundWorker1.WorkerReportsProgress = true;
            backgroundWorker1.RunWorkerCompleted += backgroundWorker1_RunWorkerCompleted;
        }

        void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            button1.Enabled = true;
        }

        private void button1_Click(object sender, EventArgs e)
        {
            button1.Enabled = false;
            backgroundWorker1.RunWorkerAsync();
        }

        void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            label1.Text = e.ProgressPercentage.ToString();
        }

        void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            FakeCountingWork();
        }


        private void FakeCountingWork()
        {
            int totalNumber = 100;
            int progressCounter = 0;
            while (progressCounter < totalNumber)
            {
                int fakecounter = 0;
                for (int x = 0; x < 100000000; x++)
                {
                    fakecounter++;
                }
                progressCounter++;
                backgroundWorker1.ReportProgress(progressCounter);
            }
        }
    }

################################## EDITED TO ADD OTHER FUNCTIONALITY

Okay, here's how you can implement a label which displays the number of bytes downloaded so far. Add a second label named label2 to your form.
Next alter the following methods from my previous example. Here we are going to use the UserState to pass an extra value to the ProgressChanged Event. It's very simple. You can see that I'm generating a random number and it will now appear in Label2. This is where you could show your number of bytes.

  void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e) { label1.Text = e.ProgressPercentage.ToString(); label2.Text = e.UserState.ToString(); } private void FakeCountingWork() { int totalNumber = 100; int progressCounter = 0; Random rnd = new Random(); while (progressCounter < totalNumber) { int fakecounter = 0; for (int x = 0; x < 100000000; x++) { fakecounter++; } progressCounter++; updateValue = rnd.Next(); backgroundWorker1.ReportProgress(progressCounter,updateValue); } } 

Answer 2

I would imagine this is because you are trying to update UI objects on a different thread. HAve you tried using the Dispatcher if using wpf? https://msdn.microsoft.com/en-us/library/system.windows.threading.dispatcher.invoke(v=vs.110).aspx

or Invoke if using Winforms? https://msdn.microsoft.com/fr-ca/library/zyzhdc6b(v=vs.85).aspx

Edit: As @daylight pointed out to be, the UI was being updated in the progresschanged event, which executes on the thread which created the background worker, therefore there shouldn't be an issue regarding threading. See https://msdn.microsoft.com/en-us/library/ka89zff4(v=vs.110).aspx for more info