Question

I’m writing a simple Windows forms application to get me into the swing of things with Threads. So far what I have is working, but what I would like to do is contain it all in a seperate class rather than directly in my forms code.

I have a background thread that starts and retrieves data from a database. I then display that data in to a listbox.

private delegate void UpdateListValues(List<ListBoxItem> itemList);

private void form_main_Shown(object sender, EventArgs e)
{            
    // Set the loading text.
    list_selection.Items.Add(ListHelpers.LoadingItem());

    // Start the data access on a seperate thread.
    Thread worker = new Thread(GetInvoicingData);
    worker.IsBackground = true;
    worker.Start();
}

private void GetInvoicingData()
{
    // Query database
    List<ListBoxItem> values = DAC.GetInvoicingAccounts();

    // Display results
    BeginInvoke(new UpdateListValues(DisplayList), new object[] { values });
}

private void DisplayList(List<ListBoxItem> itemList)
{
    // Display each result
    list_selection.Items.Clear();
    for (int i = 0; i < itemList.Count; i++)
    {
        list_selection.Items.Add(itemList[i]);
    }
}

The problem is that in the DisplayList method, I won’t be able to access the list box (list_selection) because it’s part of the form class. Does anyone have any suggestions on how I can do this.

Also, I’m new to threading so feel free to tell me I’m doing it absolutely wrong. I just used the example from http://www.codeproject.com/Articles/23517/How-to-Properly-Handle-Cross-thread-Events-and-Upd to get me to where I am now.

Thanks

Answer 1

How about something like this:

// Added the form's class declaration to highlight separation of thread code into a separate class, but may not be exactly the same as yours depending on naming
public class Form1 : Form
{
    private readonly DataRetriever _dataRetriever;

    private void form_main_Shown(object sender, EventArgs e)
    {            
        // Set the loading text.
        list_selection.Items.Add(ListHelpers.LoadingItem());

        // Create the DataRetriever, and provide it with a delegate to DisplayList for returning data
        _dataRetriever = new DataRetriever(DisplayList);
        // Start retrieving data on a separate thread...
        _dataRetriever.GetData();
    }

    private void DisplayList(List<ListBoxItem> itemList)
    {
        if (InvokeRequired)
        {
            // Ensure the update occurs on the UI thread
            Invoke((Action)(() => DisplayList(itemList)));
            return;
        }
        // Display each result
        list_selection.Items.Clear();
        foreach (var item in itemList)
        {
            list_selection.Items.Add(item);
        }
    }
}

// Separate class to hold thread code
public class DataRetriever
{
    public delegate void UpdateCallbackDelegate(List<ListBoxItem> itemList);

    private readonly UpdateCallbackDelegate _updateCallback;

    public DataRetriever(UpdateCallbackDelegate updateCallback)
    {
        _updateCallback = updateCallback;
    }

    public void GetData()
    {
        var thread = new Thread(GetInvoicingData)
        {
            IsBackground = true
        };
        thread.Start();
    }

    private void GetInvoicingData()
    {
        // Not sure whether "DAC" is a static class, if it needs to be constructed
        // in the DataRetriever's constructor, or passed to it as a parameter
        _updateCallback(DAC.GetInvoicingAccounts());
    }
}

As you can see, all the thread code is now in a separate class DataRetriever, and a delegate provided when constructing it to enable the retrieved data to be passed back to the form once the retrieval is complete. The method that handles the callback ensures that the call is marshalled to the UI thread to prevent cross-thread exceptions.

I would like to point out that this is not presented as the “best” way to do this, but merely as an answer to the question (how to separating threading code into a separate class). As others have mentioned, there are already mechanisms in place to do this sort of thing (e.g. BackgroundWorker). Some complexity has been omitted for clarity. For example, in the implementation presented here, if you were to call GetData() multiple times (with each call occurring before the previous ones have returned their data), you would have multiple queries occurring simultaneously, and as they are running asynchronously, may return their data in an arbitrary order. This may or may not be an issue in your case.