System.NotSupportedException: Deserialization of interface or abstract types is not supported. Type 'IProdus'. Path: $ | LineNumber: 0 | BytePositionInLine: 1.
Ai cerut deserializarea într-o interfață sau o clasă abstractă (`Deserialize<IProdus>`, o proprietate `List<IForma>`). Serializatorul nu știe ce clasă concretă să creeze. Deserializează într-o clasă concretă sau, pentru ierarhii, marchează baza cu `[JsonPolymorphic]` și `[JsonDerivedType]` și include în JSON un discriminator (`$type`).
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Ca să creeze un obiect din JSON, System.Text.Json are nevoie de o clasă concretă, pe care o poate instanția. O interfață (IProdus) sau o clasă abstract (Forma) nu pot fi create cu new, iar JSON-ul simplu nu spune care dintre clasele derivate ar trebui folosită.
De aceea primești NotSupportedException: Deserialization of interface or abstract types is not supported. Type 'IProdus'. Partea Path arată unde e obiectul în JSON: $ pentru rădăcină, $.Produse[0] pentru primul element dintr-o proprietate.
Cazuri tipice:
JsonSerializer.Deserialize<IProdus>(json)sauDeserialize<List<IProdus>>;- o clasă cu o proprietate de tip interfață (
public IAdresa Adresa { get; set; }); - o ierarhie (
Cerc,Patratderivate dinForma) salvată ca listă deForma.
Din .NET 7 poți descrie ierarhia cu atribute: [JsonPolymorphic] și [JsonDerivedType(typeof(Cerc), "cerc")] pe clasa de bază. La serializare se adaugă câmpul $type, iar la deserializare el decide ce clasă se creează. Serializarea interfețelor, în schimb, merge fără probleme.
De ce apare: cauzele frecvente
1Deserializare direct în interfață
var p = JsonSerializer.Deserialize<IProdus>(json);var p = JsonSerializer.Deserialize<Carte>(json);Clasa concretă Carte poate fi creată și completată.
2Proprietate de tip interfață într-un DTO
class Comanda
{
public IAdresa Livrare { get; set; }
}class Comanda
{
public Adresa Livrare { get; set; }
}Obiectele de transfer (DTO) folosesc tipuri concrete. Interfețele rămân în logica aplicației.
3Ierarhie de clase
abstract class Forma { }
class Cerc : Forma { public double Raza { get; set; } }[JsonPolymorphic]
[JsonDerivedType(typeof(Cerc), "cerc")]
abstract class Forma { }
class Cerc : Forma { public double Raza { get; set; } }Cu atributele polimorfice, JSON-ul conține "$type":"cerc", iar serializatorul știe ce clasă să creeze.
Repară eroarea, direct în pagină
Programul încarcă din JSON o listă de cărți folosind interfața IProdus, dar se oprește cu System.NotSupportedException: Deserialization of interface or abstract types is not supported. Type 'IProdus'. Repară deserializarea ca programul să afișeze Ion: 30 lei, Enigma Otiliei: 40 lei și Total: 70 lei, fără să schimbi interfața.
using System.Text.Json;
string json = "[{\"Nume\":\"Ion\",\"Pret\":30},{\"Nume\":\"Enigma Otiliei\",\"Pret\":40}]";
List<IProdus> produse = JsonSerializer.Deserialize<List<IProdus>>(json);
foreach (var p in produse)
Console.WriteLine($"{p.Nume}: {p.Pret} lei");
Console.WriteLine($"Total: {produse.Sum(p => p.Pret)} lei");
interface IProdus
{
string Nume { get; }
decimal Pret { get; }
}
class Carte : IProdus
{
public string Nume { get; set; }
public decimal Pret { get; set; }
}Ion: 30 lei Enigma Otiliei: 40 lei Total: 70 lei
Indiciu
JSON-ul conține cărți; deserializează în clasa concretă și folosește apoi obiectele prin interfață.
Reparația
using System.Text.Json;
string json = "[{\"Nume\":\"Ion\",\"Pret\":30},{\"Nume\":\"Enigma Otiliei\",\"Pret\":40}]";
List<IProdus> produse = JsonSerializer.Deserialize<List<Carte>>(json).Cast<IProdus>().ToList();
foreach (var p in produse)
Console.WriteLine($"{p.Nume}: {p.Pret} lei");
Console.WriteLine($"Total: {produse.Sum(p => p.Pret)} lei");
interface IProdus
{
string Nume { get; }
decimal Pret { get; }
}
class Carte : IProdus
{
public string Nume { get; set; }
public decimal Pret { get; set; }
}De ce merge
Serializatorul nu poate crea obiecte de tipul unei interfețe, pentru că nu știe ce clasă concretă să folosească. Lista e deserializată acum ca List<Carte>, adică într-o clasă care poate fi creată, apoi e convertită la List<IProdus> cu Cast<IProdus>(), iar restul programului lucrează în continuare prin interfață.
Alte forme ale mesajului
System.NotSupportedException: Deserialization of interface or abstract types is not supported. Type 'Forma'. Path: $[0] | LineNumber: 0 | BytePositionInLine: 2.Newtonsoft.Json.JsonSerializationException: Could not create an instance of type IProdus. Type is an interface or abstract class and cannot be instantiated.
Cum o eviți pe viitor
- Folosește clase concrete (sau record-uri) pentru tot ce intră și iese ca JSON.
- Pentru ierarhii, declară clasele derivate cu
[JsonDerivedType]pe clasa de bază. - Convertește DTO-urile în obiectele domeniului după deserializare, nu încerca să deserializezi direct în interfețe.
Întrebări frecvente
De ce serializarea merge, dar deserializarea nu?
La serializare obiectul există deja, iar serializatorul îi citește proprietățile. La deserializare trebuie să creeze un obiect nou, iar dintr-o interfață nu se poate crea nimic.
Ce e $type din JSON?
E discriminatorul adăugat de [JsonPolymorphic]: un text care spune ce clasă derivată reprezintă obiectul. Trebuie să fie primul câmp din obiect (sau activezi AllowOutOfOrderMetadataProperties în .NET 9).
Erori înrudite
error CS0144: Cannot create an instance of the abstract type or interface 'Forma' Ai scris `new` pentru o clasă `abstract` sau pentru o interfață. Acestea descriu doar ce trebuie să aibă un obiect, nu pot fi create direct. Creează un obiect dintr-o clasă concretă care le moștenește sau le implementează: `Forma f = new Cerc(2);`. System.NotSupportedException: Deserialization of types without a parameterless constructor, a singular parameterized constructor, or a parameterized constructor annotated with 'JsonConstructorAttribute' is not supported. Type 'Produs'. Path: $ | LineNumber: 0 | BytePositionInLine: 1. `System.Text.Json` nu știe cum să creeze obiectul: clasa nu are constructor fără parametri și are mai mulți constructori cu parametri. Adaugă un constructor public fără parametri sau marchează constructorul de folosit cu `[JsonConstructor]`. System.Text.Json.JsonException: A possible object cycle was detected. This can either be due to a cycle or if the object depth is larger than the maximum allowed depth of 64. Consider using ReferenceHandler.Preserve on JsonSerializerOptions to support cycles. Obiectul pe care îl serializezi în JSON conține o buclă de referințe: un client are comenzi, iar fiecare comandă are înapoi clientul. Serializatorul ar scrie la nesfârșit. Ignoră legătura inversă cu `[JsonIgnore]`, folosește `ReferenceHandler.IgnoreCycles` sau serializează un obiect simplu (DTO) fără bucle. Î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.
