如何快速保存/加载类实例到文件

Question

我的应用程序中有几个类/结构的集合。

类只是一个带有字段的类

class A
{
  public int somevalue;
  public string someothervalue
}

还有我的收藏

List<A> _myList;

我需要能够保存并加载 _myList。我只想将所有类字段保存到文件并加载。我不想花时间编写自己的保存/加载。 .NET 中是否有任何工具可以帮助我。我不关心文件格式。

Answer 1

Answer 2

XMLSerializer 并不难使用。 只要你的对象不是很大，它就相当快。 我在一些应用程序中序列化了一些巨大的对象。 这需要很长时间，生成的文件几乎有 100 兆，但如果我需要调整一些东西，它们是可编辑的。 另外，如果我向对象添加字段并不重要。 旧版本对象的序列化文件仍然可以正确反序列化。我在单独的线程上进行序列化，因此在我的情况下花费多长时间并不重要。 需要注意的是，您的

A

类必须有一个构造函数才能使 XMLSerialziation 工作。

这是我用来序列化/反序列化的一些工作代码，为了便于阅读，删除了错误处理...

private List<A> Load()
{
    string file = "filepath";
    List<A> listofa = new List<A>();
    XmlSerializer formatter = new XmlSerializer(A.GetType());
    FileStream aFile = new FileStream(file, FileMode.Open);
    byte[] buffer = new byte[aFile.Length];
    aFile.Read(buffer, 0, (int)aFile.Length);
    MemoryStream stream = new MemoryStream(buffer);
    return (List<A>)formatter.Deserialize(stream);
}


private void Save(List<A> listofa)
{
    string path = "filepath";
    FileStream outFile = File.Create(path);
    XmlSerializer formatter = new XmlSerializer(A.GetType());
    formatter.Serialize(outFile, listofa);
}

Answer 3

旧主题，但我修改了 Tim Coker 上面的答案，以利用 using 块正确处理流对象并一次仅保存一个类实例：

public static T Load<T>(string FileSpec) {
    XmlSerializer formatter = new XmlSerializer(typeof(T));

    using (FileStream aFile = new FileStream(FileSpec, FileMode.Open)) {
        byte[] buffer = new byte[aFile.Length];
        aFile.Read(buffer, 0, (int)aFile.Length);

        using (MemoryStream stream = new MemoryStream(buffer)) {
            return (T)formatter.Deserialize(stream);
        }
    }
}

public static void Save<T>(T ToSerialize, string FileSpec) {
    Directory.CreateDirectory(FileSpec.Substring(0, FileSpec.LastIndexOf('\\')));
    FileStream outFile = File.Create(FileSpec);
    XmlSerializer formatter = new XmlSerializer(typeof(T));

    formatter.Serialize(outFile, ToSerialize);
}

Answer 4

有很多序列化器：

.net 框架的一部分

• XmlSerializer（标准化格式，缓慢且冗长）
• BinarySerializer（专有格式，中速，支持循环图，序列化字段而不是属性=>烦人的版本控制）

第三者：

• Json-Serializers（标准化格式，基于文本，比 xml 短）
• ProtoBuf-Serializers（标准化格式，二进制，非常快）

如果文件可能是二进制的，我可能会使用 ProtoBuf 序列化器，如果需要是纯文本，我可能会使用 json 序列化器。

Answer 5

您可以使用 XML 序列化程序或二进制序列化程序序列化您的

List<>

并将序列化列表保存到文件中。

稍后，您可以读取此文件内容并检索您的原始列表。

创建要为其创建列表的类型

[Serializable]

Answer 6

我通常使用 XML Serilizer，速度快，易于实现，并以易于阅读的方式保持对象，你可以看到一个很好的示例。

如果您想要一个更有效的混淆解决方案，您可以使用二进制序列化。 （例如，如果您想通过网络传输序列化。）

编辑：要更好地控制序列化的元素，请查看此示例

Answer 7

我们可以通过以下方式之一保存和加载文件中的对象。

二进制序列化、Xml序列化、Json序列化

public enum Serialization
{
    BinarySerialization = 1,
    XmlSerialization = 2,
    JsonSerialization = 3,
}
public static void SaveObjectToFile<T>(Serialization serialization, string filePath ,T objectToSave)
{
    Directory.CreateDirectory(filePath.Substring(0, filePath.LastIndexOf('\\')));
     using (StreamWriter writer = new StreamWriter(filePath))
    {
        switch (serialization)
        {
            case Serialization.XmlSerialization: //Object type must have a parameterless constructor
                XmlSerializer formatter = new XmlSerializer(typeof(T));
                //Use the [XmlIgnore] attribute to exclude a public property or variable from being written to the file.(in XML Serialization only)
                formatter.Serialize(writer, objectToSave);
                break;
            case Serialization.JsonSerialization: //Object type must have a parameterless constructor
                var contentsToWriteToFile = Newtonsoft.Json.JsonConvert.SerializeObject(objectToSave);
                //[JsonIgnore] attribute to exclude a public property or variable from being written to the file.
                writer.Write(contentsToWriteToFile);
                break;
            case Serialization.BinarySerialization: 
                var binaryFormatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                //decorate class (and all classes that it contains) with a [Serializable] attribute.Use the [NonSerialized] attribute to exclude a variable from being written to the file;
                binaryFormatter.Serialize(writer.BaseStream, objectToSave);
                break;
        }
    }
}
public static T LoadObjectToFile<T>(Serialization serialization, string filePath)
{
    using (StreamReader reader = new StreamReader(filePath))
    {
        switch (serialization)
        {
            case Serialization.XmlSerialization:
                XmlSerializer formatter = new XmlSerializer(typeof(T));
                return (T)formatter.Deserialize(reader);
            case Serialization.JsonSerialization:
                var fileContents = reader.ReadToEnd();
                return Newtonsoft.Json.JsonConvert.DeserializeObject<T>(fileContents);
            case Serialization.BinarySerialization:
                var binaryFormatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                return (T)binaryFormatter.Deserialize(reader.BaseStream);
            default:
                 throw new System.ArgumentOutOfRangeException("Serialization = "+Convert.ToString(serialization));
        }
    }
}