JsonUtility是5.3新增的用于序列化及反序列化的工具
用法为

using System;
using System.Collections.Generic;

[Serializable]
public class Enemy
{
    [SerializeField]
    string name;
    [SerializeField]
    List<string> skills;

    public Enemy(string name, List<string> skills)
    {
        this.name = name;
        this.skills = skills;
    }
}

var enemies = new List<Enemy>();
enemies.Add(new Enemy("スライム", new List<string>() { "攻撃" }));
enemies.Add(new Enemy("キングスライム", new List<string>() { "攻撃", "回復" }));
Debug.Log(JsonUtility.ToJson(enemies));

它能序列化类但是不能序列化泛型List及字典等

为了解决这个问题，可以把不可序列化的类型以可序列化的类型进行存储并保存到类中

例如我们不可以直接序列化list<T>,但可以序列化存在list<T>类型的类

我们不可以直接序列化字典,但可以将其分成存在两个list<T>类型的类

需要在类中声明保存的类型对象，并使其继承自ISerializationCallbackReceiver

然后实现OnBeforeSerialize()序列化前调用，在其中将不可序列化类型拆分为可序列化类型

和OnAfterDeserialize()反序列化后调用，将反序列化后的数据组合成原类型的数据

// Serialization.cs
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System;

// List<T>
[Serializable]
public class Serialization<T>
{
    [SerializeField]
    List<T> target;
    public List<T> ToList() { return target; }

    public Serialization(List<T> target)
    {
        this.target = target;
    }
}

// Dictionary<TKey, TValue>
[Serializable]
public class Serialization<TKey, TValue> : ISerializationCallbackReceiver
{
    [SerializeField]
    List<TKey> keys;
    [SerializeField]
    List<TValue> values;

    Dictionary<TKey, TValue> target;
    public Dictionary<TKey, TValue> ToDictionary() { return target; }

    public Serialization(Dictionary<TKey, TValue> target)
    {
        this.target = target;
    }

    public void OnBeforeSerialize()
    {
        keys = new List<TKey>(target.Keys);
        values = new List<TValue>(target.Values);
    }

    public void OnAfterDeserialize()
    {
        var count = Math.Min(keys.Count, values.Count);
        target = new Dictionary<TKey, TValue>(count);
        for (var i = 0; i < count; ++i)
        {
            target.Add(keys[i], values[i]);
        }
    }
}

用法

// List<T> -> Json文字列 ( 例 : List<Enemy> )
string str = JsonUtility.ToJson(new Serialization<Enemy>(enemies)); 
// Json文字列 -> List<T>
List<Enemy> enemies = JsonUtility.FromJson<Serialization<Enemy>>(str).ToList();
// Dictionary<TKey,TValue> -> Json文字列 ( 例 : Dictionary<int, Enemy> )
string str = JsonUtility.ToJson(new Serialization<int, Enemy>(enemies)); 

顺便还写了BitArray。

// BitArray
[Serializable]
public class SerializationBitArray : ISerializationCallbackReceiver
{
    [SerializeField]
    string flags;

    BitArray target;
    public BitArray ToBitArray() { return target; }

    public SerializationBitArray(BitArray target)
    {
        this.target = target;
    }

    public void OnBeforeSerialize()
    {
        var ss = new System.Text.StringBuilder(target.Length);
        for(var i = 0 ; i < target.Length ; ++i)
        {
            ss.Insert(0, target[i]?'1':'0');
        }
        flags = ss.ToString();
    }

    public void OnAfterDeserialize()
    {
        target = new BitArray(flags.Length);
        for (var i = 0; i < flags.Length; ++i)
        {
            target.Set(flags.Length - i - 1, flags[i] == '1');
        }
    }
}

用法

BitArray bits = new BitArray(4);
bits.Set(1, true);
// BitArray -> Json文字列
var str = JsonUtility.ToJson(new SerializationBitArray(bits)); 
// Json文字列 -> BitArray
BitArray bits = JsonUtility.FromJson<SerializationBitArray>(s).ToBitArray();

原文链接：http://kou-yeung.hatenablog.com/entry/2015/12/31/014611