error CS1996: Cannot await in the body of a lock statement
Ai scris `await` în interiorul unui bloc `lock`. Un `lock` trebuie eliberat de același fir care l-a luat, iar după `await` codul poate continua pe alt fir. Înlocuiește `lock` cu `SemaphoreSlim(1, 1)`: `await sem.WaitAsync(); try { ... } finally { sem.Release(); }`.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
lock (obiect) { ... } folosește Monitor, un mecanism legat de firul de execuție care a intrat în bloc: doar același fir îl poate elibera. Un await suspendă metoda, iar continuarea poate rula pe alt fir din thread pool. Dacă await ar fi permis într-un lock, eliberarea s-ar putea face de pe un fir greșit sau lacătul ar rămâne ținut pe durata unei operații lungi.
De aceea compilatorul interzice combinația și raportează CS1996: Cannot await in the body of a lock statement.
Pentru cod asincron, echivalentul lui lock este SemaphoreSlim cu un singur loc:
static readonly SemaphoreSlim sem = new(1, 1);
await sem.WaitAsync();
try
{
await SalveazaAsync();
}
finally
{
sem.Release();
}finally garantează eliberarea, chiar dacă apare o excepție. O altă variantă este să scoți await din lock: faci partea asincronă înainte sau după, iar în lock păstrezi doar modificarea rapidă a datelor comune.
De ce apare: cauzele frecvente
1await într-un lock
lock (blocare)
{
await Task.Delay(10);
contor++;
}await sem.WaitAsync();
try
{
await Task.Delay(10);
contor++;
}
finally
{
sem.Release();
}SemaphoreSlim se poate aștepta asincron și nu e legat de firul care l-a luat.
2Partea asincronă poate sta în afara lock-ului
lock (blocare)
{
var pret = await CitestePretAsync();
total += pret;
}var pret = await CitestePretAsync();
lock (blocare)
{
total += pret;
}Doar modificarea datelor comune are nevoie de protecție, iar ea e sincronă.
3Task.Wait ca ocolire
lock (blocare)
{
SalveazaAsync().Wait();
}await sem.WaitAsync();
try { await SalveazaAsync(); }
finally { sem.Release(); }.Wait() compilează, dar blochează firul și poate produce deadlock-uri. Folosește varianta asincronă.
Repară eroarea, direct în pagină
Metoda SalveazaAsync salvează pe rând comenzile și trebuie protejată ca două salvări să nu se suprapună, dar programul nu compilează: error CS1996: Cannot await in the body of a lock statement. Repară protecția ca programul să afișeze Salvat 1, Salvat 2, Salvat 3 și Total salvate: 3.
var blocare = new object();
int salvate = 0;
for (int i = 1; i <= 3; i++)
await SalveazaAsync(i);
Console.WriteLine($"Total salvate: {salvate}");
async Task SalveazaAsync(int id)
{
lock (blocare)
{
await Task.Delay(10);
salvate++;
Console.WriteLine($"Salvat {id}");
}
}Salvat 1 Salvat 2 Salvat 3 Total salvate: 3
Indiciu
Folosește un SemaphoreSlim cu un singur loc, așteptat cu WaitAsync și eliberat în finally.
Reparația
var sem = new SemaphoreSlim(1, 1);
int salvate = 0;
for (int i = 1; i <= 3; i++)
await SalveazaAsync(i);
Console.WriteLine($"Total salvate: {salvate}");
async Task SalveazaAsync(int id)
{
await sem.WaitAsync();
try
{
await Task.Delay(10);
salvate++;
Console.WriteLine($"Salvat {id}");
}
finally
{
sem.Release();
}
}De ce merge
lock nu poate conține await, pentru că lacătul e legat de firul care l-a luat, iar după await codul poate continua pe alt fir. SemaphoreSlim(1, 1) lasă o singură salvare să intre o dată, se așteaptă asincron cu WaitAsync și e eliberat în finally, chiar dacă apare o excepție.
Cum o eviți pe viitor
- În codul
async, foloseșteSemaphoreSlimîn loc delockpentru secțiunile care conținawait. - Eliberează semaforul întotdeauna în
finally. - Ține secțiunile protejate cât mai scurte: calculează sau descarcă în afara lor și protejează doar scrierea în datele comune.
- Pentru contoare simple,
Interlocked.Increment(ref contor)nu are nevoie de lacăt.
Întrebări frecvente
Și în C# 13 cu noul tip Lock?
Tipul System.Threading.Lock din .NET 9 se folosește tot cu lock, iar regula rămâne: nu poți folosi await în interiorul blocului.
SemaphoreSlim(1, 1) e la fel de rapid ca lock?
E puțin mai lent când nu există concurență, dar nu blochează firul cât așteaptă, ceea ce contează mult mai mult în aplicațiile web și desktop.
Erori înrudite
error CS4032: The 'await' operator can only be used within an async method. Consider marking this method with the 'async' modifier and changing its return type to 'Task<int>'. Ai folosit `await` într-o metodă care nu e marcată `async`. Adaugă `async` în semnătură și schimbă tipul de retur după sugestia din mesaj: `int` devine `Task<int>`, `void` devine `Task`. Apoi apelează metoda tot cu `await`. System.AggregateException: One or more errors occurred. (Moneda USD nu este suportata) Un `Task` s-a terminat cu o excepție, iar tu i-ai citit rezultatul cu `.Result` sau `.Wait()`. Acestea împachetează excepția reală într-un `AggregateException`; mesajul ei apare în paranteză și pe linia `--->`. Folosește `await` (care aruncă direct excepția originală) și prinde acel tip de excepție. error CS1988: Async methods cannot have ref, in or out parameters Ai declarat o metodă `async` cu un parametru `out`, `ref` sau `in`, de exemplu o variantă „asincronă” de `TryParse`. Metodele async nu pot avea astfel de parametri. Întoarce rezultatele într-un tuplu: `Task<(bool Ok, int Valoare)>`, sau într-un obiect. Învață C# de la zero, cu exerciții la fiecare lecție
Curs C#: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 15 lecții sunt gratuite.
