Question

I am just wondering about problems involved passing a parent to child, should it be done etc, so that a child can access functionality from the parent, in this case it involves threads. My scenario follows:

public class A
{
    public A() 
    { 
        B b = new B(this);
        Thread thread = new Thread(new ThreadStart(b.GO));
    }
    public string DoSomething() { return "Something Done"; }
}

public class B
{
    A _a;
    public B(A a) 
    {
        _a = a;
    }
    public void GO() { _a.DoSomething(); }
}

Based on above I’m wondering about any convention clashes the occur, or problems that come into effect when you do something like this, is it bad to do this? I know that there definitely brings up some thread safety issues. But my overall question is ok to do this, does it bring up some other issues? How would I update values in the main thread?
The reason why I want it separate is because class B has a timer in it(not in shown code) that when it runs out does somethings, then tells class A that it has finished, resets the timer and goes back to sleep until the timer runs out again, how would I do that otherwise?

~Regards,

Heinrich

Answer 1

Another way to handle what you are doing is for B to raise an event and for A to handle the event. That way you don’t have to pass A into B. I don’t know what your real structure is, but lets say that B’s thread function does something more complicated and A implements IDisposable. What happens if A is disposed before B gets to the point that it is calling a method on A. To me the cleaner way to handle that situation is to have B raise an event and A register for it.

public class A
{
    B _b;

    public A()
    {
        _b = new B();
        _b.DidSomething += HandleDidSomething;
    }

    private void HandleDidSomething(object source, EventArgs e)
    {
        // Handle the B did something case
    }

    public void WaitForBToFinish() { _b.DoneDoingThings.WaitOne(); }
}

public class B
{
    Event EventHandler DidSomething;

    ManualResetEvent DoneDoingThings = new ManualResetEvent(false);

    public B() {}

    public void StartDoingThings()
    {
        new Thread(DoThings).Start();
    }

    private void DoThings()
    {
         for (int i=0; i < 10; i++)
         {
             Thread.Sleep(1000);
             OnDidSomething(new EventArgs());
         }

         DoneDoingThings.Set();
    }

    private void OnDidSomething(EventArgs e)
    {
         if (DidSomething != null)
         {
              DidSomething(e);
         }
    }    
 }

Note – You should implement IDisposable in class B and dispose of the ManualResetEvent, I just am too lazy to do all that for sample code, and just wanted to give you an idea about using events to signal work was done.