Serialisierung und Deserialisierung von JSON in ASP.NET

Einführung: JSON ist ein Datenformat, das speziell für die Ausführung von JavaScript-Code auf Webseiten in Browsern entwickelt wurde. In diesem Artikel wird die Serialisierung und Deserialisierung von JSON vorgestellt , hauptsächlich eine kurze Einführung in JSON, wie ASP.NET mit Serialisierung und Deserialisierung umgeht und wie Datum und Uhrzeit, Sammlungen und Wörterbücher bei der Serialisierung und Deserialisierung verarbeitet werden.

1. Einführung in JSON

JSON (JavaScript Object Notation, JavaScript-Objektnotation) ist ein leichtes Datenaustauschformat.

JSON ist eine Sammlungsstruktur von „Name-Wert-Paaren“, bestehend aus geschweiften Klammern „{}“, eckigen Klammern „[]“, Kommas „“, und Doppelpunkten. „:“ besteht aus doppelten Anführungszeichen „“,“ und enthält Datentypen wie Objekte, Zahlen, boolesche Werte, String-Arrays, NULL usw.

JSON hat die folgende Form:

Objekt (Objekt) ist eine ungeordnete Sammlung von „Name-Wert-Paaren“. Ein Objekt beginnt mit „{“ und endet mit „}“ für jedes „ name“ „Gefolgt von einem „:“ werden mehrere „Name-Wert-Paare“ durch Kommas getrennt, wie zum Beispiel:

VAR user = {“Name“: „Zhang San“, „Geschlecht“: „Männlich ", "Geburtstag": "8. August 1980"🎜>

Ein Array (Array) ist eine geordnete Sammlung von Werten. Ein Array beginnt mit „[“ und endet mit „]“. Die Werte sind getrennt durch ",", wie zum Beispiel:

VAR user list = [{"Benutzer": {"Name": "Zhang San", "Geschlecht": "Männlich", "Geburtstag": "8. August, 1980"}}, {"Benutzer": {"Name" "李思", "Geschlecht": "Männlich", "Geburtstag": "8. Mai 1985"}}];

String (String ) Ist eine Sammlung einer beliebigen Anzahl von Unicode-Zeichen, die in doppelte Anführungszeichen eingeschlossen und mit Backslashes maskiert sind.

Zweitens: JSON-Daten serialisieren und deserialisieren

Sie können die DataContractJsonSerializer-Klasse verwenden, um Typinstanzen in JSON-Strings zu serialisieren und JSON-Strings in Typinstanzen zu deserialisieren. DataContractJsonSerializer befindet sich im Namespace System.Runtime.Serialization.Json. .NET Framework 3.5 ist in der Datei System.ServiceModel.Web .dll enthalten und ein Verweis darauf muss in System.Runtime hinzugefügt werden. Serialisierung.

Verwenden Sie den DataContractJsonSerializer-Serialisierungs- und Deserialisierungscode:

1: Verwenden Sie das System;

2: Verwenden Sie System.Collections.Generic;

3: Verwenden Sie das System .Linq;

4: Verwenden von System.Web;

5: Verwenden von System.Runtime.Serialization.Json;

7: Verwenden Sie System.Text;

8:

9: ///

10: /// JSON Serialisierungs- und Deserialisierungs-Hilfsklasse

11: ///

12: Öffentliche Klasse JsonHelper

13: {

14:///

15：/// JSON-Serialisierung

16：///

17： öffentlicher statischer String JsonSerializer (T T)

18: {

19: DataContractJsonSerializer SER = new DataContractJsonSerializer(typeof operation (T));

20: MemoryStream milliseconds = new MemoryStream();

21: ser.WriteObject(MS, T);

22: String jsonString = Encoding.UTF8.GetString(ms.ToArray() );

23: ms.Close();

24: JsonString zurückgeben;

25: }

26:

27：///

28： /// JSON Deserialization

29：///

30： Public static JsonDeserialize (string jsonString)

31: {

32: DataContractJsonSerializer SER = new DataContractJsonSerializer(typeof operation (T));

33 :MemoryStream milliseconds = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));

34: T obj = (T)ser.ReadObject(MS);

35: Return OBJ;

36:}

37:}

Serialisierungsdemo:

Einfache Objektperson:

1: Öffentliche Klassenperson

