lock (nuevo objeto ()) - ¿Culto a la carga o algún loco “caso especial de lenguaje”?

Estoy revisando un código escrito por un consultor, y aunque ya han aparecido docenas de banderas rojas, no puedo entender el siguiente fragmento:

private void foo()
{
    if (InvokeRequired)
    {
        lock (new object())
        {
            if (m_bar!= null)
                Invoke(new fooDelegate(foo), new object[] { });
        }
    }
    else
    {
        if(OnBazChanged != null)
            OnBazChanged();
    }
}

¿Qué está haciendo lock (new object ()) aquí? No debería tener ningún efecto, ya que siempre se bloquea en otro objeto, pero este tipo de bloqueo es persistente en todo el código, incluso en partes que no se copian y pegan. ¿Es este un caso especial en el lenguaje C # que está compilado para algo que no conozco, o el programador simplemente adoptó algún culto de carga que funcionó hace algún tiempo?

No me sorprendería que fuera alguien que viera esto:

private readonly object lockObj = new object();

private void MyMethod()
{
    lock(lockObj)
    {
        // do amazing stuff, so amazing it can only run once at a time
        // e.g. comands on the Mars Rover, or programs on iOS pre 4 / 5 ??
    }
}

y pensó que podría reducir el número de líneas.

Sin embargo, estaría muy preocupado si ese fuera el caso ...

Aquí hay una pregunta y una respuesta similares:

Los candados aseguran la exclusión mutua: no más de un hilo puede sujetar el candado al mismo tiempo. El bloqueo se identifica con una instancia de objeto específica. Está creando un nuevo objeto para bloquear cada vez y no tiene ninguna forma de informar a ningún otro hilo para bloquear exactamente esa misma instancia de objeto. Por lo tanto, su bloqueo es inútil.

Probablemente sea inútil. Pero existe la posibilidad de que esté ahí para crear una barrera de memoria. No estoy seguro de si c # bloquea la elisión o si conserva la semántica de ordenación del bloqueo.