JSON Serialization Entity Framework Selbstreferenz abrufen Schleifenfehler auch nach ProxyCreation false bei expliziter Verwendung von Include

Question

JSON-Serialisierung (ASP.Net Web API) schlägt fehl, da sich selbstverweisende Schleife (es ist ein häufiges Problem, Grund: eine Entität angeforderte Lazy Loads untergeordnete Entitäten und jedes Kind hat eine Rückverweisung auf die übergeordnete Entität).

Umgehen fand ich, aber mir nicht helfen:

1. Use [JsonIgnore] for navigation properties to be ignored: Diese Lösung funktioniert, aber in meinem Fall nicht anwendbar ist. Beispiel: Um Kundeninformationen zusammen mit seinen Bestellungen zu erhalten, würde ich der Kundeneigenschaft in der Bestellklasse schnell [JsonIgnore] hinzufügen, aber wenn ich eine Bestellinformation zusammen mit den Kundendetails erhalten möchte, da [Customer] auf der Kundeneigenschaft steht Es enthält keine Kundendaten.
2. Change JSON.Net Serializer Settings to Preserve References: Kann nicht beibehalten werden, da ich nicht auf zirkuläre referenzierte Daten angewiesen bin.
3. Disable Proxy Creation at the Data Context and use explicit loading(this should ideally solve the problem): Deaktivieren Proxy-Erstellung stoppt Lazy Laden und gibt Daten ohne Fehler, zurück, aber wenn ich explizit untergeordnete Entitäten einschließe, bekomme ich wieder die unerwartete selbstreferenzierende Schleife Fehler! Der Fehler liegt auf der Rückreferenzstufe der übergeordneten Entität.

Irgendwelche Erfahrungen in der gleichen Richtung/Vorschläge?

Answer 1

Ich habe versucht, alle vorgeschlagenen Lösungen aber hat nicht funktioniert. Endete dies mit Aufschalten des JSON.Net Serializer des DefaultContractResolver zu:

public class FilterContractResolver : DefaultContractResolver 
{ 
    Dictionary<Type, List<string>> _propertiesToIgnore; 

    public FilterContractResolver(Dictionary<Type, List<string>> propertiesToIgnore) 
    { 
     _propertiesToIgnore = propertiesToIgnore; 
    } 

    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization) 
    { 
     var property = base.CreateProperty(member, memberSerialization); 
     List<string> toIgnore; 
     property.Ignored |= ((_propertiesToIgnore.TryGetValue(member.DeclaringType, out toIgnore) || _propertiesToIgnore.TryGetValue(member.DeclaringType.BaseType, out toIgnore)) && toIgnore.Contains(property.PropertyName)); 
     return property; 
    } 
} 

erstellt dann eine statische Klasse, die ein Wörterbuch von Eigenschaften liefert Ignoriert auf dem Controller-basiert werden:

public static class CriteriaDefination 
{ 
    private static Dictionary<string, Dictionary<Type, List<string>>> ToIgnore = new Dictionary<string, Dictionary<Type, List<string>>> 
    { 
     { 
      "tblCustomer", new Dictionary<Type, List<string>>{ 
       { 
        typeof(tblCustomer), new List<string>{ 
         //include all 
        } 
       }, 
       { 
        typeof(tblOrder), new List<string>{ 
         "tblCustomer"//ignore back reference to tblCustomer 
        } 
       } 
      } 
     }, 
     { 
      "tblOrder", new Dictionary<Type, List<string>>{ 
       { 
        typeof(tblCustomer), new List<string>{ 
         "tblOrders"//ignore back reference to tblOrders 
        } 
       }, 
       { 
        typeof(tblOrder), new List<string>{ 
         //include all 
        } 
       } 
      } 
     } 
    }; 
    public static Dictionary<Type, List<string>> IgnoreList(string key) 
    { 
     return ToIgnore[key]; 
    } 
} 

Und innerhalb jeden Controller Ändern Sie den JSON-Formatierer so etwas wie:

Answer 2

Anstatt das Entity Framework das Modell generieren zu lassen, verwenden Sie Code First mit einer vorhandenen Datenbank. Jetzt haben Sie mehr Kontrolle.

See this blog entry from Scott Guthrie

Answer 3

Dies ist, was ich am Ende beschlossen, hoffentlich hilft es jemand anderem.

Sprich die EF-Klassen wie folgt strukturiert sind:

public partial class MyEF 
{ 
    public virtual ICollection<MyOtherEF> MyOtherEFs {get; set;} 
} 
public partial class MyOtherEF 
{ 
    public virtual MyEF MyEF {get; set;} 
} 

Serialisierung Form zu halten in JSON.NET geschieht, können Sie die Klasse erweitern und ein Verfahren mit dem Namen „ShouldSerialize“ + Eigenschaftsnamen wie so hinzufügen :

public partial class MyEF 
{ 
    public bool ShouldSerializeMyOtherEFs() { return false; } 
} 

Wenn Sie ein wenig mehr Lust bekommen wollen, Sie Logik in der Methode hinzufügen könnte, so dass es in bestimmten Fällen serialisiert werden würde. Dadurch können Sie die Serialisierungslogik bei der Erstellung des EF Model First-Codes beibehalten, solange sich dieser Code in einer anderen physischen Codedatei befindet.