Question

I have a MainWindow (form1) and a class called Module

In Module there is a method to create a new Backgroundworker and change a label in MainWindow. I have tried creating a public or internal method in the MainWindow code and calling it in the Module class but it doesn’t seem to work.

Can anyone help me figure this out, it’s just something which is stopping me from continuing development.

Sorry if I didn’t make things clear, if you need something cleared up let me know.

Module.cs

public class Module
{
    protected System.Diagnostics.PerformanceCounter cpuCounter;
    BackgroundWorker cpuUThread;
    private delegate void UIDelegate();
    MainWindow mn;

    public void runCPUUsage()
    {

        cpuUThread = new BackgroundWorker();
        cpuUThread.DoWork += new DoWorkEventHandler(cpuUThread_DoWork);
        cpuUThread.WorkerSupportsCancellation = true;
        cpuUThread.RunWorkerAsync();
        mn = new MainWindow();
    }

    void cpuUThread_DoWork(object sender, DoWorkEventArgs e)
    {
        cpuCounter = new System.Diagnostics.PerformanceCounter();
        cpuCounter.CategoryName = "Processor";
        cpuCounter.CounterName = "% Processor Time";
        cpuCounter.InstanceName = "_Total";

        try
        {
            mn.changeCPUULabel(getCurrentCpuUsage().ToString());
        }
        catch (Exception ex)
        {

        }
    }

    public double getCurrentCpuUsage()
    {
        return Math.Round(cpuCounter.NextValue(), 0);
    }

    public void disposeCpuUsage()
    {
        cpuUThread.CancelAsync();
        cpuUThread.Dispose();
    }
}

MainWindow – Contains a label (labelCPUU)

internal void changeCPUULabel(string val)
    {
        Dispatcher.Invoke(new UIDelegate(delegate
            {
                this.labelCPUU.Content = val;
            }));
    }
public double getCurrentCpuUsage()
    {
       return mod.getCurrentCpuUsage();
    }
void activateCPUU(){ mod.runCPUUsage(); }

Answer 1

It’s a good idea not to couple the form to tightly with the module. One way to do that is to define an interface that the form implements, and have the module accept such an interface as a parameter. I’ll exemplify with some code. Let’s start with the interface:

public interface IDataReceiver
{
    void SetData(string data);
}

In my example I use a string for the data, but that can be whatever type you need to use. Then we implement this interface in the form:

public partial class Form1 : Form, IDataReceiver
{


    private void Button_Click(object sender, EventArgs e)
    {
        // create a module intstance, passing this form as parameter
        var module = new SomeModule(this);
        module.DoSomeWork();
    }

    public void SetData(string data)
    {
        // use the data that is received
        txtSomeTextBox.Text = data;
    }

    // the rest of the form code left out to keep it short
}

Finally the module with the BackgroundWorker:

public class SomeModule
{
    private BackgroundWorker _worker = new BackgroundWorker();
    private IDataReceiver _receiver;
    public SomeModule(IDataReceiver receiver)
    {
        _worker.DoWork += new DoWorkEventHandler(Worker_DoWork);
        _worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(Worker_RunWorkerCompleted);
        _worker.ProgressChanged += new ProgressChangedEventHandler(Worker_ProgressChanged);
        _worker.WorkerReportsProgress = true;
        _receiver = receiver;
    }

    void Worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
    {
        _receiver.SetData(e.UserState.ToString());
    }

    public void DoSomeWork()
    {
        // start the worker
        _worker.RunWorkerAsync();
    }

    private void Worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    {
        // call method to pass data to receiver
        _receiver.SetData(e.Result.ToString());
    }

    private void Worker_DoWork(object sender, DoWorkEventArgs e)
    {
        // do some work here
        // assign the resulting data to e.Result
        for (int i = 0; i < 10; i++)
        {
            _worker.ReportProgress(0, "some data " + i);
            Thread.Sleep(250);
        }
        e.Result = "Finished";
    }
}

This way the module is in no way depending on what your form class looks like (it is even unaware that it is talking to a form). In my sample I call _receiver.SetData from the RunWorkerCompleted event handler, but it could just as well be done from a ReportProgress event handler.

Also note how the form is the “driving force” here. The module does not create the form, or take any initiatives of any kind. It is simply used by the form.