JSON serialization and deserialization state in dart

Currently the best option is probably using the Smoke library .

This is a subset of the Mirrors functionality, but has both a mirror-based implementation and Codegen. This is written by the PolymerDart team, so this is close to "Official" as we're going to get it.

It will use Mirrors-based encoding / decoding during development; but for posting, you can create a small transformer that will generate the code.

Seth Ladd created some sample code here that I extended a bit to support child objects:

abstract class Serializable {
  static fromJson(Type t, Map json) {
    var typeMirror = reflectType(t);
    T obj = typeMirror.newInstance(new Symbol(""), const[]).reflectee;
    json.forEach((k, v) {
      if (v is Map) {
        var d = smoke.getDeclaration(t, smoke.nameToSymbol(k));
        smoke.write(obj, smoke.nameToSymbol(k), Serializable.fromJson(d.type, v));
      } else {
        smoke.write(obj, smoke.nameToSymbol(k), v);
      }
    });
    return obj;
  }

  Map toJson() {
    var options = new smoke.QueryOptions(includeProperties: false);
    var res = smoke.query(runtimeType, options);
    var map = {};
    res.forEach((r) => map[smoke.symbolToName(r.name)] = smoke.read(this, r.name));
    return map;
  }
}

      

        
        
        
      

    

There is currently no support for getting type type information (for example, to maintain a list) in Smoke; however I have covered it here:

https://code.google.com/p/dart/issues/detail?id=20584

Until this problem is implemented, a "good" implementation of what you want is not really possible; but I hope this will be implemented soon; because doing something basic like JSON serialization depends on it!

Alan Knight is also working on the Serialization package, however I found it lacked support as easy as converting datetimes to strings, and the solution seemed pretty verbose for something so basic.

Now, in my own project, I went with coding our json serialization (in the form of the toMap and fromMap methods), since we would already have the C # versions of our classes for the server side. Time permitting, I'd like to strip that code and make a NuGet package (it supports nested objects, arrays, excluding properties, etc.).

Typically, the move from mirrored solutions to codec solutions relies specifically on the source_gen package. This is because codegen can provide less and faster execution times than mirrors.

One package that codegen uses for serialization is built_value:

https://github.com/google/built_value.dart

With built_value, your model classes look like this:

abstract class Account implements Built<Account, AccountBuilder> {
  static Serializer<Account> get serializer => _$accountSerializer;

  int get id;
  String get name;
  BuiltMap<String, JsonObject> get keyValues;

  factory Account([updates(AccountBuilder b)]) = _$Account;
  Account._();
}

      

        
        
        
      

    

Note that built_value isn't just about serialization - it also provides an == operator, hashCode, toString, and a builder class.

I am currently serializing with exportable and deserializing with morph .

Dart has an implementation for encoding and decoding maps, lists and primitive types. You can find examples at this article . If you are looking for speed this is probably the fastest as they implement json conversion in native C / C ++ - libraries created by the authors are usually written in Dart and will be slower.

The disadvantage JSON.encode

, and JSON.decode

is something that they can not take any other objects, other than those mentioned above, without the methods and toJson fromJson.

Fortunately, there are libraries out there that use reflection in Dart to make it easier. I have created a small library myself to serialize and deserialize objects to and from JSON without additional code for your classes. You can find it here . In addition to the above solutions for your problem, many of them can be found on the Dart pub website .