How to parse deserialized JSON object back into arrays? - json

Question

I have successfully been able to serialize an entire class of properties (array, vectors of strings, integers, doubles). Deserialize also works, but I need a way to parse the returned object into the various arrays, and then set these equal to the four arrays of the same dimension.
Before, when I was using BinaryFormatter, I could simply declare mydeser As Object, deserialize into mydeser, and then pick off the arrays directly by using e.g. readarray = mydeser.array.
I did notice that a JObject is a type of dictionary, but I don't know what the keys would be or the values, which are some sort of jsonToken.
I tried using:
For each kvp as KeyValuePair(String, jsonToken) in myser
Next
but an exception was thrown. So is there a way to maybe use a key, and then the JObject's values directly into the arrays, using maybe readarray = mydeser("array") -- assuming mydeser is a dictionary?
Imports System.IO
Imports Newtonsoft.Json
Public Class Form1
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
Dim ser As New testSer
End Sub
End Class
Public Class testSer
Public Property array As Double(,)
Public Property vector As Double()
Public Property strVec As String()
Public Property IntVec As Integer()
Sub New()
serdeser()
End Sub
Sub serdeser()
Dim r As New Random
ReDim array(1000, 1000)
ReDim vector(1000)
ReDim strVec(1000)
ReDim IntVec(1000)
For i = 1 To 1000
vector(i) = r.NextDouble
strVec(i) = "A"
IntVec(i) = r.Next(1, 100)
For j = 1 To 1000
array(i, j) = r.NextDouble
Next
Next
Dim jsonSerializer As New JsonSerializer
Dim stream As FileStream = File.Create("D:\test")
Dim writer As New StreamWriter(stream)
Dim jsonWriter As New JsonTextWriter(writer)
jsonSerializer.Serialize(jsonWriter, Me)
writer.Close()
Dim stream1 As FileStream = File.Open("D:\test", FileMode.Open, FileAccess.Read, FileShare.Read)
Dim reader As New StreamReader(stream1)
Dim jsonTextReader As New JsonTextReader(reader)
Dim mydeser As Linq.JObject
mydeser = jsonSerializer.Deserialize(jsonTextReader)
Dim readarray(1000, 1000) As Double
Dim readvector(1000) As Double
Dim readstrVec(1000) As String
Dim readIntVec(1000) As Integer
Dim mystr = DirectCast(mydeser.First, Linq.JProperty)
'readarray = mydeser.array <--need to assign "array" back into readarray
'readvector = mydeser.vector
'readstrVec = mydeser.strvec
'readarray = mydeser.intvec
reader.Close()
End Sub
End Class

Answer 1

A few suggestions, considering that this is a test class:
Your serialization procedure is mostly correct. It's preferable to declare the Stream objects with a Using statement, thus in case of an exception, these objects are implicitly disposed.
The deserialization becomes quite simple if you just specify the Type to deserialize to. The Type is represented by the Type of your class. You can just write (see the sample code):
Dim myObject = [JsonSerializer].Deserialize(Of [MyObjectType])([JsonTextReader])
You don't need a FileStream, StreamWriter / StreamReader already use a FileStream internally on their own. StreamWriter creates the file if it doesn't exist.
The StreamReader is initialized explicitly with Encoding.UTF8: it's the default, it's simply a remainder that this is the Encoding used and that the file is saved without BOM signature.
Call Close() on the JsonTextWriter before you exit the Using block. The behavior is determined by the AutoCompleteOnClose property, set to True by default and it's safer.
When deserializing, set the JsonTextReader's FloatParseHandling property to FloatParseHandling.Double or FloatParseHandling.Decimal. Double is actually the default, just keep this in mind, in case you need to handle Decimal values, which are otherwise deserialized as Double.
The lower bound of arrays is 0, not 1
Make your Random object a static Field. This ensures a better functionality (or, it lets the class function properly, if you want).
In the modified sample class, I've overloaded the Constructor: passing True, will call the Build() method that fills the class object with random data.
Passing False, generates an empty object.
It's not necessary to make a copy of the deserialized values, you can generate a new class object from the JsonSerializer directly. For example:
Dim jsonPath = "d:\test.json"
' Passing True to the Constuctor, calls the Build() method
Dim serTest = New SerializationTest(True)
' Serialize all property values to the specified File
serTest.Serialize(jsonPath)
' Creates a new SerializationTest objects and fills it
' deserializing the JSON previously saved calling Serialize()
Dim serTest2 = New SerializationTest(False).Deserialize(jsonPath)
You can compare the two objects, serTest and serTest2
In case a copy is needed, see at the bottom.
Modified class:
Public Class SerializationTest
Private Shared rnd As New Random()
Public Sub New()
Me.New(False)
End Sub
Public Sub New(useBuilder As Boolean)
If useBuilder Then Build()
End Sub
Public Property DblArray As Double(,)
Public Property DblVector As Double()
Public Property StringVector As String()
Public Property IntVector As Integer()
Public Sub Serialize(jsonPath As String)
Using stream As New StreamWriter(jsonPath)
Dim jWriter As New JsonTextWriter(stream)
Dim serializer As New JsonSerializer()
serializer.Serialize(jWriter, Me)
jWriter.Close()
End Using
End Sub
Public Function Deserialize(jsonPath As String) As SerializationTest
Using reader As New StreamReader(jsonPath, Encoding.UTF8)
Dim jReader As New JsonTextReader(reader) With {
.FloatParseHandling = FloatParseHandling.Double
}
Dim serializer As New JsonSerializer()
Dim deserialized = serializer.Deserialize(Of SerializationTest)(jReader)
jReader.Close()
Return deserialized
End Using
End Function
Private Sub Build()
ReDim DblArray(1000, 1000)
ReDim DblVector(1000)
ReDim StringVector(1000)
ReDim IntVector(1000)
For i = 0 To 1000
DblVector(i) = rnd.NextDouble()
StringVector(i) = $"A{i}"
IntVector(i) = rnd.Next(1, 101)
For j = 0 To 1000
DblArray(i, j) = rnd.NextDouble()
Next
Next
End Sub
End Class
If you, for some reason, want to copy the deserialized values to the initialized, but empty, class object, then change the method like this:
Public Sub Deserialize(jsonPath As String)
Using reader As New StreamReader(jsonPath, Encoding.UTF8)
Dim jReader As New JsonTextReader(reader) With {
.FloatParseHandling = FloatParseHandling.Double
}
Dim serializer As New JsonSerializer()
Dim deserialized = serializer.Deserialize(Of SerializationTest)(jReader)
jReader.Close()
Me.DblArray = deserialized.DblArray
Me.DblVector = deserialized.DblVector
Me.StringVector = deserialized.StringVector
Me.IntVector = deserialized.IntVector
deserialized = Nothing
End Using
End Sub
And change the code that fills it in:
Dim serTest = New SerializationTest(False)
serTest.Deserialize(jsonPath)