UI update with multiple concurrent operations

The B * * * dy captcha system decided it would be nice to lose my answer. I spent half an hour typing without warning or a chance to fix ... so we over and over again:

public class APD : IDevice
 {
    // Some members and properties go here, removed for clarity.

    public event EventHandler ErrorOccurred;
    public event EventHandler NewCountsAvailable;

    public UInt32[] BufferedCounts
    {
        // Get for the _ui32Values returned by the EndReadMultiSampleUInt32() 
        // after they were appended to a list. BufferdCounts therefore supplies 
        // all values read during the experiment.
    } 

    public bool IsDone
    {
        // This gets set when a preset number of counts is read by the hardware or when
        // Stop() is called.
    }

    // Constructor
    public APD( some parameters )
    {
       // Removed for clarity.
    }

    private void APDReadCallback(IAsyncResult __iaresResult)
    {
        try
        {
            if (this.m_daqtskRunningTask == __iaresResult.AsyncState)
            {
                // Get back the values read.
                UInt32[] _ui32Values = this.m_rdrCountReader.EndReadMultiSampleUInt32(__iaresResult);

                // Do some processing here!

                if (NewCountsAvailable != null)
                {
                    NewCountsAvailable(this, new EventArgs());
                }

                // Read again only if we did not yet read all pixels.
                if (this.m_dTotalCountsRead != this.m_iPixelsToRead)
                {
                    this.m_rdrCountReader.BeginReadMultiSampleUInt32(-1, this.m_acllbckCallback, this.m_daqtskAPDCount);
                }
                else
                {
                    // Removed for clarity.
                }
            }
        }
        catch (DaqException exception)
        {
            // Removed for clarity.
        }
    }


    private void SetupAPDCountAndTiming(double __dBinTimeMilisec, int __iSteps)
    {
        // Do some things to prepare hardware.
    }

    public void StartAPDAcquisition(double __dBinTimeMilisec, int __iSteps)
    {
        this.m_bIsDone = false;

        // Prepare all necessary tasks.
        this.SetupAPDCountAndTiming(__dBinTimeMilisec, __iSteps);

        // Removed for clarity.

        // Begin reading asynchronously on the task. We always read all available counts.
        this.m_rdrCountReader.BeginReadMultiSampleUInt32(-1, this.m_acllbckCallback, this.m_daqtskAPDCount); 
    }

    public void Stop()
    {
       // Removed for clarity. 
    }
}

      

        
        
        
      

    

Note. I've added some things that I mistakenly left in the original post.

Now in my form I have code like this:

public partial class Form1 : Form
{
    private APD m_APD1;
    private APD m_APD2;
    private APD m_APD3;
    private APD m_APD4;
    private DataDocument m_Document;

    public Form1()
    {
        InitializeComponent();
    }

    private void Button1_Click()
    {           
        this.m_APD1 = new APD( ... ); // times four for all APD's

        this.m_APD1.NewCountsAvailable += new EventHandler(m_APD1_NewCountsAvailable);     // times 4 again...   

        this.m_APD1.StartAPDAcquisition( ... );
        this.m_APD2.StartAPDAcquisition( ... );
        this.m_APD3.StartAPDAcquisition( ... );
        this.m_APD4.StartAPDAcquisition( ... );

        while (!this.m_APD1.IsDone) // Actually I have to check all 4
        {
             Thread.Sleep(200);
             UpdateUI();
        }

        // Some more code after the measurement is done.
    }

    private void m_APD1_NewCountsAvailable(object sender, EventArgs e)
    {
        this.m_document.Append(this.m_APD1.BufferedCounts);

    }

    private void UpdateUI()
    {
        // use the data contained in this.m_Document to fill the UI.
    } 
}

      

        
        
        
      

    

phew, I hope I don’t forget anything to repeat it a second time (this will teach me not to copy it before hitting the post).

What I can see by running this code is:

1) The APD object works as advertised, it measures. 2) NewCountsAvailable events are triggered and their handlers are executed 3) APD.StartAPDAcquisition () is called on the UI thread. Thus, BeginXXX is called on this thread. So by design, the callback is on this thread as well, and obviously the NewCountsAvailable event handlers on the UI thread are also executed. The only thing not on the UI thread is waiting for the hardware to return values ​​in the BeginXXX EndXXX call pair. 4) Since NewCountsAvailable events are firing so many things, the while loop that I was planning to use to update the UI does not fire. It is usually fired once at the beginning and then processed in some way by the event handlers,to be processed. I don't quite understand this, but it doesn't work ...

I solved this problem by getting rid of the while loop and putting Forms.Timer on the form where UpdateUI () would be called from the Tick event handler. However, I don't know if this would be considered "best practice". I also don't know if all of these event handlers will end up crawling the UI thread, I may need to add a few more such APD objects in the future. Additionally, UpdateUI () may contain heavier code to compute the image based on the values ​​in m_Document. So the tick event handler can also be a resource leak in the timer approach. In case I use this solution, I also need to have a Done event in my APD class to notify me when each APD is complete.

Should I possibly not work with events to notify that new counts are available, but instead work with some sort of "on demand" reading of APD.BufferedCounts and put the whole thing on another thread? I really don't have a clue ...

I basically want a clean, lightweight solution that scales well if I add even more APDs :)