.NET 4.0 BackgroundWorker class and unusual behavior

Question

I am running into some strange behavior in the backgroundworker class that leads me to believe that I don't fully understand how it works. I assumed that the following code sections were more or less equal except for some extra features that the BackgroundWorker implements (like progress reporting, etc.):

section 1:

    void StartSeparateThread(){
        BackgroundWorker bw = new BackgroundWorker();
        bw.DoWork += new DoWorkEventHandler(bw_DoWork);
        bw.RunWorkerAsync();
    }

    void bw_DoWork(object sender, DoWorkEventArgs e)
    {
        //Execute some code asynchronous to the thread that owns the function
        //StartSeparateThread() but synchronous to itself.

        var SendCommand = "SomeCommandToSend";
        var toWaitFor = new List<string>(){"Various","Possible","Outputs to wait for"};
        var SecondsToWait = 30;

        //this calls a function that sends the command over the NetworkStream and waits
        //for various responses.
        var Result=SendAndWaitFor(SendCommand,toWaitFor,SecondsToWait);
    }

Section 2:

    void StartSeparateThread(){
        Thread pollThread = new Thread(new ThreadStart(DoStuff));
        pollThread.Start();
    }

    void DoStuff(object sender, DoWorkEventArgs e)
    {
        //Execute some code asynchronous to the thread that owns the function
        //StartSeparateThread() but synchronous to itself.

        var SendCommand = "SomeCommandToSend";
        var toWaitFor = new List<string>(){"Various","Possible","Outputs to wait for"};
        var SecondsToWait = 30;

        //this calls a function that sends the command over the NetworkStream and waits
        //for various responses.
        var Result=SendAndWaitFor(SendCommand,toWaitFor,SecondsToWait);
    }

I was using Section 1 to run some code that sent a string over a networkstream and waited for a desired response string, capturing all output during that time. I wrote a function to do this that would return the networkstream output, the index of the the sent string, as well as the index of the desired response string. I was seeing some strange behavior with this so I changed the function to only return when both the send string and the output string were found, and that the index of the found string was greater than the index of the sent string. It would otherwise loop forever (just for testing). I would find that the function would indeed return but that the index of both strings were -1 and the output string was null or sometimes filled with the expected output of the previous call. If I were to make a guess about what was happening, it would be that external functions called from within the bw_DoWork() function are run asynchronously to the thread that owns the bw_DoWork() function. As a result, since my SendAndWaitFor() function was called multiple times in succession. the second call would be run before the first call finished, overwriting the results of the first call after they were returned but before they could be evaluated. This seems to make sense because the first call would always run correctly and successive calls would show the strange behavior described above but it seems counter intuitive to how the BackgroundWorker class should behave. Also If I were to break within the SendAndWaitFor function, things would behave properly. This again leads me to believe there is some multi-threading going on within the bwDoWork function itself.

When I change the code in the first section above to the code of the second section, things work entirely as expected. So, can anyone who understands the BackgroundWorker class explain what could be going on? Below are some related functions that may be relevant.

Thanks!

public Dictionary<string, string> SendAndWaitFor(string sendString, List<string> toWaitFor, int seconds)
    {
        var toReturn = new Dictionary<string, string>();
        var data = new List<byte>();
        var enc = new ASCIIEncoding();

        var output = "";
        var FoundString = "";

        //wait for current buffer to clear
        output = this.SynchronousRead();
        while(!string.IsNullOrEmpty(output)){
            output = SynchronousRead();
        }

        //output should be null at this point and the buffer should be clear.

        //send the desired data
        this.write(enc.GetBytes(sendString));

        //look for all desired strings until timeout is reached
        int sendIndex=-1;
        int foundIndex = -1;
        output += SynchronousRead();
        for (DateTime start = DateTime.Now; DateTime.Now - start < new TimeSpan(0, 0, seconds); )
        {
            //wait for a short period to allow the buffer to fill with new data              
            Thread.Sleep(300);

            //read the buffer and add it to the output
            output += SynchronousRead();
            foreach (var s in toWaitFor)
            {
                sendIndex = output.IndexOf(sendString);
                foundIndex = output.LastIndexOf(s);
                if (foundIndex>sendIndex)
                {
                    toReturn["sendIndex"] = sendIndex.ToString();
                    toReturn["foundIndex"] = sendIndex.ToString();
                    toReturn["Output"] = output;
                    toReturn["FoundString"] = s;
                    return toReturn;
                }
            }

        }
        //Set this to loop infinitely while debuging to make sure the function was only
        //returning above
        while(true){
        }
        toReturn["sendIndex"]="";
        toReturn["foundIndex"]="";
        toReturn["Output"] =output;
        toReturn["FoundString"] = "";
        return toReturn;
    }
    public void write(byte[] toWrite)
    {
        var enc = new ASCIIEncoding();
        var writeString = enc.GetString(toWrite);

        var ns = connection.GetStream();
        ns.Write(toWrite, 0, toWrite.Length);
    }

 public string SynchronousRead()
    {
        string toReturn = "";
        ASCIIEncoding enc = new ASCIIEncoding();
        var ns = connection.GetStream();

        var sb = new StringBuilder();
        while (ns.DataAvailable)
        {
            var buffer = new byte[4096];
            var numberOfBytesRead = ns.Read(buffer, 0, buffer.Length);
            sb.AppendFormat("{0}", Encoding.ASCII.GetString(buffer, 0, numberOfBytesRead));
            toReturn += sb.ToString();
         }         

        return toReturn;
    }

Answer 1

All data to be used by a background worker should be passed in through the DoWorkEventArgs and nothing should be pulled off of the class (or GUI interface).

In looking at your code I could not identify where the property(?) connnection was being created. My guess is that connection is created on a different thread, or may be pulling read information, maybe from a GUI(?) and either one of those could cause problems.

I suggest that you create the connection instance in the dowork event and not pull an existing one off of a different thread. Also verify that the data connection works with does not access any info off of a GUI, but its info is passed in as its made.

I discuss an issue with the Background worker on my blog C# WPF: Linq Fails in BackgroundWorker DoWork Event which might show you where the issue lies in your code.