Monitor and ReaderWriterLockSlim aren't working - visual-studio

Question

I tried to implement a typical threading application where one thread asks a device is data is available, copies the data to its own memory and sends an event to the main thread that the data is available. The main thread copies the data to its own memory and displays it on the GUI.
For this I used Visual Studio 2012 and C++/CLI with Winforms.
There is a class “Work” which holds the thread method “checkDataIsAvailable”. The “Work” class implements an interface (rather an abstract class) with a delegate “OnRetrievedData” which works as event and calls “BeginInvoke” in “Form1” to have an asynchronous behavior. And there is a method “getData” where the main thread can get the data from the “checkDataIsAvailable” thread. Furthermore the “Work” class tries to get the data from the class “ValueGenerator” which could represents any real device. I identifies a critical section for the “data” in the “Work” class called “array^ m_Data;”. The problem is that neither the “Monitor” nor the “ReaderWriterLockSlim” work approach is working.
With “Monitor” the GUI has a delayed responding and many updates are missing.
With “ReaderWriterLockSlim” the application crashes.
And without saving the critical section the application works. But I don’t know the reason because I’m sure that the data must be saved.
I would like to simplify the source code and emphasize the important things.
Most important is the thread method:
System::Void Work::checkDataIsAvailable()
{
while ( ( Thread::CurrentThread->ThreadState & Threading::ThreadState::Running) == Threading::ThreadState::Running )
{
m_WaitForDoCheckDataIsAvailableHandle->WaitOne();
//Monitor::Enter(m_LockData);
m_rwlock->EnterWriteLock();
m_Data = m_ValueGenerator->getData();
m_rwlock->ExitWriteLock();
//Monitor::Exit(m_LockData);
if ( nullptr != OnRetrievedData)
{
OnRetrievedData();
}
}
}
Here you see the copy process from the "ValueGenerator" to the variable m_Data. In my eyes this is a critical section. Then the event "OnRetrievedData" will be send that the data is available.
This event will get the Form1:
System::Void Form1::OnAcquisitionUpdate()
{
if(this->InvokeRequired == true)
{
OnAcquisitionUpdateDelegate^ onAcquisitionUpdateDelegate = gcnew OnAcquisitionUpdateDelegate(this, &Form1::OnAcquisitionUpdate);
this->BeginInvoke(onAcquisitionUpdateDelegate);
//this->Invoke(onAcquisitionUpdateDelegate);
}
else
{
if ( nullptr != m_Work )
{
//Thread::Sleep(5000);
array<System::Int32>^ data;
m_Work->getData(data);
dataResult_label->Text = data->Length.ToString();
}
}
}
"Form1::OnAcquisitionUpdate" changes it to the main thread via "BeginInvoke" and calls again the "Form1::OnAcquisitionUpdate" but now "InvokeRequired" is false so the "Work" class be called to get the data from the main thread.
System::Void Work::getData(array<System::Int32>^% data)
{
//Monitor::Enter(m_LockData);
m_rwlock->EnterReadLock();
Console::WriteLine(" getData() -> Data length = {0}", m_Data->Length);
data = m_Data;
m_rwlock->EnterReadLock();
//Monitor::Exit(m_LockData);
}
Here I see the next critical section where the data will be copied for the caller Form1.
It would be nice if anybody could help in this case.

Answer 1

I found a solution with a bool flag. Th flag is called "System::Boolean m_bCanWriteData;" and will be used in "Work::checkDataIsAvailable()" and "Work::getData(...)" in this way.
System::Void Work::checkDataIsAvailable()
{
while ( ( Thread::CurrentThread->ThreadState & Threading::ThreadState::Running) == Threading::ThreadState::Running )
{
m_WaitForDoCheckDataIsAvailableHandle->WaitOne();
#ifdef Use_Monitor
Monitor::Enter(m_LockData);
#endif
#ifdef Use_RW_Lock
m_rwlock->EnterWriteLock();
#endif
if ( m_bCanWriteData )
{
m_bCanWriteData = false;
m_Data = m_ValueGenerator->getData();
debugOutput("Work::checkDataIsAvailable() -> Data length = " + m_Data->Length);
if ( nullptr != OnRetrievedData)
{
OnRetrievedData();
}
}
#ifdef Use_RW_Lock
m_rwlock->ExitWriteLock();
#endif
#ifdef Use_Monitor
Monitor::Exit(m_LockData);
#endif
}
}
System::Void Work::getData(array<System::Int32>^% data)
{
debugOutput("Work::getData() START");
#ifdef Use_Monitor
Monitor::Enter(m_LockData);
debugOutput("Work::getData() + Monitor::Enter");
#endif
#ifdef Use_RW_Lock
m_rwlock->EnterReadLock();
#endif
m_WaitForDoCheckDataIsAvailableHandle->Reset(); // Block the thread method.
debugOutput("Work::getData() -> Data length = " + m_Data->Length);
data = m_Data;
m_bCanWriteData = true;
if ( m_bIsRunning )
{
m_WaitForDoCheckDataIsAvailableHandle->Set(); // Start the thread method.
}
#ifdef Use_RW_Lock
m_rwlock->EnterReadLock();
#endif
#ifdef Use_Monitor
Monitor::Exit(m_LockData);
#endif
debugOutput("Work::getData() END");
}
As you see the writting into and reading out is controlled and it works for the Monitor.