JSON.Net Selbstreferenzierende Schleife erkannt

Ich habe eine MSSQL-Datenbank für meine Website in 4 Tabellen.

Wenn ich das benutze:

public static string GetAllEventsForJSON()
{
    using (CyberDBDataContext db = new CyberDBDataContext())
    {
        return JsonConvert.SerializeObject((from a in db.Events where a.Active select a).ToList(), new JavaScriptDateTimeConverter());
    }
}

Der Code führt zu folgendem Fehler:

Newtonsoft.Json.JsonSerializationException: Selbstreferenzierende Schleife für Eigenschaft 'CyberUser' vom Typ 'DAL.CyberUser' erkannt. Pfad '[0] .EventRegistrations [0] .CyberUser.UserLogs [0]'.

Ich hatte gerade das gleiche Problem mit Eltern / Kind-Sammlungen und fand den Beitrag, der meinen Fall gelöst hat. Ich wollte nur die Liste der übergeordneten Sammlungselemente anzeigen und benötigte keine der untergeordneten Daten. Daher habe ich Folgendes verwendet und es hat gut funktioniert:

JsonConvert.SerializeObject(ResultGroups, Formatting.None,
                        new JsonSerializerSettings()
                        { 
                            ReferenceLoopHandling = ReferenceLoopHandling.Ignore
                        });

JSON.NET-Fehler Selbstreferenzierende Schleife für Typ erkannt

Es verweist auch auf die Json.NET-Codeplex-Seite unter:

http://json.codeplex.com/discussions/272371

Dokumentation: ReferenceLoopHandling-Einstellung

Das Update besteht darin, Schleifenreferenzen zu ignorieren und nicht zu serialisieren. Dieses Verhalten ist in angegeben JsonSerializerSettings.

SingleJsonConvert mit Überlastung:

JsonConvert.SerializeObject((from a in db.Events where a.Active select a).ToList(), Formatting.Indented,
    new JsonSerializerSettings() {
        ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore
    }
);

Wenn Sie dies als Standardverhalten festlegen möchten , fügen Sie eine globale Einstellung mit Code Application_Start()in Global.asax.cs hinzu:

JsonConvert.DefaultSettings = () => new JsonSerializerSettings {
     Formatting = Newtonsoft.Json.Formatting.Indented,
     ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore
};

Referenz: https://github.com/JamesNK/Newtonsoft.Json/issues/78

Wenn Sie ASP.NET Core MVC verwenden, fügen Sie dies der ConfigureServices-Methode Ihrer Datei startup.cs hinzu:

services.AddMvc()
    .AddJsonOptions(
        options => options.SerializerSettings.ReferenceLoopHandling =            
        Newtonsoft.Json.ReferenceLoopHandling.Ignore
    );

Dies kann Ihnen helfen.

public MyContext() : base("name=MyContext") 
{ 
    Database.SetInitializer(new MyContextDataInitializer()); 
    this.Configuration.LazyLoadingEnabled = false; 
    this.Configuration.ProxyCreationEnabled = false; 
} 

http://code.msdn.microsoft.com/Loop-Reference-handling-in-caaffaf7

Sie müssen Preserving Object References festlegen:

var jsonSerializerSettings = new JsonSerializerSettings
{
    PreserveReferencesHandling = PreserveReferencesHandling.Objects
};

Dann rufen Sie Ihre Anfrage var q = (from a in db.Events where a.Active select a).ToList();gerne an

string jsonStr = Newtonsoft.Json.JsonConvert.SerializeObject(q, jsonSerializerSettings);

Siehe: https://www.newtonsoft.com/json/help/html/PreserveObjectReferences.htm

Fügen Sie Ihrer Modellklasse "[JsonIgnore]" hinzu

{
  public Customer()
  {
    Orders = new Collection<Order>();
  }

public int Id { get; set; }
public string Name { get; set; }
public string Surname { get; set; }

[JsonIgnore]
public ICollection<Order> Orders { get; set; }
}

Ich verwende Dot.Net Core 3.1 und habe nach gesucht

"Newtonsoft.Json.JsonSerializationException: Selbstreferenzierende Schleife für Eigenschaft erkannt"

Ich füge dies dieser Frage hinzu, da es eine einfache Referenz sein wird. In der Datei Startup.cs sollten Sie Folgendes verwenden:

 services.AddControllers()
                .AddNewtonsoftJson(options =>
                {
                    // Use the default property (Pascal) casing
                    options.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
                    options.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
                });

für asp.net core 3.1.3 hat das bei mir funktioniert

services.AddControllers().AddNewtonsoftJson(opt=>{
            opt.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
        });

JsonConvert.SerializeObject(ObjectName, new JsonSerializerSettings(){ PreserveReferencesHandling = PreserveReferencesHandling.Objects, Formatting = Formatting.Indented });

Manchmal haben Sie Schleifen, weil Ihre Typklasse Verweise auf andere Klassen hat und diese Klassen Verweise auf Ihre Typklasse haben. Daher müssen Sie die Parameter, die Sie benötigen, genau in der JSON-Zeichenfolge auswählen, wie diesen Code.

List<ROficina> oficinas = new List<ROficina>();
oficinas = /*list content*/;
var x = JsonConvert.SerializeObject(oficinas.Select(o => new
            {
                o.IdOficina,
                o.Nombre
            }));