C#'s lock() in Managed C++

Question

Does managed C++ have an equivalent to C#'s lock() and VB's SyncLock? If so, how do I use it?

Answer 1

The equivelent to a lock / SyncLock would be to use the Monitor class.

In .NET 1-3.5sp, lock(obj) does:

Monitor.Enter(obj);
try
{
    // Do work
}
finally
{
    Monitor.Exit(obj);
}

As of .NET 4, it will be:

bool taken = false;
try
{
    Monitor.Enter(obj, ref taken);
    // Do work
}
finally
{
    if (taken)
    {
        Monitor.Exit(obj);
    }
}

You could translate this to C++ by doing:

System::Object^ obj = gcnew System::Object();
Monitor::Enter(obj);
try
{
    // Do work
}
finally
{
    Monitor::Exit(obj);
}

Answer 2

C++/CLI does have a 'lock' class - all you need to do is declare lock variable using stack-based semantics and it will safely exit the monitor when its destructor is called, e.g.:

#include <msclr\lock.h>
{    
    msclr::lock l(m_lock);

    // Do work

} //destructor of lock is called (exits monitor).  

'm_lock' declaration depends on which members you want to protect. To protect instance members use this:

Object^ m_lock = gcnew Object(); // Each class instance has a private lock - 
                                 // protect instance members.

To protect static members use this:

static Object^ m_lock = gcnew Object(); // Type has a private lock -
                                        // protect static members.

Answer 3

There's no equivalent of the lock keyword in C++. You could do this instead:

Monitor::Enter(instanceToLock);
try
{
    // Only one thread could execute this code at a time
}
finally
{
    Monitor::Exit(instanceToLock);
}

Answer 4

Try Threading.Monitor. And catch.