Project Overview

This project implements a JSON parser in C# that transforms JSON text into usable data structures and vice versa. The implementation includes a lexer for tokenization, a parser for syntactic analysis, and a serializer for converting objects back to JSON text.

View on GitHub

Key Features

  • Lexical analysis with comprehensive token handling
  • Recursive descent parsing
  • Support for all JSON data types
  • Robust error handling
  • Clean, maintainable code structure

Implementation Details

Basic Usage

string json = "{ \"name\": \"John\", \"age\": 30, \"isStudent\": false }";

// Tokenize
var lexer = new JsonLexer(json);
var tokens = lexer.Tokenize();

// Parse
var parser = new JsonParser(tokens);
var jsonObject = parser.Parse();

// Serialize back to string
var serializer = new JsonSerializer();
string jsonString = serializer.Serialize(jsonObject);

Core Components

  1. Lexical Analysis
public class JsonLexer 
{
    // Converts JSON text into tokens
    public IEnumerable<Token> Tokenize()
    {
        // Handle whitespace and special characters
        // Support escape sequences in strings
        // Validate numeric formats
        // Recognize keywords (true, false, null)
    }
}
  1. Parsing
public class JsonParser 
{
    // Constructs JSON object model from tokens
    public JsonValue Parse()
    {
        // Implement recursive descent parsing
        // Handle nested structures
        // Provide detailed error messages
    }
}
  1. Value Types
public abstract class JsonValue { }

public class JsonObject : JsonValue 
{
    // Represents JSON objects with key-value pairs
}

public class JsonArray : JsonValue 
{
    // Represents JSON arrays
}

public class JsonPrimitive : JsonValue 
{
    // Represents primitive values (strings, numbers, booleans, null)
}

Error Handling

The implementation includes comprehensive error handling:

try 
{
    var parser = new JsonParser(tokens);
    var result = parser.Parse();
}
catch (JsonParseException ex)
{
    // Handle parsing errors:
    // - Malformed JSON
    // - Invalid tokens
    // - Unexpected characters
    // - Unterminated strings
    // - Invalid escape sequences
    // - Improper nesting
}

Technical Challenges

  • Handling nested structures efficiently
  • Managing different numeric formats
  • Implementing proper error recovery
  • Optimizing performance for large JSON files
  • Ensuring strict JSON specification compliance

Future Improvements

  • Stream processing support
  • Performance optimizations
  • Additional validation features
  • Schema validation
  • Pretty printing options

Resources