GenJson is a zero-allocation, high-performance C# Source Generator library that automatically creates ToJson() and FromJson() methods for your classes and structs.

This project is compatible with both pure C# projects and Unity3D.

• Compile-Time Generation: No reflection overhead at runtime.
• Zero Allocation Serialization*: Uses Span based string creation to write directly into the result string's memory, avoiding StringBuilder and intermediate string allocations for primitives.
• Zero Allocation Deserialization*: Uses ReadOnlySpan and ReadOnlySpan (UTF-8) based parsing logic to avoid intermediate string allocations.
• Easy Integration: Simply mark your classes with the [GenJson] attribute.
• Rich Type Support:
  • Primitives: int, string, bool, double, float, decimal etc
  • Standard Types: Guid, Uri, Version, DateTime, TimeSpan, DateTimeOffset
  • Dictionaries: IReadOnlyDictionary
  • Collections: IEnumerable
  • Enums: Serialized as backing type (default) or string
  • Nested Objects: Recursive serialization of complex object graphs

DateOnly and TimeOnly are not supported (requires .NET 6+; the library targets netstandard2.1)

Zero-allocation* means that no unnecessary memory allocations are performed. Only the resulting objects are allocated.

• System.Text.Json
• Newtonsoft.Json
• Utf8Json

Install from Nuget

Install from OpenUPM

• Download the latest release from releases
• Place the downloaded package file inside the Packages folder in your unity project
• Reference the package using the Add Package from tar button in the Unity Package Manager (docs)

• Add the [GenJson] attribute to any class, record, or struct you wish to serialize.
• The type must be partial.
• All types (classes, records, and structs) support parameterized constructors and primary constructors.
• If no parameterized constructor is used, a parameterless constructor (implicit or explicit) must be available.

You can control how enums are serialized by marking the enum type itself with:

• [GenJsonEnumAsNumber] to serialize as a number (default).
• [GenJsonEnumAsText] to serialize as a string.

You can also override this behavior for specific properties by applying the attribute directly to the property:

You can customize the name of the property in the generated JSON using the [GenJsonPropertyName] attribute.

This works for records as well:

You can prevent a property from being serialized or deserialized using the [GenJsonIgnore] attribute.

When deserializing enums, you can specify a fallback value to use if the JSON contains a value that doesn't match any enum member. This is useful for handling unknown values from external APIs (e.g., future enum values).

Use the [GenJsonEnumFallback] attribute on the enum type definition.

When an enum is used as a Dictionary key (e.g., Dictionary), and the JSON contains a key that doesn't match any enum member:

• If [GenJsonEnumFallback] is present, the invalid key-value pair will be skipped (ignored).
• If [GenJsonEnumFallback] is NOT present, deserialization will return null (fail).

You can define custom logic for serializing and deserializing specific properties or entire types using the [GenJsonConverter] attribute.

1. Define a class with static methods GetSize, WriteJson, and FromJson (and their UTF8 variants if needed).
2. Apply [GenJsonConverter(typeof(YourConverter))] to the property, class, or struct.

You can also apply it directly to a type, and override it on specific properties if needed:

The generator creates a ToJson() method.

The generator creates static FromJson and FromJsonUtf8 methods on your class.

GenJson will generate slightly different code depending on the status of the nullable C# feature.

Given the class below with the nullable feature disabled, both Name and Description may be deserialized as null when they are not available in the JSON.

Given the class below with the nullable feature enabled, Description may still be null like before, but the object will fail to be deserialized if Name is missing.

GenJson supports serialization of inherited properties. Simply mark both the base class and the derived class with [GenJson].

GenJson supports polymorphic serialization and deserialization.

1. Mark the base class (can be abstract) with [GenJsonPolymorphic].
   • This is optional and is only needed if you want to change it.
2. Register known derived types using [GenJsonDerivedType(typeof(Derived), identifier)].
   • The identifier can be an int or a string.

Serialization: The generator will automatically include the discriminator property ($type: "dog") in the JSON output.

Deserialization: Animal.FromJson(...) will inspect the $type property and deserialize into the correct derived type (Dog or Cat). If the type is unknown or missing (for abstract bases), it returns null.

GenJson optimizes collection deserialization (Lists, Arrays, Dictionaries) by pre-allocating the collection with the exact size. This avoids resizing overhead during population.

How it works:

• Serialization: The generator automatically emits a hidden property named after the collection with a $ prefix (e.g., "$MyList": 5) immediately before the collection property.
• Deserialization: The parser reads this count property first and initializes the collection with the correct capacity (e.g., new List(5)).

Disabling Optimization: To maintain strictly standard JSON or avoid extra metadata properties, apply the [GenJsonSkipCountOptimization] attribute to your class or struct.

GenJson analyzes your code during compilation and generates specialized serialization code.

• Serialization: It pre-calculates the exact size needed for the JSON string and uses string.Create to fill the content directly via a Span. This avoids the "double allocation" problem of StringBuilder (buffer resizing + final string) and eliminates allocations for formatting numbers and other primitives.
• Deserialization: It generates a recursive descent parser that operates on ReadOnlySpan, avoiding substring allocations during parsing.