Quali sono le implicazioni dell'uso del blocco (typeof (stringa))

Question

Abbiamo avuto una discussione sul lavoro riguardante il blocco e cosa accade esattamente. Il codice che ha attivato questa discussione è:

 string name = (string)context.Cache[key]; 

     if (String.IsNullOrEmpty(name)){ 

      lock (typeof(string)){ 
       name = (string)context.Cache[key]; 
       //.. other code to get the name and then store in the cache 
      } 
     } 

Io vedo questo come straight-forward: cerca un valore nella cache, se non è lì poi ottenere un blocco in modo da niente altro interrompe mentre il codice prende il nome e lo memorizza nella cache.

La nostra discussione si è concentrata sul fatto che (typeof (stringa)) sia il modo migliore di fare le cose e che cosa è esattamente ciò che fa.

La mia domanda è cosa fa esattamente lock (typeof (stringa))? Crea una stringa locale da utilizzare come lock o crea qualcosa con un ambito più ampio e quindi potenzialmente non sicuro.

MSDN lock statement

Answer 1

Se si blocca su un Type vorrà dire che avete un'esclusione accesso reciproco sulla base di tale istanza del Type. Le implicazioni sono che due thread nell'applicazione che eseguono ciò si bloccano inavvertitamente l'un l'altro o causano deadlock imprevisti.

Ricorda, typeof(someType) restituisce solo un'istanza Type.

In genere è consigliabile dedicare un oggetto al blocco di un processo complesso, ad esempio la dichiarazione di un readonly object nella classe. Se il lucchetto ha solo bisogno di aggirare qualche accesso a una variabile privata, diciamo una collezione, quindi bloccare quella raccolta è abbastanza buona.

Answer 2

Come mostrato nella pagina si collega a:

In generale, evitare di bloccare su un tipo di pubblico, o di casi che esulano dal controllo del codice. Il comune costrutto lock (this), lock (typeof (MyType)) e lock ("myLock") violano questa linea guida:

lock (typeof (MyType)) è un problema se MyType è pubblicamente accessibile.

Answer 3

La mia domanda è cosa fa esattamente lock (typeof (stringa))?

Si blocca sull'oggetto Type cui dal riferimento che i rendimenti typeof operatore.

Ciò significa alcun codice che fa la stessa cosa ovunque all'interno dello stesso processo (o almeno lo stesso dominio di applicazione) condivideranno lo stesso blocco. Mi sembra una cattiva idea.

vorrei suggerire si crea un oggetto solo per il bloccaggio su:

private static readonly object CacheLock = new object(); 

... 

lock (CacheLock) 
{ 
    ... 
} 

In questo modo si può facilmente vedere cosa sta succedendo per bloccare su tale oggetto.