lock (neues Objekt ()) - Frachtkult oder ein verrückter „Sprach-Sonderfall“?

Ich überprüfe einen Code, der von einem Berater geschrieben wurde, und obwohl bereits Dutzende roter Fahnen aufgetaucht sind, kann ich mich nicht um das folgende Snippet kümmern:

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

Was macht lock (new object ()) hier? Sollte keinerlei Auswirkungen haben, da immer ein anderes Objekt gesperrt wird. Diese Art der Sperre bleibt jedoch im gesamten Code bestehen, auch in nicht kopierten und eingefügten Teilen. Ist dies ein Sonderfall in der C # -Sprache, der zu etwas kompiliert wurde, von dem ich nichts weiß, oder hat der Programmierer einfach einen Frachtkult übernommen, der vor einiger Zeit funktioniert hat?

Ich wäre nicht überrascht, wenn jemand dies gesehen hätte:

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

und dachte, er könnte die Anzahl der Zeilen reduzieren.

Ich wäre sehr besorgt, wenn das der Fall wäre ...

Hier ist eine ähnliche Frage und Antwort:

Sperren gewährleisten den gegenseitigen Ausschluss - nicht mehr als ein Thread darf die Sperre gleichzeitig halten. Die Sperre wird mit einer bestimmten Objektinstanz identifiziert. Sie erstellen jedes Mal ein neues Objekt, das gesperrt werden soll, und Sie haben keine Möglichkeit, einen anderen Thread zu informieren, der genau dieselbe Objektinstanz sperren soll. Daher ist Ihre Verriegelung unbrauchbar.

Es ist wahrscheinlich nutzlos. Es besteht jedoch die Möglichkeit, dass eine Speicherbarriere entsteht. Nicht sicher, ob c # die Elision sperrt oder ob die Ordnungssemantik der Sperre beibehalten wird.