c# - Was ist der Unterschied zwischen PreserveReferencesHandling und ReferenceLoopHandling in Json.Net?




asp.net asp.net-web-api (2)

Ich schaue mir ein WebAPI-Anwendungsbeispiel an, das diesen Code enthält:

json.SerializerSettings.PreserveReferencesHandling 
   = Newtonsoft.Json.PreserveReferencesHandling.Objects;

und ein anderer mit diesem Code:

json.SerializerSettings.ReferenceLoopHandling 
   = Newtonsoft.Json.ReferenceLoopHandling.Ignore;

Keiner erklärt, warum jeder ausgewählt wird. Ich bin sehr neu in WebAPI, also kann jemand helfen, indem er mir in einfachen Begriffen erklärt, was die Unterschiede sind und warum ich einen über den anderen verwenden muss.


Answers

Diese Einstellungen können am besten anhand eines Beispiels erläutert werden. Nehmen wir an, wir möchten eine Hierarchie von Mitarbeitern in einem Unternehmen darstellen. Also machen wir eine einfache Klasse wie folgt:

class Employee
{
    public string Name { get; set; }
    public List<Employee> Subordinates { get; set; }
}

Dies ist eine kleine Firma mit nur drei Angestellten: Angela, Bob und Charles. Angela ist der Boss, Bob und Charles sind ihre Untergebenen. Lassen Sie uns die Daten zur Beschreibung dieser Beziehung einrichten:

Employee angela = new Employee { Name = "Angela Anderson" };
Employee bob = new Employee { Name = "Bob Brown" };
Employee charles = new Employee { Name = "Charles Cooper" };

angela.Subordinates = new List<Employee> { bob, charles };

List<Employee> employees = new List<Employee> { angela, bob, charles };

Wenn wir die Liste der Mitarbeiter zu JSON serialisieren ...

string json = JsonConvert.SerializeObject(employees, Formatting.Indented);
Console.WriteLine(json);

... wir bekommen diese Ausgabe:

[
  {
    "Name": "Angela Anderson",
    "Subordinates": [
      {
        "Name": "Bob Brown",
        "Subordinates": null
      },
      {
        "Name": "Charles Cooper",
        "Subordinates": null
      }
    ]
  },
  {
    "Name": "Bob Brown",
    "Subordinates": null
  },
  {
    "Name": "Charles Cooper",
    "Subordinates": null
  }
]

So weit, ist es gut. Sie werden jedoch feststellen, dass die Informationen für Bob und Charles im JSON wiederholt werden, da die Objekte, die sie repräsentieren, sowohl von der Hauptliste der Mitarbeiter als auch von Angelas Liste der Untergebenen referenziert werden. Vielleicht ist das für jetzt okay.

Nun nehmen wir an, wir möchten auch einen Weg haben, den Vorgesetzten jedes Mitarbeiters zusätzlich zu seinen Untergebenen im Auge zu behalten. Daher ändern wir unser Employee , um eine Supervisor Eigenschaft hinzuzufügen ...

class Employee
{
    public string Name { get; set; }
    public Employee Supervisor { get; set; }
    public List<Employee> Subordinates { get; set; }
}

... und fügen unserem Setup-Code noch ein paar Zeilen hinzu, um anzuzeigen, dass Charles und Bob Angela berichten:

Employee angela = new Employee { Name = "Angela Anderson" };
Employee bob = new Employee { Name = "Bob Brown" };
Employee charles = new Employee { Name = "Charles Cooper" };

angela.Subordinates = new List<Employee> { bob, charles };
bob.Supervisor = angela;       // added this line
charles.Supervisor = angela;   // added this line

List<Employee> employees = new List<Employee> { angela, bob, charles };

Aber jetzt haben wir ein kleines Problem. Da das Objektdiagramm Referenzschleifen enthält (z. B. angela references bob und bob references angela ), erhalten wir eine JsonSerializationException wenn wir versuchen, die Mitarbeiterliste zu serialisieren. Eine Möglichkeit, dieses Problem zu Ignore besteht darin, ReferenceLoopHandling wie folgt auf Ignore :

JsonSerializerSettings settings = new JsonSerializerSettings
{
    ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
    Formatting = Formatting.Indented
};

string json = JsonConvert.SerializeObject(employees, settings);

Mit dieser Einstellung erhalten wir folgendes JSON:

[
  {
    "Name": "Angela Anderson",
    "Supervisor": null,
    "Subordinates": [
      {
        "Name": "Bob Brown",
        "Subordinates": null
      },
      {
        "Name": "Charles Cooper",
        "Subordinates": null
      }
    ]
  },
  {
    "Name": "Bob Brown",
    "Supervisor": {
      "Name": "Angela Anderson",
      "Supervisor": null,
      "Subordinates": [
        {
          "Name": "Charles Cooper",
          "Subordinates": null
        }
      ]
    },
    "Subordinates": null
  },
  {
    "Name": "Charles Cooper",
    "Supervisor": {
      "Name": "Angela Anderson",
      "Supervisor": null,
      "Subordinates": [
        {
          "Name": "Bob Brown",
          "Subordinates": null
        }
      ]
    },
    "Subordinates": null
  }
]

Wenn Sie das JSON untersuchen, sollte klar sein, was diese Einstellung bewirkt: Jedes Mal, wenn der Serializer eine Referenz zurück zu einem Objekt findet, das er gerade serialisiert, überspringt er einfach dieses Mitglied. (Dies verhindert, dass der Serialisierer in eine Endlosschleife gerät.) Sie können sehen, dass in Angelas Liste der Untergebenen im oberen Teil des JSON weder Bob noch Charles einen Supervisor zeigen. Im unteren Teil des JSON zeigen Bob und Charles beide Angela als ihren Vorgesetzten, aber beachten Sie, dass die Liste ihrer Untergebenen zu diesem Zeitpunkt nicht Bob und Charles einschließt.

Es ist zwar möglich, mit diesem JSON zu arbeiten und vielleicht sogar die ursprüngliche Objekthierarchie mit etwas Arbeit zu rekonstruieren, aber es ist eindeutig nicht optimal. Wir können die wiederholten Informationen in JSON entfernen, während die Objektreferenzen PreserveReferencesHandling indem stattdessen die Einstellung PreserveReferencesHandling verwendet wird:

JsonSerializerSettings settings = new JsonSerializerSettings
{
    PreserveReferencesHandling = PreserveReferencesHandling.Objects,
    Formatting = Formatting.Indented
};

string json = JsonConvert.SerializeObject(employees, settings);

Jetzt bekommen wir folgendes JSON:

[
  {
    "$id": "1",
    "Name": "Angela Anderson",
    "Supervisor": null,
    "Subordinates": [
      {
        "$id": "2",
        "Name": "Bob Brown",
        "Supervisor": {
          "$ref": "1"
        },
        "Subordinates": null
      },
      {
        "$id": "3",
        "Name": "Charles Cooper",
        "Supervisor": {
          "$ref": "1"
        },
        "Subordinates": null
      }
    ]
  },
  {
    "$ref": "2"
  },
  {
    "$ref": "3"
  }
]

Beachten Sie, dass nun jedem Objekt im JSON ein sequenzieller $id Wert zugewiesen wurde. Wenn ein Objekt das erste Mal auftritt, wird es vollständig serialisiert, während nachfolgende Referenzen durch eine spezielle $ref Eigenschaft ersetzt werden, die auf das ursprüngliche Objekt mit der entsprechenden $id verweist. Mit dieser Einstellung ist das JSON viel prägnanter und kann ohne zusätzliche Arbeit in die ursprüngliche Objekthierarchie deserialisiert werden, vorausgesetzt, Sie verwenden eine Bibliothek, die die von Json.Net / Web erzeugte Schreibweise $id und $ref versteht API.

Warum also wählten Sie die eine oder die andere Einstellung? Es hängt natürlich von Ihren Bedürfnissen ab. Wenn der JSON von einem Client konsumiert wird, der das $id / $ref Format nicht versteht und unvollständige Daten an einigen Stellen tolerieren kann, würden Sie sich für ReferenceLoopHandling.Ignore . Wenn Sie nach einem kompakteren JSON suchen und die JSer.Net- oder Web-API (oder eine andere kompatible Bibliothek) zum Deserialisieren der Daten verwenden möchten, verwenden Sie PreserveReferencesHandling.Objects . Wenn Ihre Daten ein gerichteter azyklischer Graph ohne doppelte Referenzen sind, brauchen Sie keine Einstellung.


A const ist eine Kompilierzeitkonstante, während readonly die Berechnung eines Wertes zur Laufzeit erlaubt und im Konstruktor oder Feldinitialisierer festgelegt wird. Ein 'const' ist also immer konstant, aber 'readonly' ist nur lesbar, sobald es zugewiesen ist.

Eric Lippert vom C # -Team hat mehr Informationen über verschiedene Arten von Unveränderlichkeit





c# asp.net json asp.net-web-api json.net