使用 C# & VB 中的 Newtonsoft.Json

using Newtonsoft.Json;
using System.Collections.Generic;

namespace Support.CSharp
{
    public static class JsonHelper
    {
        public static string FromClass<T>(T data, bool isEmptyToNull = false,
                                          JsonSerializerSettings jsonSettings = null)
        {
            string response = string.Empty;

            if (!EqualityComparer<T>.Default.Equals(data, default(T)))
                response = JsonConvert.SerializeObject(data, jsonSettings);

            return isEmptyToNull ? (response == "{}" ? "null" : response) : response;
        }

        public static T ToClass<T>
        (string data, JsonSerializerSettings jsonSettings = null)
        {
            var response = default(T);

            if (!string.IsNullOrEmpty(data))
                response = jsonSettings == null
                    ? JsonConvert.DeserializeObject<T>(data)
                    : JsonConvert.DeserializeObject<T>(data, jsonSettings);

            return response;
        }
    }
}

Imports Newtonsoft.Json

Public Module JsonHelper

    Public Function FromClass(Of T)(data As T,
                                    Optional isEmptyToNull As Boolean = False,
                                    Optional jsonSettings _
                                    As JsonSerializerSettings = Nothing) _
                                                          As String

        Dim response As String = String.Empty

        If Not EqualityComparer(Of T).Default.Equals(data, Nothing) Then
            response = JsonConvert.SerializeObject(data, jsonSettings)
        End If

        Return If(isEmptyToNull, (If(response = "{}", "null", response)), response)

    End Function

    Public Function ToClass(Of T)(data As String,
                                  Optional jsonSettings _
                                  As JsonSerializerSettings = Nothing) _
                                                        As T

        Dim response = Nothing

        If Not String.IsNullOrEmpty(data) Then
            response = If(jsonSettings Is Nothing,
                JsonConvert.DeserializeObject(Of T)(data),
                JsonConvert.DeserializeObject(Of T)(data, jsonSettings))
        End If

        Return response

    End Function

End Module

using Newtonsoft.Json;

namespace WinFormSimpleObject.Models
{
    public class Category
    {
        [JsonProperty("category_id")]
        public int CategoryId { get; set; }

        [JsonProperty("name")]
        public string Name { get; set; }

        [JsonProperty("meta_title")]
        public string MetaTitle { get; set; }

        [JsonProperty("meta_keywords")]
        public string MetaKeywords { get; set; }

        [JsonProperty("meta_description")]
        public string MetaDescription { get; set; }

        [JsonProperty("page_description")]
        public string PageDescription { get; set; }

        [JsonProperty("page_title")]
        public string PageTitle { get; set; }

        [JsonProperty("category_name")]
        public string CategoryName { get; set; }

        [JsonProperty("short_name")]
        public string ShortName { get; set; }

        [JsonProperty("long_name")]
        public string LongName { get; set; }

        [JsonProperty("num_children")]
        public int NumChildren { get; set; }
    }
}

Imports Newtonsoft.Json

Namespace Models

    Public Class Category

        <JsonProperty("category_id")>
        Public Property CategoryId As Integer

        <JsonProperty("name")>
        Public Property Name As String

        <JsonProperty("meta_title")>
        Public Property MetaTitle As String

        <JsonProperty("meta_keywords")>
        Public Property MetaKeywords As String

        <JsonProperty("meta_description")>
        Public Property MetaDescription As String

        <JsonProperty("page_description")>
        Public Property PageDescription As String

        <JsonProperty("page_title")>
        Public Property PageTitle As String

        <JsonProperty("category_name")>
        Public Property CategoryName As String

        <JsonProperty("short_name")>
        Public Property ShortName As String

        <JsonProperty("long_name")>
        Public Property LongName As String

        <JsonProperty("num_children")>
        Public Property NumChildren As Integer

    End Class

End Namespace

public Category Result { get; set; }

private const string fileName = "Etsy_Category.Json";
private readonly string filePath = Environment.CurrentDirectory;

private void GetData()
{
    // Retrieve JSON data from file
    var rawJson = File.ReadAllText(Path.Combine(filePath, fileName));

    // Convert to C# Class typed object
    Result = JsonHelper.ToClass<Category>(rawJson);
}

Public Property Result() As Category

Private Const fileName As String = "Etsy_Category.Json"
Private ReadOnly filePath As String = Environment.CurrentDirectory

