Convert JSON results with variable field names and value types

Since your parameter names can be anything, I would suggest using a Dictionary(Of String, String) for that part. Declare your model classes like this:

Class RootObject
    Public Property Data As List(Of Item)
End Class

Class Item
    Public Property ID As String
    Public Property Name As String
    Public Property ObjCode As String
    Public Property ParameterValues As Dictionary(Of String, String)
End Class

Using a decent JSON library like Json.Net, you can deserialize the JSON into these models easily:

Dim root As RootObject = JsonConvert.DeserializeObject(Of RootObject)(json)

From there you can use the models like you would for any other class. For example, here is how you would dump out all the data to the console:

For Each item In root.Data
    Console.WriteLine("ID: " & item.ID)
    Console.WriteLine("Name: " & item.Name)
    Console.WriteLine("ObjCode: " & item.ObjCode)
    Console.WriteLine()

    Console.WriteLine(String.Format("{0,-45} {1}", "Parameter Name", "Parameter Value"))
    Console.WriteLine(New String("-", 45) & " " & New String("-", 20))

    For Each kvp In item.ParameterValues
        Console.WriteLine(String.Format("{0,-45} {1}", kvp.Key, kvp.Value))
    Next
Next

Working demo: https://dotnetfiddle.net/SqInI6

To address your updates:

It looks like your each of your parameter values can now be a either single string or an array of strings. This will crash the current code because the dictionary can only hold simple string values. You could change your dictionary declaration to Dictionary(Of String, Object) and that will allow it to deserialize, but if you do that you will end up with a mix of strings and JArrays in your dictionary. You will then need to check the type of value everywhere you use it and handle it appropriately, e.g.:

If kvp.Value Is GetType(JArray) Then
    Dim list As List(Of String) = DirectCast(kvp.Value, JArray).ToObject(Of List(Of String))
    ... handle multiple values ...
Else
    Dim str As String = DirectCast(kvp.Value, String)
    ... handle single value ...
End If

I think a better solution is to change your dictionary be a Dictionary(Of String, List(Of String)), and then use a custom JsonConverter to populate it from the JSON. That will allow you to handle the values uniformly in the rest of your code, because you know you will always have a list of strings.

If you went with that approach, you would need the following converter:

Public Class SingleOrArrayDictionaryConverter(Of T)
    Inherits JsonConverter

    Public Overrides Function CanConvert(objectType As Type) As Boolean
        Return objectType = GetType(Dictionary(Of String, List(Of T)))
    End Function

    Public Overrides Function ReadJson(reader As JsonReader, objectType As Type, existingValue As Object, serializer As JsonSerializer) As Object
        Dim obj = JObject.Load(reader)
        Dim dict = New Dictionary(Of String, List(Of T))
        For Each prop In obj.Properties()
            If prop.Value.Type = JTokenType.Array Then
                dict.Add(prop.Name, prop.Value.ToObject(Of List(Of T)))
            Else
                dict.Add(prop.Name, New List(Of T) From {prop.Value.ToObject(Of T)})
            End If
        Next
        Return dict
    End Function

    Public Overrides ReadOnly Property CanWrite As Boolean
        Get
            Return False
        End Get
    End Property

    Public Overrides Sub WriteJson(writer As JsonWriter, value As Object, serializer As JsonSerializer)
        Throw New NotImplementedException()
    End Sub
End Class

To use the converter, add a <JsonConverter> attribute to your ParameterValues property like this:

    <JsonConverter(GetType(SingleOrArrayDictionaryConverter(Of String)))>
    Public Property ParameterValues As Dictionary(Of String, List(Of String))

Demo: https://dotnetfiddle.net/oA3bfE