Ich habe Probleme mit meinem Web-Anwendungsdesign mit JSON, ASP.NET, Typoskript/Javascript und AngularJS.
JSON Datenstruktur - JSON zu Objekten - Best Practice
Kurz: Ich brauche eine Best-Practice für Daten vom Server an einen Client über JSON senden, den JSON-String auf der Client-Seite mit Objekten zu erstellen.
Ich habe ein WebServerAPI Projekt (ASP.NET) mit der folgenden Struktur:
- Controller
- Datacontroller (REST API)
- Modell
- A
- Typ
Die Modellklassen:
public class A {
public property int Id {get; set;}
public property string Name {get; set;}
public property Type Type {get; set;}
}
public class Type {
public property int Id {get; set;}
public property string Name {get; set;}
}
ID jeder Modellklasse gehört zu einer ID in einer Datenbanktabelle (Primärschlüssel).
Die Datacontroller Struktur:
public class DataController : ApiController {
// ...
// GET api/a
public IEnumerable<A> Get()
{
// fetches all As from the database
// the facade creates instances of A and Type as required
// (if A has a 'Type' the Type will also fetched an set)
return facade.GetAll<A>();
}
// ...
}
Die Methode get() des Datacontroller gibt ein JSON Ergebnis.
Das JSON Ergebnis sieht wie folgt aus:
[
{"Id":1,
"Type": {"Id":1, "Name":"name1"}
},
{"Id":2,
"Type": {"Id":2, "Name":"name2"}
},
{"Id":3,
"Type": {"Id":1, "Name":"name1"}
}
{"Id":4,
"Type": {"Id":2, "Name":"name2"}
},
{"Id":5,
"Type": {"Id":2, "Name":"name2"}
},
]
Wie Sie in den JSON-Daten einige Wie teilen die gleichen Typen sehen. Obwohl dies JSON ist, frage ich mich, ob dies die beste Methode ist, Daten zu senden.
Wäre es nicht besser sein, so etwas zu senden:
[
{"Id":1,
"TypeId": {"Id":1}
},
{"Id":2,
"TypeId": {"Id":2}
},
{"Id":3,
"TypeId": {"Id":1}
}
{"Id":4,
"TypeId": {"Id":2}
},
{"Id":5,
"TypeId": {"Id":2}
},
]
So bekommen wir nur die ID des Typs. Dann müssen wir alle verfügbaren Typen anfordern, um festzustellen, welcher Typ in dem entsprechenden As festgelegt werden muss. Was kann schlecht sein? Ich denke, das könnte langsam sein, weil ich zwei Abfragen senden muss.
Eine dritte Option kann alle verfügbaren Typen und die As in demselben JSON-Ergebnis senden.
[
{"Types":
[
{"Id":1, "Name":"name1"},
{"Id":2, "Name":"name2"},
]
},
{"As":
[
{"Id":1,
"TypeId": {"Id":1}
},
{"Id":2,
"TypeId": {"Id":2}
},
{"Id":3,
"TypeId": {"Id":1}
}
{"Id":4,
"TypeId": {"Id":2}
},
{"Id":5,
"TypeId": {"Id":2}
}
]
}
]
Also ich frage mich, ob es eine Best-Practice dafür ist. Das gleiche Objekt (Type) immer wieder als verschachteltes Objekt in A zu versenden erscheint ziemlich "dumm".
Insbesondere, wenn ich die JSON-Zeichenfolge in Typescript-Objekte konvertieren.
Ohne „Speicher/Cache“ Logik schaffe ich das „gleiche“ über das Objekt und immer wieder:
export class A {
public Id: number;
public Name: string;
public Type: Type;
public static fromData(data: any): A {
var a = new A();
a.Id = data.Id;
a.Name = data.Name;
a.Type = Type.fromData(data.Type);
return a;
}
}
export class Type {
public Id: number;
public Name: string;
public static fromData(data: any) : Type {
var type = new Type();
type.Id = data.Id;
type.Name = data.Name;
return type;
}
}
// AngularJS controller
export class AListCtrl {
static $inject = ['$scope', '$http'];
public As: A[] = [];
constructor(private $scope, private $http) {
$scope.AListCtrl = this;
$http.get('http://localhost/api/a').success((data) => {
var as: A[] = [];
for (var i = 0; i < data.length; i++) {
var aData = data[i];
var a = A.fromData(aData);
as.push(a);
}
this.As = as;
});
}
}
verschiedene Objekte erstellen, die die gleichen Typen repräsentieren nur falsch zu sein scheint. Weil ich viel mit Referenzen in anderen Sprachen (C#, Java, C++) arbeite. Die Verwendung dieser Art des Deserialisierens der Daten und das Erstellen der Objekte ermöglicht überhaupt keine Verwendung von Referenzen (ist das vielleicht in Web-Anwendungen falsch?). Und ich denke auch, dass das Erzeugen einer Menge nutzloser Objekte anstelle von einem pro Typ eine Verschwendung von Speicher- und CPU-Zeit ist.
Ziemlich lange Post, aber ich hoffe, es erklärt mein Problem gut.
Um es zusammenzufassen:Ich brauche eine Best-Practice für Daten vom Server auf einen Client über JSON, mit der JSON-String auf der Client-Seite zu senden Objekte zu erstellen.
Ich habe normalerweise das C# Ansichtsmodell genau mit dem Javascript-Ansichtsmodell übereinstimmen. Ich finde, dass es einfacher zu pflegen ist, zu einer schnelleren Entwicklungszeit führt und in Zukunft, wenn ich etwas ändere, ist das keine große Sache (für mich ist das wichtiger als ein paar Bytes Netzwerkverkehr zu speichern). Wenn Sie keine Anwendung entwickeln, bei der jedes Byte zählt oder große Datenmengen übertragen werden, sollten Sie sich keine Gedanken darüber machen. Sie speichern bereits viele Bytes, indem Sie eine JSON-Zeichenfolge übergeben, anstatt beim erneuten Anzeigen einer neuen Seite einen vollständigen Seitenneuaufbau durchzuführen. –
@dhsto Leider muss ich mit vielen Daten umgehen (etwa 1kk Objekte (As)). Aber wie Sie im Typoskript-Code sehen können, verwende ich die gleichen Klassenstrukturen in C# und in Typoskript. – bakunin