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