lock (new object ()) - Cargo cult o qualche folle “language special case”?

Sto rivedendo del codice scritto da un consulente e, sebbene siano già spuntate dozzine di bandiere rosse, non riesco a capire il seguente frammento:

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

Cosa ci fa lock (new object ()) qui? Non dovrebbe avere alcun effetto in quanto si blocca sempre su un altro oggetto, ma questo tipo di blocco è persistente in tutto il codice, anche nelle parti non copiate e incollate. È un caso speciale nel linguaggio C # compilato su qualcosa che non conosco, o il programmatore ha semplicemente adottato un culto del carico che è capitato di funzionare qualche tempo fa?

Non sarei sorpreso se fosse qualcuno che ha visto questo:

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

e pensava di poter ridurre il numero di righe.

Sarei molto preoccupato se fosse così però ...

Ecco una domanda simile e risposta:

I blocchi garantiscono l'esclusione reciproca: non più di un thread può contenere il blocco contemporaneamente. Il blocco viene identificato con un'istanza di oggetto specifica. Stai creando un nuovo oggetto da bloccare ogni volta e non hai alcun modo per informare nessun altro thread di bloccarsi sulla stessa identica istanza dell'oggetto. Pertanto, il tuo blocco è inutile.

Probabilmente è inutile. Ma c'è la possibilità che sia lì per creare una barriera di memoria. Non sono sicuro se c # blocchi l'elisione o se lo fa se conserva la semantica di ordinamento del blocco.