Private Sub GetData()

    ' Retrieve JSON data from file
    Dim rawJson = File.ReadAllText(Path.Combine(filePath, fileName))

    ' Convert to C# Class typed object
    Result = JsonHelper.ToClass(Of Category)(rawJson)

End Sub

public class Pagination
{
    [JsonProperty("effective_limit")]
    public int? EffectiveLimit { get; set; }

    [JsonProperty("effective_offset")]
    public int? EffectiveOffset { get; set; }

    [JsonProperty("effective_page")]
    public int? EffectivePage { get; set; }

    [JsonProperty("next_offset")]
    public int? NextOffset { get; set; }

    [JsonProperty("next_page")]
    public int? NextPage { get; set; }
}

public class Params
{
    [JsonProperty("tag")]
    public string Tag { get; set; }
}

public class Response<TModel> where TModel : class
{
    [JsonProperty("count")]
    public int Count { get; set; }

    [JsonProperty("results")]
    public IList<TModel> Results { get; set; }

    [JsonProperty("params")]
    public Params Params { get; set; }

    [JsonProperty("type")]
    public string Type { get; set; }

    [JsonProperty("pagination")]
    public Pagination Pagination { get; set; }
}

Public Class Pagination

    <JsonProperty("effective_limit")>
    Public Property EffectiveLimit() As Integer?

    <JsonProperty("effective_offset")>
    Public Property EffectiveOffset() As Integer?

    <JsonProperty("effective_page")>
    Public Property EffectivePage() As Integer?

    <JsonProperty("next_offset")>
    Public Property NextOffset() As Integer?

    <JsonProperty("next_page")>
    Public Property NextPage() As Integer?

End Class

Public Class Params

    <JsonProperty("tag")>
    Public Property Tag As String

End Class

Public Class Response(Of TModel As Class)

    <JsonProperty("count")>
    Public Property Count As Integer

    <JsonProperty("results")>
    Public Property Results As IList(Of TModel)

    <JsonProperty("params")>
    Public Property Params As Params

    <JsonProperty("type")>
    Public Property Type As String

    <JsonProperty("pagination")>
    Public Property Pagination As Pagination

End Class

public BindingList<Category> Categories { get; set; }

private void GetData()
{
    // Retrieve JSON data from file
    var rawJson = File.ReadAllText(Path.Combine(filePath, fileName));

    // Convert to C# Class typed object
    var response = JsonHelper.ToClass<Response<Category>>(rawJson);

    // Get collection of objects
    if (response != null && response.Results != null && response.Results.Count > 0)
    {
        var data = response.Results;
        Categories.Clear();
        for (int i = 0; i < data.Count; i++)
        {
            Categories.Add(data[i]);
        }
    }
}

Public Property Categories() As BindingList(Of Category)

Private Sub GetData()

    ' Retrieve JSON data from file
    Dim rawJson = File.ReadAllText(Path.Combine(filePath, fileName))

    ' Convert to C# Class typed object
    Dim response = JsonHelper.ToClass(Of Response(Of Category))(rawJson)

    ' Get collection of objects
    If response IsNot Nothing _
        AndAlso response.Results IsNot Nothing _
        AndAlso response.Results.Count > 0 Then

        Dim data = response.Results
        Categories.Clear()
        For i As Integer = 0 To data.Count - 1
            Categories.Add(data(i))
        Next

    End If

End Sub

internal static class Unix
{
    internal static readonly DateTime Epoch = new DateTime
    (year: 1970, month: 1, day: 1, hour: 0, minute: 0, second: 0, millisecond: 0, 
     kind: DateTimeKind.Utc);
}

public static class DoubleExtensions
{
    public static DateTime FromUnixDate(this double? unixDate)
    {
        return Unix.Epoch.AddSeconds(unixDate ?? 0.0);
    }

    public static DateTime FromUnixDate(this double unixDate)
    {
        return Unix.Epoch.AddSeconds(unixDate);
    }
}

