Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/paolo-rossi/delphi-neon
JSON Serialization library for Delphi
https://github.com/paolo-rossi/delphi-neon
delphi json rest rtti serializer
Last synced: about 1 month ago
JSON representation
JSON Serialization library for Delphi
- Host: GitHub
- URL: https://github.com/paolo-rossi/delphi-neon
- Owner: paolo-rossi
- License: apache-2.0
- Created: 2019-03-16T15:54:35.000Z (over 5 years ago)
- Default Branch: master
- Last Pushed: 2024-01-28T09:06:33.000Z (5 months ago)
- Last Synced: 2024-01-28T12:23:25.248Z (5 months ago)
- Topics: delphi, json, rest, rtti, serializer
- Language: Pascal
- Homepage:
- Size: 6.22 MB
- Stars: 272
- Watchers: 36
- Forks: 74
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Lists
- awesome-pascal - Neon
README
# Neon - JSON Serialization Library for Delphi
## What is Neon
[](https://github.com/paolo-rossi/delphi-neon/release)
[](https://github.com/paolo-rossi/delphi-neon/issues)
[](https://github.com/paolo-rossi/delphi-neon/pulls)
[](https://github.com/paolo-rossi/delphi-neon/blob/master/LICENSE)
**Neon** is a serialization library for [Delphi](https://www.embarcadero.com/products/delphi) that helps you to convert (back and forth) objects and other values to JSON. It supports simple Delphi types but also complex class and records. **Neon** has been designed with **REST** in mind, to exchange pure data between applications with no *"metadata"* or added fields, in fact **Neon** is the default JSON serialization engine for the [WiRL REST Library](https://github.com/delphi-blocks/WiRL).
Please take a look at the Demos to see **Neon** in action.
### Neon Main Demo
This is the main demo where you can see how you can serialize/deserialize simple types, records, classes, Delphi specific types (TStringList, TDataSet, etc...):
### Neon Benchmarks Demo
This new demo tries to compare the standard TJSON serialization engine with the TNeon engine, with a few changes you can compare TNeon with other serialization engines out there:
### A Neon Introduction by Holger Flick (Video)
[](https://www.youtube.com/watch?v=djzfeS9k4KU)
## General Features
### Configuration
Extensive configuration through `INeonConfiguration` interface:
- Word case (Unchanged, UPPERCASE, lowercase, PascalCase, camelCase, snake_case)
- CuStOM CAse (through anonymous method)
- Member types (Fields, Properties)
- Option to ignore the "F" if you choose to serialize the fields
- Member visibility (private, protected, public, published)
- Custom serializer registration
- Use UTC date in serialization
- Auto creation of nil (object) members
### Delphi Types Support
Neon supports the (de)serialization of most Delphi standard types, records, array and of course classes. Classes can be complex as you want them to be, can contain array, (generic) lists, sub-classes, record, etc...
#### Simple values
- Basic types: **string, Integer, Double, Boolean, TDateTime**
#### Complex values
- **Dynamic Arrays** of (basic types, records, classes, etc...)
- **Records** with fields of (basic types, records, classes, arrays, etc...)
- **Classes** with fields of (basic types, records, classes, arrays, etc...)
- **Generic lists**
- **Dictionaries** (key must be of type string)
- **Streamable classes**
#### Custom Serializers
- Inherit from `TCustomSerializer` and register the new serializer class in the configuration
## Todo
##### Code
- More Unit Tests
## Prerequisite
This library has been tested with **Delphi 12 Athens**, **Delphi 11 Alexandria**, **Delphi 10.4 Sydney**, **Delphi 10.3 Rio**, **Delphi 10.2 Tokyo**, but with a minimum amount of work it should compile with **Delphi XE7 and higher**
#### Libraries/Units dependencies
This library has no dependencies on external libraries/units.
Delphi units used:
- System.JSON (DXE6+)
- System.Rtti (D2010+)
- System.Generics.Collections (D2009+)
## Installation
Simply add the source path "Source" to your Delphi project path and.. you are good to go!
## Code Examples
### Serialize an object
#### Using TNeon utility class
The easiest way to serialize and deserialize is to use the `TNeon` utility class:
Object serialization:
```delphi
var
LJSON: TJSONValue;
begin
LJSON := TNeon.ObjectToJSON(AObject);
try
Memo1.Lines.Text := TNeon.Print(LJSON, True);
finally
LJSON.Free;
end;
end;
```
Object deserialization:
```delphi
var
LJSON: TJSONValue;
begin
LJSON := TJSONObject.ParseJSONValue(Memo1.Lines.Text);
try
TNeon.JSONToObject(AObject, LJSON, AConfig);
finally
LJSON.Free;
end;
```
#### Using TNeonSerializer and TNeonDeserializer classes
Using the `TNeonSerializerJSON` and `TNeonDeserializerJSON` classes you have more control over the process.
Object serialization:
```delphi
var
LJSON: TJSONValue;
LWriter: TNeonSerializerJSON;
begin
LWriter := TNeonSerializerJSON.Create(AConfig);
try
LJSON := LWriter.ObjectToJSON(AObject);
try
Memo1.Lines.Text := TNeon.Print(LJSON, True);
MemoError.Lines.AddStrings(LWriter.Errors);
finally
LJSON.Free;
end;
finally
LWriter.Free;
end;
end;
```
Object deserialization:
```delphi
var
LJSON: TJSONValue;
LReader: TNeonDeserializerJSON;
begin
LJSON := TJSONObject.ParseJSONValue(Memo1.Lines.Text);
if not Assigned(LJSON) then
raise Exception.Create('Error parsing JSON string');
try
LReader := TNeonDeserializerJSON.Create(AConfig);
try
LReader.JSONToObject(AObject, LJSON);
MemoError.Lines.AddStrings(LWriter.Errors);
finally
LReader.Free;
end;
finally
LJSON.Free;
end;
```
#### Neon configuration
It's very easy to configure **Neon**,
```delphi
var
LConfig: INeonConfiguration;
begin
LConfig := TNeonConfiguration.Default
.SetMemberCase(TNeonCase.SnakeCase) // Case settings
.SetMembers(TNeonMembers.Properties) // Member type settings
.SetIgnoreFieldPrefix(True) // F Prefix settings
.SetVisibility([mvPublic, mvPublished]) // Visibility settings
// Custom serializer registration
.GetSerializers.RegisterSerializer(TGUIDSerializer)
;
end;
```
Paolo Rossi