Question

I have been at work this afternoon trying to use a backgroundworker to read from an pretty large xml File Located in my assembly. It has worked pretty well up till the point I decided to rename the backgroundworker’s objectname. After I built my solution, it told me it was a success. After running my program and testing it, I noticed that the backgroundworker’s DoWork Event refuses to fire at all. When I added the code below to the Backgroundworker’s RunWorkerCompleted event, all i got was a messagebox containing a big fat nothing. MessageBox.Show(e.Result + " " + e.Error); Renaming it back to what it was also didn’t help. I wrote all the code myself, so there are no third party applications involved here.

Here is the code I used to set up the workings with the backgroundworker

private volatile List<string> listItems = new List<string>();
    private BackgroundWorker _populateListItems = new BackgroundWorker();
    private string currentConnection;
    #endregion
    public frmSettings()
    {
        InitializeComponent();

        //I will be able to track how far the list is populated with the following command.
        _populateListItems.WorkerReportsProgress = true;
        //This will fire if there is an error in the xml file.
        _populateListItems.WorkerSupportsCancellation = true;
        //Assign the job to be done for the backgroundworker
        _populateListItems.DoWork +=new DoWorkEventHandler(_populateListItems_DoWork);
        _populateListItems.ProgressChanged += new ProgressChangedEventHandler(_populateListItems_ProgressChanged);
        //When the worker is finished, the following event will fire: All UI controls will be updated.
        _populateListItems.RunWorkerCompleted += new RunWorkerCompletedEventHandler(_populateListItems_RunWorkerCompleted);

        _populateListItems.RunWorkerAsync();
    }

    void _populateListItems_ProgressChanged(object sender, ProgressChangedEventArgs e)
    {
        prgProgress.Value = e.ProgressPercentage;
        lblProgress.Text = e.ProgressPercentage.ToString() + "%";
    }

    private void _populateListItems_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
        //The operation is completed/Cancelled/Erroneous. The list will now be populated with the available information.
        MessageBox.Show(e.Result + " " + e.Error);
        foreach (string item in listItems)
        {
            liConnections.Items.Add(item);
        }

        //This shows the user which connection is currently used.
        lblCurrentSelection.Text = currentConnection;
    }

    private void _populateListItems_DoWork(object sender, DoWorkEventArgs e)
    {
        try
        {
            //The following lines of code are the variables that are going to be used.
            // xReadSettings will make the XmlReader xRead Ignore whitespaces and comments, if any.
            // assemblyExecuted will get information from which assembly gets Executed.
            // filename Will get the filename of the settings.xml file that is going to be used.
            // SettingsStream will open the stream for reading and writing, using the GetManifestResourceStream() method from the currently executed assembly.
            XmlReaderSettings xReadSettings = new XmlReaderSettings();
            Assembly assemblyExecuted = Assembly.GetExecutingAssembly();
            string filename = String.Format("{0}.Settings.xml", assemblyExecuted.GetName().Name);
            Stream settingsStream = assemblyExecuted.GetManifestResourceStream(filename);

            xReadSettings.IgnoreComments = true;
            xReadSettings.IgnoreWhitespace = true;

            //Finally the xmlReader object is created using the settingstream, and its settings.
            //While the stream reads, it checks whether the nodes accessed are elements of the xml file.
            //if it is an element that is accessed, then we check whether the element which is accessed is a connection string to the database
            //if it is a connectionstring to the database, we will check if the connection has a name.
            //if it has a name, we get the name attribute, and add it to our list. The list is volatile, so it will be up to date, because this
            //background thread is updating it.
            //To Update the progress of the backgroundworker, we need to know the amount of elements in the XML File. Xpath will be used for this.
            XmlDocument xdoc = new XmlDocument();
            xdoc.Load(settingsStream);
            XmlNodeList nodes = xdoc.SelectNodes("*"); //Xpath - select all.
            int totalElementsToRead = nodes.Count;
            int totalElementsRead = 0;
            using (XmlReader xRead = XmlReader.Create(settingsStream, xReadSettings))
            {
                while (xRead.Read())
                {
                    if (xRead.NodeType == XmlNodeType.Element)
                    {
                        if (xRead.Name == "ConnectionString")
                        {
                            if (xRead.HasAttributes)
                            {
                                string attribute = xRead.GetAttribute("name").ToString();
                                listItems.Add(attribute);
                            }
                        }
                        if (xRead.Name == "CurrentConnection")
                        {
                            xRead.Read(); //gets the value of <CurrentConnection>
                            currentConnection = xRead.Value.Trim();
                        }
                        totalElementsRead++;
                        _populateListItems.ReportProgress(totalElementsRead / totalElementsToRead * 100);
                    }
                }
            }
        }
        catch
        {
            _populateListItems.CancelAsync();
        }
    }

Pardon the theory in the comments behind it. I’m explaining it the best way that i can.

My question is though, can anyone see perhaps where this has gone wrong? Why the event suddenly does not fire? It is supposed to fill a list up with items from my xml file (untouched, was working before rename). Running a step-through debug also proved it was skipping my doWork event handler.

Answer 1

I think the problem is that you are calling RunWorkerAsync from the constructor and the ProgressChanged fails due to the form not being visible yet. Try moving the call to RunWorkerAsync to the form’s Show event handler.

OK, so the problem was an exception inside the DoWork event handler that was being eaten up by the try..catch block.

To sum up the issues with your code:

• try..catch block that eats up all exceptions and makes debugging difficult.
• Call RunWorkerAsync from inside the form constructor.
• Access UI thread objects from the worker thread without proper synchronization/locking.
• Call CancelAsync from inside the DoWork event handler.