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.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
AggregateException este un „plic” pentru una sau mai multe excepții produse de task-uri. Apare când aștepți un Task în mod blocant: task.Result, task.Wait(), Task.WaitAll(...). Textul din paranteză, (Moneda USD nu este suportata), este mesajul excepției interne, iar linia ---> System.ArgumentException: ... din stack trace îi arată tipul. Aceea este eroarea pe care trebuie s-o înțelegi și s-o repari.
De ce contează: un catch (ArgumentException) nu prinde un AggregateException, deci tratarea erorilor pe care ai scris-o nu funcționează. Cu await, excepția internă este aruncată direct, cu tipul ei, iar catch-urile obișnuite merg.
În plus, .Result și .Wait() blochează firul curent; în aplicații cu interfață grafică sau în ASP.NET clasic pot produce blocaje complete (deadlock). Regula practică: folosește await peste tot și lasă async să se propage până la Main.
De ce apare: cauzele frecvente
1.Result pe o metodă care eșuează
decimal curs = Curs("USD").Result;
async Task<decimal> Curs(string moneda)
{
if (moneda != "EUR") throw new ArgumentException($"Moneda {moneda} nu este suportata");
await Task.Delay(10);
return 4.97m;
}try
{
decimal curs = await Curs("USD");
}
catch (ArgumentException ex)
{
Console.WriteLine(ex.Message);
}
async Task<decimal> Curs(string moneda)
{
if (moneda != "EUR") throw new ArgumentException($"Moneda {moneda} nu este suportata");
await Task.Delay(10);
return 4.97m;
}await aruncă ArgumentException direct, iar catch o prinde cu tipul ei.
2catch care nu prinde nimic din cauza .Wait()
try { Salveaza().Wait(); }
catch (InvalidOperationException) { Console.WriteLine("Eroare la salvare"); }
async Task Salveaza() { await Task.Delay(1); throw new InvalidOperationException("Disc plin"); }try { await Salveaza(); }
catch (InvalidOperationException) { Console.WriteLine("Eroare la salvare"); }
async Task Salveaza() { await Task.Delay(1); throw new InvalidOperationException("Disc plin"); }Cu .Wait(), excepția vine ca AggregateException și scapă de catch (InvalidOperationException).
Repară eroarea, direct în pagină
Programul convertește prețuri în lei, dar se oprește cu System.AggregateException: One or more errors occurred. (Moneda GBP nu este suportata), iar catch (ArgumentException) nu o prinde. Repară apelul, astfel încât monedele cunoscute să fie convertite, iar pentru GBP să se afișeze mesajul excepției.
foreach (string moneda in new[] { "EUR", "GBP", "USD" })
{
try
{
decimal curs = Curs(moneda).Result;
Console.WriteLine($"100 {moneda} = {100 * curs:F2} lei");
}
catch (ArgumentException ex)
{
Console.WriteLine(ex.Message);
}
}
async Task<decimal> Curs(string moneda)
{
if (moneda == "GBP") throw new ArgumentException($"Moneda {moneda} nu este suportata");
await Task.Delay(10);
return moneda == "EUR" ? 4.97m : 4.58m;
}100 EUR = 497.00 lei Moneda GBP nu este suportata 100 USD = 458.00 lei
Indiciu
Înlocuiește .Result cu await, ca excepția să ajungă cu tipul ei original.
Reparația
foreach (string moneda in new[] { "EUR", "GBP", "USD" })
{
try
{
decimal curs = await Curs(moneda);
Console.WriteLine($"100 {moneda} = {100 * curs:F2} lei");
}
catch (ArgumentException ex)
{
Console.WriteLine(ex.Message);
}
}
async Task<decimal> Curs(string moneda)
{
if (moneda == "GBP") throw new ArgumentException($"Moneda {moneda} nu este suportata");
await Task.Delay(10);
return moneda == "EUR" ? 4.97m : 4.58m;
}De ce merge
.Result împacheta ArgumentException într-un AggregateException, iar catch (ArgumentException) nu se potrivea cu tipul plicului, deci excepția oprea programul. Cu await Curs(moneda), excepția internă este aruncată direct, catch-ul o prinde și afișează mesajul, iar bucla continuă. Pentru EUR și USD conversia merge normal.
Alte forme ale mesajului
System.AggregateException: One or more errors occurred. (The input string 'x' was not in a correct format.)Unhandled exception. System.AggregateException: One or more errors occurred. (Serviciu indisponibil)
Cum o eviți pe viitor
- Așteaptă task-urile cu
await, nu cu.Result,.Wait()sauGetAwaiter().GetResult()acolo unde poți evita. - Dacă ești obligat să prinzi un
AggregateException, uită-te înex.InnerExceptions(sau foloseșteex.Flatten()), nu doar înex.Message. - La
Task.WhenAll,awaitaruncă prima excepție; celelalte sunt întask.Exception.InnerExceptions. - Citește întotdeauna linia
--->din stack trace: acolo e cauza reală.
Întrebări frecvente
Cum aflu excepția reală?
Din linia ---> Tip: mesaj din stack trace sau, în cod, din ex.InnerException / ex.InnerExceptions. Mesajul din paranteză e chiar mesajul ei.
De ce await nu împachetează excepția?
Pentru că await a fost gândit să se comporte ca un apel obișnuit: despachetează și aruncă prima excepție internă, cu stack trace-ul păstrat. .Result și .Wait() sunt mai vechi și păstrează plicul.
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.Threading.Tasks.TaskCanceledException: A task was canceled. O operație asincronă a fost anulată printr-un `CancellationToken` (de utilizator, de un timeout cu `CancelAfter` sau de `HttpClient.Timeout`) și nu ai tratat anularea. Prinde `OperationCanceledException` acolo unde anularea e un caz normal sau mărește timeout-ul dacă operația chiar are nevoie de mai mult timp. System.FormatException: The input string 'abc' was not in a correct format. `int.Parse` (sau `double.Parse`, `Convert.ToInt32`) a primit un text care nu este un număr valid: litere, șir gol, zecimale într-un `int`. Folosește `int.TryParse(text, out int n)` și tratează cazul în care întoarce `false`. Î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.
