Convenção de nomenclatura para objetos de bloqueio de thread dedicado [fechado]

Uma pergunta relativamente pequena, mas não consegui encontrar documentação oficial nem mesmo opiniões / discussões sobre o blog.

Simplificando: quando eu tenho um objeto particular cujo único objetivo é servir para o privado lock, qual o nome desse objeto?

class MyClass
{
    private object LockingObject = new object();

    void DoSomething()
    {
        lock(LockingObject)
        {
            //do something
        }
    }
}

Como devemos nomear LockingObjectaqui? Considere também não apenas o nome da variável, mas como ela fica no código ao bloquear.

Eu já vi vários exemplos, mas aparentemente nenhum conselho sólido:

1. Muitos usos de SyncRoot(e variações como _syncRoot).

   • Exemplo de código: lock(SyncRoot) ,lock(_syncRoot)
   • Isso parece ser influenciado pela SyncLockdeclaração equivalente do VB , a SyncRootpropriedade que existe em algumas das classes ICollection e parte de algum tipo de padrão de design do SyncRoot (o que sem dúvida é uma má idéia)
   • Estar em um contexto de C #, não tenho certeza se eu gostaria de ter uma nomeação VBish. Pior ainda, no VB, nomear a variável da mesma forma que a palavra-chave. Não tenho certeza se isso seria uma fonte de confusão ou não.

2. thisLocke lockThisdos artigos do MSDN: Instrução C # lock , Instrução VB SyncLock

   • Exemplo de código: lock(thisLock) ,lock(lockThis)
   • Não tenho certeza se estes foram nomeados minimamente puramente para o exemplo ou não
   • Meio estranho se estivermos usando isso dentro de uma staticclasse / método.
   • EDIT: O artigo da Wikipedia sobre bloqueios também usa essa nomeação como exemplo

3. Vários usos de PadLock(de revestimento variado)

   • Exemplo de código: lock(PadLock) ,lock(padlock)
   • Nada mal, mas meu único problema é que, sem surpresa, invoca a imagem de um "cadeado" físico que eu tendem a não associar ao conceito abstrato de rosqueamento .

4. Nomeando o bloqueio com base no que ele pretende bloquear

   • Código de exemplo: lock(messagesLock) , lock(DictionaryLock),lock(commandQueueLock)
   • No exemplo da página VB SyncRoot MSDN, ele tem um simpleMessageListexemplo com um messagesLockobjeto particular
   • Não acho que seja uma boa ideia nomear o bloqueio com o tipo que você está bloqueando ("DictionaryLock"), pois esse é um detalhe da implementação que pode mudar. Prefiro nomear o conceito / objeto que você está bloqueando ("messagesLock" ou "commandQueueLock")
   • Curiosamente, raramente vejo essa convenção de nomenclatura para bloquear objetos em amostras de código online ou no StackOverflow.

5. (EDIT) A especificação C # na seção "8.12 The Lock Statement" tem um exemplo desse padrão e o nomeia synchronizationObject

   • Exemplo de código: lock(SynchronizationObject) ,lock(synchronizationObject)

Pergunta: Qual é a sua opinião geralmente sobre como nomear objetos de bloqueio privados ?

Recentemente, comecei a nomeá-los ThreadLock(assim como a opção 3), mas estou me perguntando esse nome.

Eu frequentemente uso esse padrão de bloqueio (no exemplo de código fornecido acima) em todos os meus aplicativos, então pensei que faria sentido obter uma opinião / discussão mais profissional sobre uma convenção de nomenclatura sólida para eles. Obrigado!

Adotei o hábito de chamá-lo SomeResourceLockonde SomeResourceé o bloqueio que você precisa para acessar / atualizar, ou seja (perdoe qualquer problema de thread, isso é apenas uma ilustração)

public class ProcessDataInQueue
{
    private static Queue<Data> _dataQueue = new Queue<Data>();
    private static object _dataQueueLock = new Object();

    public void AddOneItem(Data itemToAdd)
    {
        lock(_dataQueueLock)
        {
            _dataQueue.Enqueue(itemToAdd);
        }
    }

    public void ProcessOneItem()
    {
        Data itemToProcess = null;
        lock(_dataQueueLock)
        {
            itemToProcess = _dataQueue.Dequeue();
        }
        // ... process itemToProcess
    }
}

Adquiri esse hábito depois de ter aulas em que posso ter vários bloqueios para recursos diferentes, então nomeio o objeto de bloqueio com base em quais recursos ele está bloqueando o acesso. Às vezes, um objeto pode estar bloqueando vários recursos; nesse caso, eu tentaria fazer com que os nomes respeitassem isso de alguma maneira, para que o leitor saiba que "outros bloqueios para esses recursos individuais também estarão em conflito com esse bloqueio".

Eu costumo chamá-lo locker, mas como é privado, acredito que seja um detalhe de implementação pouco importante. Primeira regra geral, use os padrões da sua equipe / empresa. Se não houver um, bem, por favor, fazer um e usá-lo, mas em fazê-lo, manter as coisas simples. Se sua classe tiver um único objeto de bloqueio, chamá-lo fooé bom o suficiente. Se você tem muitos, uma boa ordem de negócios pode apenas revisitar o design dessa classe primeiro para ver se está fazendo muitas coisas diferentes. Mas, se não, o nome se tornará importante, como neste exemplo completamente artificial:

public sealed class CustomerOrders
{
    private readonly object customerLocker = new object();

    private readonly object orderLocker = new object();

    public IEnumerable<Customer> Customers
    {
        get
        {
            lock (this.cutomerLocker)
            lock (this.orderLocker)
            {
                // stuff...
            }
        }

        set
        {
            lock (this.cutomerLocker)
            lock (this.orderLocker)
            {
                // other stuff...
            }
        }
    }

    public IEnumerable<Order> Orders
    {
        get
        {
            lock (this.orderLocker)
            {
                // stuff...
            }
        }

        set
        {
            lock (this.cutomerLocker)
            {
                // different stuff...
            }
        }
    }
}

Eu sempre usei lck_. Dessa forma, se você pressionar Ctrl + f 'lck', deverá encontrar apenas os bloqueios, enquanto 'lock' também encontrará coisas como 'clock'.

Coisas como lockThis e Padlock são adequadas para portfólios uni, mas para projetos adequados, você realmente deve usar nomes semânticos para que, ao examinar as declarações, saiba o que o objeto realmente faz sem pesquisar no código.