public sealed class JsonUnixDateConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(DateTime) || objectType == typeof(DateTime?);
    }

    public override object ReadJson(JsonReader reader, Type objectType, 
                    object existingValue, JsonSerializer serializer)
    {
        double value = 0;
        if (double.TryParse(Convert.ToString(reader.Value), out value))
            return value.FromUnixDate();

        if (objectType == typeof(DateTime))
            return default(DateTime);

        return null;
    }

    public override void WriteJson
    (JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

Friend Module Unix

    Friend ReadOnly Epoch As New DateTime(year:=1970, month:=1, day:=1, 
           hour:=0, minute:=0, second:=0, millisecond:=0, kind:=DateTimeKind.Utc)

End Module

Public Module DoubleExtensions

    <Extension>
    Public Function FromUnixDate(unixDate As Double?) As DateTime
        Return Epoch.AddSeconds(If(unixDate, 0.0))
    End Function

    <Extension>
    Public Function FromUnixDate(unixDate As Double) As DateTime
        Return Epoch.AddSeconds(unixDate)
    End Function

End Module

Public NotInheritable Class JsonUnixDateConverter : Inherits JsonConverter

    Public Overrides Function CanConvert(objectType As Type) As Boolean
        Return objectType Is GetType(DateTime) OrElse objectType Is GetType(Date?)
    End Function

    Public Overrides Function ReadJson(reader As JsonReader, objectType As Type, 
           existingValue As Object, serializer As JsonSerializer) As Object

        Dim value As Double = 0
        If Double.TryParse(Convert.ToString(reader.Value), value) Then
            Return value.FromUnixDate()
        End If

        If objectType Is GetType(DateTime) Then
            Return Nothing
        End If

        Return Nothing

    End Function

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

End Class

[JsonProperty("lastupdate"), JsonConverter(typeof(JsonUnixDateConverter))]
public DateTime? LastUpdate { get; set; }

<JsonProperty("lastupdate"), JsonConverter(GetType(JsonUnixDateConverter))>
Public Property LastUpdate() As Date?

public class Comments
{
    [JsonProperty("_content")]
    public int Count { get; set; }
}

public class Photo
{
    [JsonProperty("comments")]
    public Comments Comments { get; set; }
}

public class Comments
{
    [JsonProperty("_content")]
    public string Content { get; set; }
}

public class Photo
{
    [JsonProperty("comments")]
    public Comments Comments { get; set; }
}

int GetCommentCount(Photo photo)
{
    return photo.Comments.Count;
}

Private Function GetCommentCount(photo As Photo) As Integer
    Return photo.Comments.Count
End Function

int GetCommentCount(Photo photo)
{
    return photo.CommentCount;
}

Private Function GetCommentCount(photo As Photo) As Integer
    Return photo.CommentCount
End Function

public sealed class JsonFlickrContentConverter<TModel> : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(TModel);
    }

    public override object ReadJson(JsonReader reader, Type objectType, 
                    object existingValue, JsonSerializer serializer)
    {
        var result = default(TModel);

        switch (reader.TokenType)
        {
            case JsonToken.Integer:
            case JsonToken.Float:
            case JsonToken.String:
            case JsonToken.Boolean:
            case JsonToken.Date:
                // convert from string or type to correct type
                // eg: "isfavorite": 0 to bool? = false
                result = (TModel)Convert.ChangeType(reader.Value, GetUnderlyingType());
                break;
            case JsonToken.StartObject:
                // sub-node _content holds actual value
                //  eg: "comments": { "_content": "483" } to int? = 483
                GetObject(reader, out result);
                break;
        }
        return result;
    }

    private void GetObject(JsonReader reader, out TModel result)
    {
        var tags = JObject.Load(reader).FindTokens("_content");
        result = (tags != null && tags.Count > 0)
            ? (TModel)Convert.ChangeType((string)tags[0], GetUnderlyingType())
            : result = default(TModel);
    }

    // converts Generic nullable type to underlying type
    // eg: int? to int
    private Type GetUnderlyingType()
    {
        var type = typeof(TModel);
        return Nullable.GetUnderlyingType(type) ?? type;
    }

    public override void WriteJson
    (JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

Public NotInheritable Class JsonFlickrContentConverter(Of TModel) : _
                                               Inherits JsonConverter

    Public Overrides Function CanConvert(objectType As Type) As Boolean
        Return objectType = GetType(TModel)
    End Function

    Public Overrides Function ReadJson(reader As JsonReader, _
    objectType As Type, existingValue As Object, serializer As JsonSerializer) As Object

        Dim result = Nothing

        Select Case reader.TokenType
            Case JsonToken.[Integer],
                 JsonToken.Float,
                 JsonToken.[String],
                 JsonToken.[Boolean],
                 JsonToken.[Date]
                ' convert from string or type to correct type
                ' eg: "isfavorite": 0 to bool? = false
                result = DirectCast(Convert.ChangeType_
                         (reader.Value, GetUnderlyingType()), TModel)
                Exit Select
            Case JsonToken.StartObject
                ' sub-node _content holds actual value
                '  eg: "comments": { "_content": "483" } to int? = 483
                GetObject(reader, result)
                Exit Select
        End Select

        Return result

    End Function

    Private Sub GetObject(reader As JsonReader, ByRef result As TModel)

        Dim tags = JObject.Load(reader).FindTokens("_content")

        result = If((tags IsNot Nothing AndAlso tags.Count > 0),
            DirectCast(Convert.ChangeType(CType(tags(0), String), _
                       GetUnderlyingType()), TModel),
            Nothing)

    End Sub

    ' converts Generic nullable type to underlying type
    ' eg: int? to int
    Private Function GetUnderlyingType() As Type
        Dim type = GetType(TModel)
        Return If(Nullable.GetUnderlyingType(type), type)
    End Function

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

End Class

public class Photo
{
    [JsonProperty("comments"), JsonConverter(typeof(JsonFlickrContentConverter<int?>))]
    public int? Comments { get; set; }
}

Public Class Photo
    <JsonProperty("comments"), _
     JsonConverter(GetType(JsonFlickrContentConverter(Of Integer?)))>
    Public Property Comments() As Integer?
End Class

public class Photo
{
    [JsonProperty("notes")]
    public Notes Notes { get; set; }
}

public class Notes
{
    [JsonProperty("note")]
    public IList<Note> Note { get; set; }
}

Public Class Photo

    <JsonProperty("notes")>
    Public Property Notes As Notes

End Class

Public Class Notes

    <JsonProperty("note")>
    Public Property Note As IList(Of Note)

End Class

public sealed class JsonFlickrCollectionConverter<TModel> : 
                    JsonConverter where TModel : class
{
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(TModel);
    }

    public override object ReadJson(JsonReader reader, _
    Type objectType, object existingValue, JsonSerializer serializer)
    {
        // A collection type containing only a collection of type
        // eg: "urls": { "url": [{...}, {...}, ...] }
        if (reader.TokenType == JsonToken.StartObject)
        {
            var jObj = JObject.Load(reader);
            if (jObj.HasValues)
            {
                var items = new List<TModel>();
                foreach (var value in jObj.Values())
                {
                    try
                    {
                        items.AddRange_
                        (JsonHelper.ToClass<IList<TModel>>(value.ToString()));
                    }
                    catch (Exception)
                    {
                        // unexpected type
                        return null;
                    }
                }
                return items;
            }
        }
        return null;
    }

    public override void WriteJson(JsonWriter writer, 
                    object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

Public NotInheritable Class JsonFlickrCollectionConverter(Of TModel As Class) : _
                      Inherits JsonConverter

    Public Overrides Function CanConvert(objectType As Type) As Boolean
        Return objectType = GetType(TModel)
    End Function

    Public Overrides Function ReadJson(reader As JsonReader, _
    objectType As Type, existingValue As Object, serializer As JsonSerializer) As Object

        ' A collection type containing only a collection of type
        ' eg: "urls": { "url": [{...}, {...}, ...] }
        If reader.TokenType = JsonToken.StartObject Then

            Dim jObj = JObject.Load(reader)

            If jObj.HasValues Then

                Dim items = New List(Of TModel)

                For Each value In jObj.Values()
                    Try
                        items.AddRange(JsonHelper.ToClass_
                        (Of IList(Of TModel))(value.ToString()))
                    Catch generatedExceptionName As Exception
                        ' unexpected type
                        Return Nothing
                    End Try
                Next

                Return items

            End If

        End If

        Return Nothing

    End Function

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

End Class

[JsonProperty("notes"), JsonConverter(typeof(JsonFlickrCollectionConverter<Note>))]
public IList<Note> Notes { get; set; }

<JsonProperty("notes"), JsonConverter(GetType(JsonFlickrCollectionConverter(Of Note)))>
Public Property Notes() As IList(Of Note)

public interface IDataType
{
}

Public Interface IDataType
End Interface

public sealed class JsonDataTypeConverter : JsonConverter
{
    // destination data type
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(IDataType);
    }

    public override object ReadJson(JsonReader reader, Type objectType, 
                                    object existingValue, JsonSerializer serializer)
    {
        List<IDataType> results = null;

        // Are there multiple results?
        if (reader.TokenType== JsonToken.StartArray)
        {
            // Retrieve a list of Json objects
            var jObjs = serializer.Deserialize<IList<JObject>>(reader);
            if (jObjs != null && jObjs.Count > 0)
            {
                results = new List<IDataType>();

                for (int i = 0; i < jObjs.Count; i++)
                {
                    // Does the object contain a "media_type" 
                    // identifier - eg: "media_type":
                    var token = jObjs[i].FindTokens("media_type");
                    if (token != null && token.Count > 0)
                    {
                        // Only one is expected
                        switch (token[0].ToString())
                        {
                            // "media_type": "tv"
                            case "tv":
                                results.Add(Convert<TV>(jObjs[i]));
                                break;
                            // "media_type": "movie"
                            case "movie":
                                results.Add(Convert<Movie>(jObjs[i]));
                                break;
                            // "media_type": "person"
                            case "person":
                                results.Add(Convert<Person>(jObjs[i]));
                                break;
                        }
                    }
                }
            }
        }
        return results;
    }

    // Convert Json Object data into a specified class type
    private TModel Convert<TModel>(JObject jObj) where TModel : IDataType
    {
        return JsonHelper.ToClass<TModel>(jObj.ToString());
    }

    // one way conversion, so back to Json is not required
    public override void WriteJson
    (JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

Public NotInheritable Class JsonDataTypeConverter : Inherits JsonConverter

    ' destination data type
    Public Overrides Function CanConvert(objectType As Type) As Boolean
        Return objectType = GetType(IDataType)
    End Function

    Public Overrides Function ReadJson(reader As JsonReader, objectType As Type, _
                     existingValue As Object, serializer As JsonSerializer) As Object

        Dim results As List(Of IDataType) = Nothing

        ' Are there multiple results?
        If reader.TokenType = JsonToken.StartArray Then

            ' Retrieve a list of Json objects
            Dim jObjs = serializer.Deserialize(Of IList(Of JObject))(reader)
            If jObjs IsNot Nothing AndAlso jObjs.Count > 0 Then
                results = New List(Of IDataType)()

                For i As Integer = 0 To jObjs.Count - 1

                    ' Does the object contain a "media_type" identifier - 
                    ' e.g.: "media_type":
                    Dim token = jObjs(i).FindTokens("media_type")
                    If token IsNot Nothing AndAlso token.Count > 0 Then

                        ' Only one is expected
                        Select Case token(0).ToString()
                            ' "media_type": "tv"
                            Case "tv"
                                results.Add(Convert(Of TV)(jObjs(i)))
                                Exit Select
                            ' "media_type": "movie"
                            Case "movie"
                                results.Add(Convert(Of Movie)(jObjs(i)))
                                Exit Select
                            ' "media_type": "person"
                            Case "person"
                                results.Add(Convert(Of Person)(jObjs(i)))
                                Exit Select
                        End Select

                    End If
                Next
            End If
        End If

        Return results

    End Function

    ' Convert Json Object data into a specified class type
    Private Function Convert(Of TModel As IDataType)(jObj As JObject) As TModel
        Return JsonHelper.ToClass(Of TModel)(jObj.ToString())
    End Function

    ' one way conversion, so back to Json is not required
    Public Overrides Sub WriteJson(writer As JsonWriter, _
                                   value As Object, serializer As JsonSerializer)
        Throw New NotImplementedException()
    End Sub

End Class

public class Response
{
    [JsonProperty("results"), JsonConverter(typeof(JsonDataTypeConverter))]
    public IList<IDataType> Results { get; set; }
}

Public Class Response

    <JsonProperty("results"), JsonConverter(GetType(JsonDataTypeConverter))>
    Public Property Results() As IList(Of IDataType)

End Class

public class File : IResourceKind
{
    [JsonProperty("kind")]
    public string Kind { get; set; }

    [JsonProperty("mimeType")]
    public string MimeType { get; set; }
}

public class Folder : File
{
}

public class TxtDocument : File
{
}

public class WordDocument : File
{
}

public class PngImage : File
{
}

public class JpgImage : File
{
}

public class Zipped : File
{
}

Public Class File : Implements IResourceKind

    <JsonProperty("kind")>
    Public Property Kind As String

    <JsonProperty("mimeType")>
    Public Property MimeType As String

End Class

Public Class Folder : Inherits File
End Class

Public Class TxtDocument : Inherits File
End Class

Public Class WordDocument : Inherits File
End Class

Public Class PngImage : Inherits File
End Class

// only some types are lists for brevity
private readonly Dictionary<string, Func<JObject, File>> mimeTypes
    = new Dictionary<string, Func<JObject, File>>
{
    { "application/vnd.google-apps.folder", Convert<Folder>() },
    { "image/jpeg", Convert<JpgImage>() },
    { "image/png", Convert<PngImage>() },
    { "application/zip", Convert<Zipped>() },
    { "application/x-zip-compressed", Convert<Zipped>() },
    { "video/mp4", Convert<Mp4Video>() },
    { "text/plain", Convert<TxtDocument>() },
    { "application/vnd.openxmlformats-officedocument.presentationml.presentation",
      Convert<PptDocument>() },
    { "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
      Convert<WordDocument>() }
};

// Convert file of type.... mimeTypes
private void ProcessFileType(List<File> results, IList<JObject> jObjs, int i)
{
    var fileToken = jObjs[i].FindTokens("mimeType");
    if (fileToken != null && fileToken.Count > 0)
    {
        var key = mimeTypes.Keys.FirstOrDefault(x => x.Equals(fileToken[0].ToString()));
        if (key != null)
        {
            results.Add(mimeTypes[key](jObjs[i]));
        }
    }
}

// Convert Json Object data into a specified class type
private static Func<JObject, File> Convert<TModel>() where TModel : File
{
    return (jObj) => JsonHelper.ToClass<TModel>(jObj.ToString());
}

' only some types are lists for brevity
Private ReadOnly mimeTypes As New Dictionary(Of String, Func(Of JObject, File))() From {
    {"application/vnd.google-apps.folder", Convert(Of Folder)()},
    {"image/jpeg", Convert(Of JpgImage)()},
    {"image/png", Convert(Of PngImage)()},
    {"application/zip", Convert(Of Zipped)()},
    {"application/x-zip-compressed", Convert(Of Zipped)()},
    {"video/mp4", Convert(Of Mp4Video)()},
    {"text/plain", Convert(Of TxtDocument)()},
    {"application/vnd.openxmlformats-officedocument.presentationml.presentation",
     Convert(Of PptDocument)()},
    {"application/vnd.openxmlformats-officedocument.wordprocessingml.document",
     Convert(Of WordDocument)()}
}

' Convert file of type.... mimeTypes
Private Sub ProcessFileType(results As List(Of File), _
                            jObjs As IList(Of JObject), i As Integer)

    Dim fileToken = jObjs(i).FindTokens("mimeType")

    If fileToken IsNot Nothing AndAlso fileToken.Count > 0 Then

        Dim key = mimeTypes.Keys.FirstOrDefault(Function(x) _
                  x.Equals(fileToken(0).ToString()))

        If key IsNot Nothing Then
            results.Add(mimeTypes(key)(jObjs(i)))
        End If

    End If

End Sub

' Convert Json Object data into a specified class type
Private Shared Function Convert(Of TModel As File)() As Func(Of JObject, File)
    Return Function(jObj) JsonHelper.ToClass(Of TModel)(jObj.ToString())
End Function

// Convert Json Object data into a specified class type
private TModel Convert<TModel>(JObject jObj) where TModel : IDataType
{
    return JsonHelper.ToClass<TModel>(jObj.ToString());
}

' Convert Json Object data into a specified class type
Private Function Convert(Of TModel As IDataType)(jObj As JObject) As TModel
    Return JsonHelper.ToClass(Of TModel)(jObj.ToString())
End Function

public class Person : RecordBase
{
    [JsonProperty("known_for"), JsonConverter(typeof(JsonDataTypeConverter))]
    public IList<IDataType> KnownFor { get; set; }
}

Public Class Person : Inherits RecordBase

    <JsonProperty("known_for"), JsonConverter(GetType(JsonDataTypeConverter))>
    Public Property KnownFor As IList(Of IDataType)

End Class

public class UserAgentModel
{
    // trimmed for brevity

    [JsonProperty("plugins")]
    [JsonConverter(typeof(UserAgentPluginsConverter))]
    public List<PluginModel> Plugins { get; set; }
}

public class PluginModel
{
    public string Id { get; set; }
    public List<PluginObjectModel> Values { get; set; }
}

public class PluginObjectModel
{
    public string Id { get; set; }
    public object Value { get; set; }
}

Public Class UserAgentModel

    ' trimmed for brevity

    <JsonProperty("plugins")>
    <JsonConverter(GetType(UserAgentPluginsConverter))>
    Public Property Plugins As List(Of PluginModel)

End Class

Public Class PluginModel

    Public Property Id As String
    Public Property Values As List(Of PluginObjectModel)

End Class

Public Class PluginObjectModel

    Public Property Id As String
    Public Property Value As Object

End Class

public class UserAgentPluginsConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(PluginModel);
    }
 
    public override object ReadJson(JsonReader reader, Type objectType,
                                    object existingValue, JsonSerializer serializer)
    {
        List<PluginModel> result = new List<PluginModel>();
 
        // Is this the start of an object?
        if (reader.TokenType == JsonToken.StartObject)
        {
            var jObj = JObject.Load(reader);
            if (jObj.HasValues)
            {
                // Step through each top property node
                foreach (var child in jObj.Children())
                {
                    result.Add(new PluginModel
                    {
                        Id = child.Path,
                        Values =  ProcessChild(child, serializer)
                    });
                } 
            }
        }
        
        return result;
    }
 
    private List<PluginObjectModel> ProcessChild(JToken child, JsonSerializer serializer)
    {
        var objects = new List<PluginObjectModel>();
        var node = serializer.Deserialize<JProperty>(child.CreateReader());
 
        if (node.HasValues)
        {
            foreach (var jToken in node.Values())
            {
                var item = serializer.Deserialize<JProperty>(jToken.CreateReader());
                objects.Add(new PluginObjectModel
                {
                    Id = item.Name,
                    Value = item.Value.ToString()
                });
            } 
        }
 
        return objects;
    }
 
    public override void WriteJson
    (JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

Public Class UserAgentPluginsConverter : Inherits JsonConverter

    Public Overrides Function CanConvert(objectType As Type) As Boolean
        Return objectType = GetType(PluginModel)
    End Function

    Public Overrides Function ReadJson(reader As JsonReader, objectType As Type, _
                                       existingValue As Object, _
                                       serializer As JsonSerializer) As Object

        Dim result = New List(Of PluginModel)()

        If reader.TokenType = JsonToken.StartObject Then
            Dim jObj = JObject.Load(reader)

            If jObj.HasValues Then

                For Each child In jObj.Children()
                    result.Add(New PluginModel With {
                        .Id = child.Path,
                        .Values = ProcessChild(child, serializer)
                    })
                Next
            End If
        End If

        Return result
    End Function

    Private Function ProcessChild(child As JToken, serializer As JsonSerializer) _
                                  As List(Of PluginObjectModel)

        Dim objects = New List(Of PluginObjectModel)()
        Dim node = serializer.Deserialize(Of JProperty)(child.CreateReader())

        If node.HasValues Then

            objects.AddRange(From jToken In node.Values()
                             Select item = serializer.Deserialize_
                             (Of JProperty)(jToken.CreateReader())
                             Select New PluginObjectModel With
                                {
                                    .Id = item.Name,
                                    .Value = item.Value.ToString()
                                })
        End If

        Return objects
    End Function

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

End Class

public sealed class JsonApiRateLimitsConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(RateCategoryModel);
    }

    public override object ReadJson(JsonReader reader, Type objectType, 
                    object existingValue, JsonSerializer serializer)
    {
        ObservableCollection<RateCategoryModel> result = null;

        // is this the start of an object?
        if (reader.TokenType == JsonToken.StartObject)
        {
            var jObj = JObject.Load(reader);
            if (jObj.HasValues)
            {
                // Step through each top property node
                result = new ObservableCollection<RateCategoryModel>();
                foreach (var child in jObj.Children())
                {
                    var rate = ProcessChild(child, serializer);
                    if (rate != null) result.Add(rate);
                }
            }
        }
        return result;
    }

    private static RateCategoryModel ProcessChild(JToken child, JsonSerializer serializer)
    {
        RateCategoryModel rate = null;
        var node = serializer.Deserialize<JProperty>(child.CreateReader());
        if (node.HasValues)
        {
            // step through each sub-property node
            rate = new RateCategoryModel { Name = node.Name };
            foreach (var item in node.Values())
            {
                var limit = serializer.Deserialize<JProperty>(item.CreateReader());
                rate.Limits.Add(new RateLimitModel
                {
                    // we only want the last part of the property name
                    Name = GetPropertyName(limit),
                    Limit = GetRateLimit(limit)
                });
            }
        }
        return rate;
    }

    private static string GetPropertyName(JProperty prop)
    {
        string name = string.Empty;

        if (!string.IsNullOrEmpty(prop.Name))
        {
            var parts = prop.Name.Split(new[] { '/' }, 
                        StringSplitOptions.RemoveEmptyEntries);
            name = string.Join("_", parts.Skip(1)).Replace(":", "");
            if (string.IsNullOrEmpty(name))
                name = prop.Name.Replace("/", "");
        }
        else
        {
            name = "__noname__";
        }

        return name;
    }

    private static ApiRateLimitModel GetRateLimit(JProperty limit)
    {
        ApiRateLimitModel model = null;

        if (!string.IsNullOrEmpty(limit.First.ToString()))
        {
            var rawJson = limit.First.ToString();
            model = JsonHelper.ToClass<ApiRateLimitModel>(rawJson);
        }

        return model;
    }

    public override void WriteJson
    (JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

Public NotInheritable Class JsonApiRateLimitsConverter : Inherits JsonConverter

    Public Overrides Function CanConvert(objectType As Type) As Boolean
        Return objectType = GetType(RateCategoryModel)
    End Function

    Public Overrides Function ReadJson(reader As JsonReader, _
      objectType As Type, existingValue As Object, 
                          serializer As JsonSerializer) As Object

        Dim result As ObservableCollection(Of RateCategoryModel) = Nothing

        ' is this the start of an object?
        If reader.TokenType = JsonToken.StartObject Then

            Dim jObj = JObject.Load(reader)
            If jObj.HasValues Then

                ' Step through each top property node
                result = New ObservableCollection(Of RateCategoryModel)()
                For Each child In jObj.Children()

                    Dim rate = ProcessChild(child, serializer)

                    If rate IsNot Nothing Then
                        result.Add(rate)
                    End If

                Next

            End If
        End If

        Return result

    End Function

    Private Shared Function ProcessChild(child As JToken, _
            serializer As JsonSerializer) As RateCategoryModel

        Dim rate As RateCategoryModel = Nothing
        Dim node = serializer.Deserialize(Of JProperty)(child.CreateReader())

        If node.HasValues Then

            ' step through each sub-property node
            rate = New RateCategoryModel() With {.Name = node.Name}

            For Each item In node.Values()

                Dim limit = serializer.Deserialize(Of JProperty)(item.CreateReader())

                ' we only want the last part of the property name
                rate.Limits.Add(New RateLimitModel() With
                {
                    .Name = GetPropertyName(limit),
                    .Limit = GetRateLimit(limit)
                })

            Next

        End If

        Return rate

    End Function

    Private Shared Function GetPropertyName(prop As JProperty) As String

        Dim name As String = String.Empty

        If Not String.IsNullOrEmpty(prop.Name) Then

            Dim parts = prop.Name.Split(New Char() _
                        {"/"c}, StringSplitOptions.RemoveEmptyEntries)
            name = String.Join("_", parts.Skip(1)).Replace(":", "")

            If String.IsNullOrEmpty(name) Then
                name = prop.Name.Replace("/", "")
            End If

        Else
            name = "__noname__"
        End If

        Return name

    End Function

    Private Shared Function GetRateLimit(limit As JProperty) As ApiRateLimitModel

        Dim model As ApiRateLimitModel = Nothing

        If Not String.IsNullOrEmpty(limit.First.ToString()) Then
            Dim rawJson = limit.First.ToString()
            model = JsonHelper.ToClass(Of ApiRateLimitModel)(rawJson)
        End If

        Return model

    End Function

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

public class APIRateStatusModel
{
    [JsonProperty("resources"), JsonConverter(typeof(JsonApiRateLimitsConverter))]
    public ObservableCollection<RateCategoryModel> Resources { get; set; }
}

Public Class APIRateStatusModel

    <JsonProperty("resources"), JsonConverter(GetType(JsonApiRateLimitsConverter))>
    Public Property Resources() As ObservableCollection(Of RateCategoryModel)

End Class

private void GetData()
{
    // Retrieve JSON data from file
    var rawJson = File.ReadAllText(Path.Combine(filePath, fileName));

    // Convert to C# Class List of typed objects
    Result = JsonHelper.ToClass<APIRateStatusModel>(rawJson);
}

Private Sub GetData()

    ' Retrieve JSON data from file
    Dim rawJson = File.ReadAllText(Path.Combine(filePath, fileName))

    ' Convert to C# Class List of typed objects
    Result = JsonHelper.ToClass(Of APIRateStatusModel)(rawJson)

End Sub