lock (new object ()) - Cargo culte ou un «cas particulier de langage» fou?

J'examine du code écrit par un consultant, et bien que des dizaines de signaux d'alarme soient déjà apparus, je ne peux pas comprendre l'extrait de code suivant:

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

Que fait lock (new object ()) ici? Ne devrait avoir aucun effet car il se verrouille toujours sur un autre objet, mais ce type de verrouillage est persistant dans tout le code, même dans les parties non copiées-collées. Est-ce un cas particulier dans le langage C # qui est compilé vers quelque chose que je ne connais pas, ou le programmeur a-t-il simplement adopté un culte du cargo qui fonctionnait il y a quelque temps?

Je ne serais pas surpris si c'était quelqu'un qui avait vu ceci:

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 ??
    }
}

et a pensé qu'il pourrait réduire le nombre de lignes.

Je serais très inquiet si c'était le cas cependant ...

Voici une question similaire et une réponse:

Les verrous garantissent une exclusion mutuelle - pas plus d'un fil ne peut retenir le verrou en même temps. Le verrou est identifié avec une instance d'objet spécifique. Vous créez un nouvel objet à verrouiller à chaque fois et vous n'avez aucun moyen d'informer un autre thread de se verrouiller sur cette même instance d'objet. Par conséquent, votre verrouillage est inutile.

C'est probablement inutile. Mais il y a une chance qu'il soit là pour créer une barrière mémoire. Je ne sais pas si c # verrouille l'élision ou s'il le fait s'il préserve la sémantique de classement du verrou.