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

C++/CLI does have a lock class. All you need to do is declare a 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 whether you are synchronising access to an instance or static member.

To protect instance members, use this:

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

To protect static members, use this:

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

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);}

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);}