...
Eroare C# · Async, task-uri și anulare

System.Threading.SemaphoreFullException: Adding the specified count to the semaphore would cause it to exceed its maximum count.

Pe scurt

Ai apelat `Release()` pe un `SemaphoreSlim` de mai multe ori decât `Wait` / `WaitAsync`, de obicei de două ori în același bloc (o dată în `try`, o dată în `finally`) sau fără să fi intrat. Fiecare `Release()` trebuie să corespundă unui `Wait` reușit: pune-l o singură dată, în `finally`, după un `await WaitAsync()` reușit.

Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la

Ce înseamnă

Un SemaphoreSlim(initial, maxim) limitează câte bucăți de cod pot rula în același timp: WaitAsync() ocupă un loc, Release() îl eliberează. Dacă eliberezi mai multe locuri decât maximul permis, semaforul ar ajunge să aibă mai multe locuri libere decât capacitatea, iar .NET aruncă System.Threading.SemaphoreFullException: Adding the specified count to the semaphore would cause it to exceed its maximum count..

Excepția indică aproape mereu un dezechilibru între Wait și Release:

  • Release() apare și în try, și în finally;
  • WaitAsync(timeout) a întors false (nu s-a intrat), dar finally face totuși Release();
  • WaitAsync() e chemat în interiorul try, iar o excepție sau o anulare apare înainte să se intre, dar finally eliberează.

Modelul corect: await sem.WaitAsync(); înainte de try, apoi try { ... } finally { sem.Release(); }. Cu timeout: if (!await sem.WaitAsync(t)) return; înainte de try. Fără maxim explicit (new SemaphoreSlim(1)), excepția nu apare, dar dezechilibrul tot e o greșeală: permite mai multe intrări simultane decât ai vrut.

De ce apare: cauzele frecvente

1Release dublu, în try și în finally

Greșit
C#
await sem.WaitAsync();
try
{
    Proceseaza();
    sem.Release();
}
finally { sem.Release(); }
Corect
C#
await sem.WaitAsync();
try
{
    Proceseaza();
}
finally { sem.Release(); }

Un singur Release(), în finally, pentru un singur WaitAsync().

2Release chiar dacă nu s-a intrat

Greșit
C#
try
{
    if (!await sem.WaitAsync(100)) return;
    Proceseaza();
}
finally { sem.Release(); }
Corect
C#
if (!await sem.WaitAsync(100)) return;
try
{
    Proceseaza();
}
finally { sem.Release(); }

Blocul try începe abia după ce intrarea a reușit.

3WaitAsync în interiorul try

Greșit
C#
try
{
    await sem.WaitAsync(token);
    await LucreazaAsync();
}
finally { sem.Release(); }
Corect
C#
await sem.WaitAsync(token);
try
{
    await LucreazaAsync();
}
finally { sem.Release(); }

Dacă WaitAsync e anulat, nu s-a intrat, deci nu trebuie eliberat nimic.

Repară tu

Repară eroarea, direct în pagină

Programul procesează fișiere pe rând, protejat de un SemaphoreSlim(1, 1), dar se oprește cu System.Threading.SemaphoreFullException: Adding the specified count to the semaphore would cause it to exceed its maximum count. Repară metoda ca programul să afișeze Procesez a.csv, Procesez b.csv și Gata: 2 fisiere.

Codul care dă eroarea
C#
var sem = new SemaphoreSlim(1, 1);
int procesate = 0;
foreach (var f in new[] { "a.csv", "b.csv" })
    await Proceseaza(f);
Console.WriteLine($"Gata: {procesate} fisiere");

async Task Proceseaza(string fisier)
{
    await sem.WaitAsync();
    try
    {
        await Task.Delay(10);
        Console.WriteLine($"Procesez {fisier}");
        procesate++;
        sem.Release();
    }
    finally
    {
        sem.Release();
    }
}
După reparație, programul afișează
Procesez a.csv
Procesez b.csv
Gata: 2 fisiere
Indiciu

Fiecărui WaitAsync() reușit îi corespunde exact un Release().

Cum o eviți pe viitor

  • Folosește mereu modelul: await sem.WaitAsync(); urmat de try { ... } finally { sem.Release(); }.
  • Dă un maxim explicit (new SemaphoreSlim(3, 3)): un Release în plus devine imediat excepție, nu o greșeală ascunsă.
  • Pentru excludere simplă poți folosi lock (cod sincron) sau o clasă ajutătoare care face Release în Dispose.

Întrebări frecvente

Ce înseamnă cele două numere din constructor?

Primul e câte locuri sunt libere la început, al doilea e capacitatea maximă. new SemaphoreSlim(1, 1) e un „lacăt” pentru cod asincron: o singură intrare odată.

Pot folosi lock în loc de SemaphoreSlim?

Nu în cod cu await: nu poți face await într-un bloc lock (eroarea CS1996). SemaphoreSlim cu WaitAsync e varianta pentru cod asincron.

Erori înrudite

← Toate erorile C#

Tudor Andrei Dumitrescu
Cine a explicat eroarea

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Fiecare eroare de aici a fost reprodusă în editorul nostru: codul greșit chiar dă mesajul din titlu, iar reparația chiar funcționează.

Î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.