响应按键而生成随机立方体。

使用通用类型和虚拟方法。

将数据写入文件并回读。

保存游戏状态，以便以后加载。

封装持久数据的详细信息。

var writer = new BinaryWriter(File.Open(savePath, FileMode.Create);try { … }finally {  if (writer != null) {    ((IDisposable)writer).Dispose();  }}

写数据

我们可以通过调用writer的Write方法将数据写入文件。可以一次写入一个简单的值，例如布尔值，整数等。首先，我们只写实例化了多少个对象。

  void Save () {    using (      var writer = new BinaryWriter(File.Open(savePath, FileMode.Create))    ) {      writer.Write(objects.Count);    }  }

要实际保存此数据，我们必须调用该Save方法。我们将再次通过一个键来控制它，在这种情况下，使用S作为默认值。

  public KeyCode createKey = KeyCode.C;  public KeyCode saveKey = KeyCode.S;
  …
  void Update () {    if (Input.GetKeyDown(createKey)) {      CreateObject();    }    else if (Input.GetKey(newGameKey)) {      BeginNewGame();    }    else if (Input.GetKeyDown(saveKey)) {      Save();    }  }

进入游戏模式，创建几个立方体，然后按键保存游戏。这将在文件系统上创建一个saveFile文件。如果不确定Debug.Log文件的位置，可以使用将该文件的路径写入Unity控制台。

您会发现该文件包含四个字节的数据。在文本编辑器中打开文件不会显示任何有用的信息，因为数据是二进制的。它可能什么也没有显示，或者可能会将数据解释为怪异的字符。有四个字节，因为这是整数的大小。

除了编写多少个多维数据集外，我们还必须存储每个多维数据集的转换数据。我们通过遍历对象并写入它们的数据来做到这一点，一次写入一个数字。现在，我们将只限于他们的职位。因此，请按此顺序写入每个多维数据集位置的X，Y和Z分量。

      writer.Write(objects.Count);      for (int i = 0; i < objects.Count; i++) {        Transform t = objects[i];        writer.Write(t.localPosition.x);        writer.Write(t.localPosition.y);        writer.Write(t.localPosition.z);      }

包含七个位置的文件，以四字节块为单位。

为什么不使用BinaryFormatter？

尽管依赖BinaryFormatter可以很方便，但是不可能仅使用序列化游戏对象层次结构BinaryFormatter并在以后反序列化它。游戏对象层次结构必须手动重新创建。同样，我们自己编写每一个数据可以使我们完全控制和理解。除此之外，手动写入数据需要较少的空间和内存，速度更快，并且可以更轻松地支持不断发展的保存文件格式。有时，已经发布的游戏在更新或扩展后会大大改变存储的内容。这样，其中一些游戏将无法再加载玩家的旧保存文件。理想情况下，游戏与其所有保存文件版本都向后兼容。

加载数据中

要加载刚刚保存的数据，我们必须再次打开文件，这一次FileMode.Open是第二个参数。代替 BinaryWriter，我们必须使用 BinaryReader。使用新Load方法再次执行此操作，并再次using声明。

void Load () {    using (      var reader = new BinaryReader(File.Open(savePath, FileMode.Open))    ) {}  }

我们写入文件的第一件事是列表的count属性，因此这也是要阅读的第一件事。我们用读reder的方法ReadInt32来做到这一点。我们必须明确所读内容，因为没有参数可以明确说明这一点。后缀32表示整数的大小，即四个字节，即32位。也有越来越大的整数变体，但我们不使用它们。

    using (      var reader = new BinaryReader(File.Open(savePath, FileMode.Open))    ) {      int count = reader.ReadInt32();    }

读取计数后，我们知道保存了多少个对象。我们必须从文件中读取很多位置。循环执行此操作，每次迭代读取三个浮点数，以获取位置向量的X，Y和Z分量。该ReadSingle方法读取单精度float。该ReadDouble方法将读取双精度double。

      int count = reader.ReadInt32();      for (int i = 0; i < count; i++) {        Vector3 p;        p.x = reader.ReadSingle();        p.y = reader.ReadSingle();        p.z = reader.ReadSingle();      }

使用向量设置新实例化的多维数据集的位置，并将其添加到列表中。

      for (int i = 0; i < count; i++) {        Vector3 p;        p.x = reader.ReadSingle();        p.y = reader.ReadSingle();        p.z = reader.ReadSingle();        Transform t = Instantiate(prefab);        t.localPosition = p;        objects.Add(t);      }

此时，我们可以重新创建保存的所有多维数据集，但是它们会添加到场景中已经存在的多维数据集中。为了正确加载以前保存的游戏，我们必须在重新创建游戏之前将其重置。我们可以通过在加载数据之前调用BeginNewGame来实现。

  void Load () {    BeginNewGame();    using (      var reader = new BinaryReader(File.Open(savePath, FileMode.Open))    ) {      …    }  }

有Game调用Load时按下某个键，使用L-为默认值。

  public KeyCode createKey = KeyCode.C;  public KeyCode saveKey = KeyCode.S;  public KeyCode loadKey = KeyCode.L;
  …
  void Update () {    …    else if (Input.GetKeyDown(saveKey)) {      Save();    }    else if (Input.GetKeyDown(loadKey)) {      Load();    }  }

现在，玩家可以保存他们的多维数据集，然后在相同的播放会话或另一个播放会话中加载它们。但是因为我们只存储位置数据，所以不存储立方体的旋转和比例。结果，所有加载的多维数据集最终都具有预制件的默认旋转和比例。

如果在保存任何内容之前加载，会发生什么？

然后，您将尝试打开一个不存在的文件，这将导致异常。本教程不会检查文件是否存在或是否包含有效数据，但是在以后的教程中我们会更加小心。

抽象存储

尽管我们需要了解读取和写入二进制数据的细节，但这还是很底层的。编写单个3D向量需要调用的三个Write。保存和加载对象时，如果我们可以在更高的层次上进行工作，通过一次方法调用来读取或写入整个3D向量，则将更加方便。另外，如果我们仅使用ReadInt和ReadFloat，而不必担心我们不使用的所有不同变体，那将是很好的。最后，数据是以二进制，纯文本，base-64还是其他编码方法存储都没有关系。Game不需要知道这些细节。

游戏数据写和读

为了隐藏读取和写入数据的细节，我们将创建自己的读取器和写入器类。让我们从写开始，用GameDataWriter命名它。

GameDataWriter不会扩展MonoBehaviour，因为我们不会将其附加到游戏对象上。它将充当的包装器BinaryWriter，因此给它一个单一的writer字段。

using System.IO;using UnityEngine;
public class GameDataWriter {
  BinaryWriter writer;}

可以通过创建新的自定义作家类型的对象实例new GameDataWriter()。但这只有在我们要包装一位作家的情况下才有意义。因此，使用BinaryWriter参数创建自定义构造函数方法。这是一个使用其类的类型名称作为其自身名称的方法，该方法还用作其返回类型。它替换了隐式默认构造函数方法。

public GameDataWriter (BinaryWriter writer) {  }

尽管调用构造函数方法会产生一个新的对象实例，但此类方法不会显式返回任何内容。在调用构造函数之前先创建对象，然后该对象可以进行任何必需的初始化。在我们的例子中，这只是将writer参数分配给对象的字段。由于我对两者都使用了相同的名称，因此必须使用this关键字来明确表示我是在指对象的字段而不是参数。

  public GameDataWriter (BinaryWriter writer) {    this.writer = writer;  }

最基本的功能是编写一个float或一个int值。Write为此添加公共方法，只需将调用转发给实际的编写器即可。

public void Write (float value) {    writer.Write(value);  }
  public void Write (int value) {    writer.Write(value);  }

除此之外，还添加一些方法来写一个Quaternion-用于旋转-和一个Vector3。这些方法必须编写其参数的所有组件。对于四元数，这是四个组成部分。

public void Write (Quaternion value) {    writer.Write(value.x);    writer.Write(value.y);    writer.Write(value.z);    writer.Write(value.w);  }    public void Write (Vector3 value) {    writer.Write(value.x);    writer.Write(value.y);    writer.Write(value.z);  }

接下来，GameDataReader使用与编写者相同的方法创建一个新类。在这种情况下，我们包装一个BinaryReader。

using System.IO;using UnityEngine;
public class GameDataReader {
  BinaryReader reader;
  public GameDataReader (BinaryReader reader) {    this.reader = reader;  }}

给它简单地命名为ReadFloat和ReadInt方法，这些方法将调用转发给ReadSingle和 ReadInt32。

public float ReadFloat () {    return reader.ReadSingle();  }
  public int ReadInt () {    return reader.ReadInt32();  }

还创建ReadQuaternion和ReadVector3方法。以与编写它们相同的顺序阅读它们的组件。

public Quaternion ReadQuaternion () {    Quaternion value;    value.x = reader.ReadSingle();    value.y = reader.ReadSingle();    value.z = reader.ReadSingle();    value.w = reader.ReadSingle();    return value;  }
  public Vector3 ReadVector3 () {    Vector3 value;    value.x = reader.ReadSingle();    value.y = reader.ReadSingle();    value.z = reader.ReadSingle();    return value;  }

持久对象

现在，在中写入多维数据集的转换数据要简单得多Game。但是，我们可以走得更远。如果Game可以简单地调用该writer.Write(objects[i])怎么办？那将是非常方便的，但是将需要GameDataWriter知道编写游戏对象的细节。但是最好使编写者保持简单，将其限制为原始值和简单结构。

我们可以扭转这种推理。Game不需要知道如何保存游戏对象，这是对象本身的责任。对象所需的全部就是编写者来保存自己。然后Game可以使用   objects[i].Save(writer)。

我们的多维数据集是简单的对象，没有附加任何自定义组件。因此，唯一要保存的是变换组件。让我们创建一个PersistableObject组件脚本，该脚本知道如何保存和加载该数据。它只是简单地扩展，MonoBehaviour并具有一个公共Save方法和Load一个带有GameDataWriter或GameDataReader参数的方法。让它保存变换位置，旋转和缩放，并以相同顺序加载它们。

using UnityEngine;
public class PersistableObject : MonoBehaviour {
  public void Save (GameDataWriter writer) {    writer.Write(transform.localPosition);    writer.Write(transform.localRotation);    writer.Write(transform.localScale);  }
  public void Load (GameDataReader reader) {    transform.localPosition = reader.ReadVector3();    transform.localRotation = reader.ReadQuaternion();    transform.localScale = reader.ReadVector3();  }}

这个想法是，一个只能持久保存的游戏对象只附加了一个组件PersistableObject。具有多个这样的组件是没有意义的。我们可以通过将DisallowMultipleComponent属性添加到类中来强制执行此操作。

[DisallowMultipleComponent]public class PersistableObject : MonoBehaviour {
  …}

将此组件添加到我们的立方体预制件中。

永久储存

现在我们有了持久的对象类型，让我们也创建一个PersistentStorage类来保存这样的对象。它包含与保存和加载逻辑相同的逻辑Game，只是它仅保存和加载一个PersistableObject实例，并通过参数提供给public Save和Loadmethod。将其设置为MonoBehaviour，这样我们就可以将其附加到游戏对象上，并且可以初始化其保存路径。

using System.IO;using UnityEngine;
public class PersistentStorage : MonoBehaviour {
  string savePath;
  void Awake () {    savePath = Path.Combine(Application.persistentDataPath, "saveFile");  }
  public void Save (PersistableObject o) {    using (      var writer = new BinaryWriter(File.Open(savePath, FileMode.Create))    ) {      o.Save(new GameDataWriter(writer));    }  }
  public void Load (PersistableObject o) {    using (      var reader = new BinaryReader(File.Open(savePath, FileMode.Open))    ) {      o.Load(new GameDataReader(reader));    }  }}

附加此组件的场景中添加一个新的游戏对象。它代表了我们游戏的持久存储。从理论上讲，我们可以有多个这样的存储对象，用于存储不同的事物或提供对不同存储类型的访问。但是在本教程中，我们仅使用此单个文件存储对象。

持久游戏

要使用新的可持久对象方法，我们必须重写Game。将prefab和objects内容类型更改为PersistableObject。进行调整CreateObject，使其可以处理此类型更改。然后删除所有特定于读取和写入文件的代码。

using System.Collections.Generic;//using System.IO;using UnityEngine;
public class Game : MonoBehaviour {
  publicPersistableObjectprefab;
  …
  List<PersistableObject> objects;
//  string savePath;
  void Awake () {    objects = new List<PersistableObject>();//    savePath = Path.Combine(Application.persistentDataPath, "saveFile");  }
  void Update () {    …    else if (Input.GetKeyDown(saveKey)) {//      Save();    }    else if (Input.GetKeyDown(loadKey)) {//      Load();    }  }    …
  void CreateObject () {    PersistableObject o = Instantiate(prefab);    Transform t =o.transform;    …    objects.Add(o);  }
//  void Save () {//    …//  }
//  void Load () {//    …//  }}

我们将Game依靠PersistentStorage实例来处理存储数据的细节。添加storage此类型的公共字段，以便我们Game可以引用我们的存储对象。为了再次保存和加载游戏状态，我们将Game其扩展为PersistableObject。然后，它可以使用存储加载并保存自身。

public class Game :PersistableObject{
  …
  public PersistentStorage storage;
  …
  void Update () {    if (Input.GetKeyDown(createKey)) {      CreateObject();    }    else if (Input.GetKeyDown(saveKey)) {      storage.Save(this);    }    else if (Input.GetKeyDown(loadKey)) {      BeginNewGame();      storage.Load(this);    }  }
  …}

通过检查器连接存储。还要重新连接预制件，因为由于字段的类型更改而导致其参考丢失。

覆盖方法

现在，当我们保存和加载游戏时，最终将写入和读取主要游戏对象的转换数据。这没用。相反，我们必须保存并加载其对象列表。

我在保存之前加载了游戏对象，而游戏对象的位置又变了呢？

如果此时要加载较旧的保存文件，则最终会误解数据。计数整数将被误认为X位置，第一个保存的位置的X和Y最终将被用作Y和Z位置，然后旋转将被下一个值填充，依此类推。如果保存的位置少于四个，则该文件包含的数据太少，无法加载完整的转换。然后，您会收到一个错误消息，抱怨您试图读取文件末尾之外的内容。

而不是依赖于中Save定义的方法PersistableObject，我们必须提供Game其自己的Save带有GameDataWriter参数的公共版本。在其中，使用Save对象的便捷方法像以前一样编写列表。

public void Save (GameDataWriter writer) {    writer.Write(objects.Count);    for (int i = 0; i < objects.Count; i++) {      objects[i].Save(writer);    }  }

这还不足以使其正常工作。编译器抱怨Game.Save隐藏了继承的成员PersistableObject.Save。虽然Game可以使用自己的Save版本，但PersistentStorage仅了解PersistableObject.Save。因此它将调用此方法，而不是中的方法Game。为了确保Save调用正确的方法，我们必须显式声明要重写Game从PersistableObject继承的方法。这是通过将override关键字添加到方法声明中来完成的。

  public override void Save (GameDataWriter writer) {    …  }

但是，我们不能仅仅覆盖我们喜欢的任何方法。默认情况下，我们不允许这样做。我们必须通过将virtual关键字添加到PersistableObject中的Save和Load方法声明中来显式启用它。

  public virtual void Save (GameDataWriter writer) {    writer.Write(transform.localPosition);    writer.Write(transform.localRotation);    writer.Write(transform.localScale);  }
  public virtual void Load (GameDataReader reader) {    transform.localPosition = reader.ReadVector3();    transform.localRotation = reader.ReadQuaternion();    transform.localScale = reader.ReadVector3();  }

什么是virtual关键字？

在非常低的级别上，实际上没有对象或方法。仅存在数据，其中一部分被用作要由CPU执行的指令。除非经过优化，否则方法调用会成为告诉CPU跳转到另一个数据点并从那里继续执行的指令。除此之外，它还可能放置一些参数值。因此，当PersistentStorage调用该PersistableObject类型的Save方法时，它成为跳转到固定位置的指令。我们传递给它的实例是的Game子类型，PersistableObject根本不影响它。用于调用该方法的对象实例只是另一个参数。

该virtual关键字改变这种做法。编译器不使用硬编码的位置，而是根据所涉及的类型添加指令以查找跳转到的位置。而不是去“使用这种方法，所以总是跳到那里。” 变为“此类型是否包含此方法的跳转目标？如果是，请转到那里。如果否，请检查其直接父类型。重复此操作，直到找到目标为止。” 这种方法称为虚拟方法，函数或调用表。因此virtual。它允许子类型覆盖其父类型的功能。

请注意，最终由CPU执行的低级指令的细节可能会有很大不同，尤其是在使用Unity的IL2CPP创建本机可执行文件时。IL2CPP尽可能避免使用虚拟方法表。

PersistentStorage现在将最终调用我们的Game.Save方法，即使该方法已作为PersistableObject参数传递给它。也有Game重写Load方法。

public override void Load (GameDataReader reader) {    int count = reader.ReadInt();    for (int i = 0; i < count; i++) {      PersistableObject o = Instantiate(prefab);      o.Load(reader);      objects.Add(o);    }  }

下一个教程是各色对象。

资源库（Repository）

https://bitbucket.org/catlikecodingunitytutorials/object-management-01-persisting-objects

往期精选

Unity3D游戏开发中100+效果的实现和源码大全 - 收藏起来肯定用得着

S‍‍‍‍hader学习应该如何切入？

喵的Unity游戏开发之路 - 从入门到精通的学习线路和全教程‍‍‍‍

声明：发布此文是出于传递更多知识以供交流学习之目的。若有来源标注错误或侵犯了您的合法权益，请作者持权属证明与我们联系，我们将及时更正、删除，谢谢。

原作者：Jasper Flick

原文：

https://catlikecoding.com/unity/tutorials/object-management/persisting-objects/

翻译、编辑、整理：MarsZhou

More：【微信公众号】 u3dnotes