2: {

3: Öffentlicher Zeichenfolgenname {; 🎜>

4: Öffentliches Interpretationsalter {get; group; }

5: , EventArgs gesendet)

2: {

3: Person p = new Person();

4: p.Name = "Zhang San";

5: p.Age = 28;

6:

7: String jsonString = JsonHelper.JsonSerializer <人>(P);

8: Antwort to (jsonString);

9: }

Ausgabeergebnis:

{"Era": 28., "Name": "Zhang San"}

Deserialisierungsdemonstration:

1: Ungültiges Page_Load schützen (Objektsender, gesendete EventArgs)

2: {

3: String jsonString = "{"age": 28, „name“: „Zhang San“}“;

4P = JsonHelper.JsonDeserialize <人>(jsonString);

5:}

Laufendes Ergebnis:

JSON-Sequenz in ASP.NET JavaScriptSerializer kann auch zur Deserialisierung und Deserialisierung verwendet werden. Im System.Web.Script.Serializatioin-Namespace muss auf System.Web.Extensions.dll verwiesen werden. JSON.NET kann ebenfalls verwendet werden.

3. JSON-Serialisierung und Deserialisierung von Datum und Uhrzeit

Das JSON-Format unterstützt Datum und Uhrzeit nicht direkt in der Form „/Datum (700000 + 0500)/“. Eine JSON-Zeichenfolge, bei der die erste Zahl (700000 im bereitgestellten Beispiel) die Anzahl der Millisekunden ist, die in normaler Zeit (nicht Sommerzeit) seit Mitternacht am 1. Januar 1970 in der GMT-Zeitzone vergangen sind. Die Zahl kann negativ sein, um eine frühere Zeit darzustellen. Der optionale Teil des Beispiels, der „0500“ enthält, gibt an, dass die Zeit vom lokalen Typ ist, d. h. sie sollte bei der Deserialisierung in die lokale Zeitzone konvertiert werden. Ohne diesen Teil wird die Zeit auf UTC deserialisiert.

Ändern Sie die persönliche Klasse und fügen Sie LastLoginTime hinzu:

1: Öffentliche Klasse Person

2: {

3: Öffentlicher Zeichenfolgenname {;

4: Öffentliches Dolmetscheralter {get;group;}

5: Public DateTime LastLoginTime {get;🎜>

6:🎜>

1 : Person p = neue Person();

2: p.Name = „Zhang San“ 3: p.Alter = 28; LastLoginTime = DateTime.Now;

5:

6: String jsonString = JsonHelper.JsonSerializer <人>(P);

Serialisierungsergebnis:

{"Era": 28th, "LastLoginTime": "/Date (1294499956278 + 0800) /", "Name": "Zhang San"}

1. Verwenden Sie reguläre Ausdrücke im Hintergrund. Ändern Sie JsonHelper für Ausdrucksersetzungsverarbeitung:

1: System verwenden

2: System.Collections.Generic verwenden

4 : Verwenden von System.Web;

5: Verwenden von System.Runtime.Serialization.Json;

6: Verwenden von System.IO;

7 : Verwenden von System.Text;

8: Verwenden Sie System.Text.RegularExpressions;

9:

10: ///

11：/// JSON-Serialisierung und Deserialisierungshilfsklasse

12:///

13: Öffentliche Klasse JsonHelper

14 : {

15:// /

16:/// JSON-Serialisierung

17:///

18: Öffentliche statische Zeichenfolge JsonSerializer (T T)

19: {

20: DataContractJsonSerializer SER = new DataContractJsonSerializer(typeof operation (T));

21: MemoryStream milliseconds = new MemoryStream(); 🎜>

22: ser.WriteObject(MS, T);

23: String jsonString = Encoding.UTF8.

24: ms. Close();

25: //Json-Datumszeichenfolge ersetzt

26: String P = @"\/Date((D+)+D+)\/";

27: MatchEvaluator matchEvaluator = new MatchEvaluator(ConvertJsonDateToDateString);

28: Regulärer Ausdruck kapitel = neuer regulärer Ausdruck (P);

29: jsonString = reg.Replace(jsonString, matchEvaluator);

30: Return jsonString;

31: }

32:

33: ///

34 : /// JSON-Deserialisierung

35: ///

36: Public static JsonDeserialize (string jsonString)

37: {

38: //Änderung der Formatzeichenfolge „JJJJ-MM-TT HH:MM:SS“ wird in das Format „/Datum (1294499956278 + 0800) /“ konvertiert

39: Zeichenfolge P = @"D{4}-d{2}-d{2} S D{2}: D{2}: D{2}"

40: MatchEvaluator matchEvaluator = new MatchEvaluator(ConvertDateStringToJsonDate); 🎜>

41: Regulärer Ausdruck Kapitel = neue reguläre Ausdrucksformel (P);

42: jsonString = reg.Replace(jsonString, matchEvaluator);

43: DataContractJsonSerializer SER = neu DataContractJsonSerializer (typeof operation (T));

44: MemoryStream milliseconds = new MemoryStream(Encoding.UTF8.GetBytes(jsonString));

45: T obj = (T)ser.ReadObject (MS);

46 : Return OBJ;

47:}

48:

49:///

50:/// Will Json serialisierte Zeit/Datum (1294499956278 + 0800) in einen String

51:///

52: privater statischer String ConvertJsonDateToDateString( semi )

53: {

54: String result = String.Empty;

55: DateTime DT = new DateTime(1970,1,1);

56: DT = dt.AddMilliseconds(long.Parse(m.Groups[1].value));

57: DT = dt.ToLocalTime();

58 : Ergebnis = dt.ToString("JJJJ-MM-TT HH:MM:SS");

59: Ergebnis zurückgeben

60: }

61:

62：///

63：///Zeitzeichenfolge in JSON-Zeit konvertieren

64：///

65: Private statische Zeichenfolge ConvertDateStringToJsonDate(saimi)

66: {

67: String result = String.Empty;

68: DateTime DT = DateTime.Parse (m.Groups[0].value);

69: DT = dt.ToUniversalTime();

70: Zeitspanne TS = DT - DateTime.Parse("1970-01- 01");

71: result = String.Format("\/Date({0}+0800)\/",ts.TotalMilliseconds);

72: Ergebnis zurückgeben; Neue Person();

2: p.Name = "张三";

3: p.Age = 28;

4: p.LastLoginTime = DateTime . Now;

5:

6: String jsonString = JsonHelper.JsonSerializer <人>(P);

Run result:

{" Zeit“: 28., „LastLoginTime“: „2011-01-09 ein Uhr Minute 56 Sekunden“, „Name“: „Zhang San“}

Deserialisierungsdemonstration:

JSON-Zeichenfolge = "{"Alter": 28.,"LastLoginTime": "2011-01-09 00:30:00", "Name": "Zhang San"}";

P + Mehr lästig.

2. Verarbeitung mit JavaScript

1: Funktion ChangeDateFormat(jsondate) {

2: jsondate = jsondate.replace("/date(",""). ersetzen ("")/","");

3: if (jsondate.indexOf("+")> 0) {

4: jsondate = jsondate.substring(0, jsondate .indexOf("+"));

5:}

6: Ansonsten if (jsondate.indexOf("-")> 0){

7 : jsondate = jsondate.substring(0,jsondate.indexOf("-"));

8:}

9:

10: VAR date = neues Datum (parseInt function (jsondate, 10));

11: Reaktiver Monat = date.getMonth() + 1 <10? "0" + (date.getMonth() + 1): date.getMonth() + 1;

12: VAR's currentdate = date.getDate()<10? "0" + date.getDate(): date.getDate();

13: Rückgabe date.getFullYear()+"-"+month+"-"+currentdate;

14: }

Einfache Demonstration:

ChangeDateFormat("/Date(1294499956278+0800)/");

Ergebnis:

Vier, JSON-Sequenzverarbeitung von Deserialisieren und Deserialisieren von Sammlungen, Wörterbüchern und Arrays

In JSON-Daten werden alle Sammlungen, Wörterbücher und Arrays als Arrays dargestellt.

Liste Serialisierung:

1: Liste Liste = neue Liste 3: Neue Person () {name = „Zhang San“, Alter = 28},

4: Neue Person () {name = „Li Si“, Alter = 25}

5 :};

6:

7: String jsonString = JsonHelper.JsonSerializer >(List);

Serialisierungsergebnis:

"[{"Alter": 28,"Name": "Zhang San"},{"Alter": 25,"Name":李思"}] ”

Wörterbücher können nicht direkt verwendet werden für JSON. Die Konvertierung eines Wörterbuchs in JSON entspricht nicht dem ursprünglichen Wörterbuchformat. Stattdessen verwendet das Format die Schlüssel des Wörterbuchs als Wert des Namens „key“. Wert von „Wert“. Zum Beispiel:

1: Wörterbuch DIC = Neues Wörterbuch ");

3: dic.Add("Era", "28");

4:

5: String jsonString = JsonHelper .JsonSerializer >(DIC);

Serialisierungsergebnis:

1: „[{“key“: „name“, „value“: „张三“},{“ Schlüssel: „Alter“, „Wert“: „28“}]“