error CS0121: The call is ambiguous between the following methods or properties: 'Calc.Afiseaza(string)' and 'Calc.Afiseaza(int[])'
Apelul se potrivește la fel de bine cu două variante supraîncărcate ale metodei, iar compilatorul nu poate alege. Cazuri tipice: argumentul `null` (merge la orice tip referință) sau parametri opționali care fac două variante apelabile la fel. Fă apelul neambiguu: cast (`(string)null`), argument numit sau metode cu nume diferite.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Când o metodă are mai multe variante (supraîncărcări), compilatorul o alege pe cea mai potrivită pentru argumentele date. Dacă două variante sunt la fel de bune și niciuna nu e „mai specifică”, primești CS0121, cu cele două semnături numite în mesaj.
Situații frecvente:
nullca argument:Afiseaza(null)se potrivește și custring, și cuint[], și cu orice clasă;- parametri opționali:
Pret(decimal p, int cant = 1)șiPret(decimal p, decimal reducere = 0)pot fi apelate amândouă caPret(10m); - conversii numerice în sens opus:
F(int, long)șiF(long, int)apelate cuF(1, 1).
Repararea: transmite un argument cu tip clar (cast sau variabilă tipizată), folosește argumente numite (Pret(10m, cant: 2)), elimină parametrii opționali care se suprapun sau redenumește metodele. Ultima variantă e de obicei cea mai curată.
De ce apare: cauzele frecvente
1null trimis unei metode supraîncărcate
Calc.Afiseaza(null);
class Calc
{
public static void Afiseaza(string s) => Console.WriteLine(s);
public static void Afiseaza(int[] v) => Console.WriteLine(v?.Length);
}Calc.Afiseaza((string)null);
class Calc
{
public static void Afiseaza(string s) => Console.WriteLine(s);
public static void Afiseaza(int[] v) => Console.WriteLine(v?.Length);
}Cast-ul spune ce tip are null, deci compilatorul poate alege varianta cu string.
2Parametri opționali care se suprapun
Console.WriteLine(Cos.Pret(10m));
class Cos
{
public static decimal Pret(decimal p, int cant = 1) => p * cant;
public static decimal Pret(decimal p, decimal reducere = 0) => p - reducere;
}Console.WriteLine(Cos.Pret(10m));
class Cos
{
public static decimal Pret(decimal p, int cant = 1) => p * cant;
public static decimal PretRedus(decimal p, decimal reducere) => p - reducere;
}Cu un singur argument, ambele variante erau apelabile. Numele diferite elimină ambiguitatea.
Repară eroarea, direct în pagină
Clasa Livrare are două metode Cost, una cu număr de colete și una cu greutate, ambele cu parametru opțional. Apelul Livrare.Cost("Cluj") dă error CS0121: The call is ambiguous between the following methods or properties. Fă apelurile neambigue, astfel încât programul să afișeze costul pentru 1 colet și costul pentru 2.5 kg.
Console.WriteLine($"Colete: {Livrare.Cost("Cluj")}");
Console.WriteLine($"Greutate: {Livrare.Cost("Cluj", 2.5)}");
class Livrare
{
public static decimal Cost(string oras, int colete = 1) => colete * 15m;
public static decimal Cost(string oras, double kg = 1) => (decimal)kg * 8m;
}Colete: 15 Greutate: 20.0
Indiciu
Poți redenumi a doua metodă (de exemplu CostGreutate) și actualiza apelul ei.
Reparația
Console.WriteLine($"Colete: {Livrare.Cost("Cluj")}");
Console.WriteLine($"Greutate: {Livrare.CostGreutate("Cluj", 2.5)}");
class Livrare
{
public static decimal Cost(string oras, int colete = 1) => colete * 15m;
public static decimal CostGreutate(string oras, double kg = 1) => (decimal)kg * 8m;
}De ce merge
Cu un singur argument, ambele metode Cost puteau fi apelate (al doilea parametru avea valoare implicită), așa că apelul era ambiguu. După redenumirea variantei cu greutate în CostGreutate, Cost("Cluj") are o singură potrivire: 1 colet × 15 = 15. Al doilea apel calculează 2.5 × 8 = 20.
Alte forme ale mesajului
error CS0121: The call is ambiguous between the following methods or properties: 'Cos.Pret(decimal, int)' and 'Cos.Pret(decimal, decimal)'
Cum o eviți pe viitor
- Evită supraîncărcările care diferă doar printr-un parametru opțional.
- Nu trimite
nullliteral unei metode cu mai multe variante; folosește o variabilă cu tip declarat. - Când variantele fac lucruri diferite, dă-le nume diferite (
Pret,PretRedus). - Folosește argumente numite pentru apelurile cu mulți parametri opționali.
Întrebări frecvente
De ce Afiseaza("text") merge, dar Afiseaza(null) nu?
"text" are tipul string, deci se potrivește exact cu o variantă. null nu are un tip propriu și poate fi convertit la oricare tip referință.
Ce înseamnă „more specific”?
Dacă un argument se potrivește cu object și cu string, string e mai specific și câștigă. Ambiguitatea apare când niciuna dintre variante nu e mai specifică decât cealaltă.
Erori înrudite
error CS1503: Argument 1: cannot convert from 'string' to 'int' Trimiți unei metode un argument de alt tip decât cel pe care îl cere parametrul: aici un `string` unde se așteaptă `int`. Convertește valoarea înainte de apel (`int.Parse`) sau verifică ordinea argumentelor. error CS1501: No overload for method 'Max' takes 3 arguments Apelezi o metodă cu un număr de argumente pentru care nu există nicio variantă: de exemplu `Math.Max(a, b, c)`, deși `Math.Max` primește exact două. Verifică ce variante are metoda și trimite numărul corect de argumente (sau combină apelurile). error CS0111: Type 'Calc' already defines a member called 'Aduna' with the same parameter types Ai două metode cu același nume și aceleași tipuri de parametri în aceeași clasă. Supraîncărcarea funcționează doar dacă parametrii diferă ca tip sau număr; numele parametrilor și tipul de retur nu contează. Redenumește una dintre metode sau schimbă-i parametrii. Î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.
