C# 在C中具有1000条记录的二进制文件格式#

我希望将数组模型对象序列化为二进制流。模型类将主要具有字符串和整数属性

我相信我可以将该类标记为[Serializable]并使用二进制格式化程序，但是我想知道您是否认为这是最好的方法，记住我的首要任务是在低带宽连接上传输尽可能小的文件（我也可以压缩/解压文件）

该文件可能有1000条记录，因此理想情况下，我希望能够附加到磁盘并逐个记录地从磁盘读取，而不必一次将整个文件存储在内存中

所以我的首要任务是：小文件大小和高效的内存使用

也许有一个预先编写的框架？使用XML和CSV文件似乎很容易！希望它也是一个自定义的二进制格式

谢谢

您可以使用。对于需要小文件的用户来说，这是一个很好的解决方案，但只有您知道这是否是您所在域的最佳解决方案。不过，我认为你不能一次读一张唱片

目前我仅有的示例代码是一个。这些扩展方法将（反）序列化自定义数据集，如果我没有记错的话，这是获得可以使用BinaryFormatter的类型的最简单方法

public static TDataSet LoadBinary<TDataSet>(Stream stream) where TDataSet : DataSet
{
    var formatter = new BinaryFormatter();
    return (TDataSet)formatter.Deserialize(stream);
}

public static void WriteBinary<TDataSet>(this TDataSet dataSet, Stream stream) where TDataSet : DataSet
{
    dataSet.RemotingFormat = SerializationFormat.Binary;
    var formatter = new BinaryFormatter();
    formatter.Serialize(stream, dataSet);
}

publicstatictdataset-LoadBinary（Stream-Stream），其中TDataSet:DataSet
{
var formatter=新的二进制格式化程序（）；
返回（TDataSet）格式化程序。反序列化（流）；
}
公共静态void WriteBinary（此TDataSet数据集，Stream），其中TDataSet:dataSet
{
dataSet.RemotingFormat=SerializationFormat.Binary；
var formatter=新的二进制格式化程序（）；
序列化（流、数据集）；
}

您还可以看看，这是.NET处理序列化的新“标准”方式（简而言之，根据C#4.0，Albahari&Albahari）。在这种情况下，您还需要阅读。下面是如何用XML和JSON（反）序列化的示例，尽管它们不直接适用于您的情况（因为您需要小文件）。但是你可以压缩文件

/// <summary>
/// Converts this instance to XML using the <see cref="DataContractSerializer"/>.
/// </summary>
/// <typeparam name="TSerializable">
/// A type that is serializable using the <see cref="DataContractSerializer"/>.
/// </typeparam>
/// <param name="value">
/// The object to be serialized to XML.
/// </param>
/// <returns>
/// Formatted XML representing this instance. Does not include the XML declaration.
/// </returns>
public static string ToXml<TSerializable>(this TSerializable value)
{
    var serializer = new DataContractSerializer(typeof(TSerializable));
    var output = new StringWriter();
    using (var writer = new XmlTextWriter(output) { Formatting = Formatting.Indented })
    {
        serializer.WriteObject(writer, value);
    }
    return output.GetStringBuilder().ToString();
}

/// <summary>
/// Converts this instance to XML using the <see cref="DataContractSerializer"/> and writes it to the specified file.
/// </summary>
/// <typeparam name="TSerializable">
/// A type that is serializable using the <see cref="DataContractSerializer"/>.
/// </typeparam>
/// <param name="value">
/// The object to be serialized to XML.
/// </param>
/// <param name="filePath">Path of the file to write to.</param>
public static void WriteXml<TSerializable>(this TSerializable value, string filePath)
{
    var serializer = new DataContractSerializer(typeof(TSerializable));
    using (var writer = XmlWriter.Create(filePath, new XmlWriterSettings { Indent = true }))
    {
        serializer.WriteObject(writer, value);
    }
}

/// <summary>
/// Creates from an instance of the specified class from XML.
/// </summary>
/// <typeparam name="TSerializable">The type of the serializable object.</typeparam>
/// <param name="xml">The XML representation of the instance.</param>
/// <returns>An instance created from the XML input.</returns>
public static TSerializable CreateFromXml<TSerializable>(string xml)
{
    var serializer = new DataContractSerializer(typeof(TSerializable));

    using (var stringReader = new StringReader(xml))
    using (var reader = XmlReader.Create(stringReader))
    {
        return (TSerializable)serializer.ReadObject(reader);
    }
}

/// <summary>
/// Creates from an instance of the specified class from the specified XML file.
/// </summary>
/// <param name="filePath">
/// Path to the XML file.
/// </param>
/// <typeparam name="TSerializable">
/// The type of the serializable object.
/// </typeparam>
/// <returns>
/// An instance created from the XML input.
/// </returns>
public static TSerializable CreateFromXmlFile<TSerializable>(string filePath)
{
    var serializer = new DataContractSerializer(typeof(TSerializable));

    using (var reader = XmlReader.Create(filePath))
    {
        return (TSerializable)serializer.ReadObject(reader);
    }
}

public static T LoadJson<T>(Stream stream) where T : class
{
    var serializer = new DataContractJsonSerializer(typeof(T));
    object readObject = serializer.ReadObject(stream);
    return (T)readObject;
}

public static void WriteJson<T>(this T value, Stream stream) where T : class
{
    var serializer = new DataContractJsonSerializer(typeof(T));
    serializer.WriteObject(stream, value);
}

//
///使用将此实例转换为XML。
/// 
/// 
///使用可序列化的类型。
/// 
/// 
///要序列化为XML的对象。
/// 
/// 
///表示此实例的格式化XML。不包括XML声明。
/// 
公共静态字符串ToXml（此TSerializable值）
{
var serializer=新的DataContractSerializer（typeof（TSerializable））；
var输出=新的StringWriter（）；
使用（var writer=newxmltextwriter（输出）{Formatting=Formatting.Indented}）
{
serializer.WriteObject（writer，value）；
}
返回output.GetStringBuilder（）.ToString（）；
}
/// 
///使用将此实例转换为XML，并将其写入指定文件。
/// 
/// 
///使用可序列化的类型。
/// 
/// 
///要序列化为XML的对象。
/// 
///要写入的文件的路径。
公共静态void WriteXml（此可变量值，字符串文件路径）
{
var serializer=新的DataContractSerializer（typeof（TSerializable））；
使用（var writer=XmlWriter.Create（文件路径，新的XmlWriterSettings{Indent=true}））
{
serializer.WriteObject（writer，value）；
}
}
/// 
///从XML中指定类的实例创建。
/// 
///可序列化对象的类型。
///实例的XML表示形式。
///从XML输入创建的实例。
公共静态可变量CreateFromXml（字符串xml）
{
var serializer=新的DataContractSerializer（typeof（TSerializable））；
使用（var stringReader=newstringreader（xml））
使用（var reader=XmlReader.Create（stringReader））
{
return（TSerializable）serializer.ReadObject（reader）；
}
}
/// 
///从指定XML文件中指定类的实例创建。
/// 
/// 
///XML文件的路径。
/// 
/// 
///可序列化对象的类型。
/// 
/// 
///从XML输入创建的实例。
/// 
公共静态TSerializable CreateFromXmlFile（字符串文件路径）
{
var serializer=新的DataContractSerializer（typeof（TSerializable））；
使用（var reader=XmlReader.Create（filePath））
{
return（TSerializable）serializer.ReadObject（reader）；
}
}
公共静态T LoadJson（流），其中T:class
{
var serializer=newdatacontractjsonserializer（typeof（T））；
object readObject=serializer.readObject（流）；
返回（T）readObject；
}
公共静态void WriteJson（这个T值，Stream），其中T:class
{
var serializer=newdatacontractjsonserializer（typeof（T））；
serializer.WriteObject（流、值）；
}

我建议这样做非常有效

话虽如此，这将无法处理序列化/反序列化集合中的单个对象。这部分你需要自己去实现

• 一种解决方案是：将对象作为单个文件存储在文件夹中。文件名将包含一个引用，以便根据名称找到所需的对象

• 另一种方法是有一个文件，但保留一个索引文件，该文件保存所有对象及其在文件中的位置的列表。这是非常复杂的，就像当你保存一个在文件中间的对象时，你必须移动所有其他的地址，也许B-树更有效。

---

我建议使用Sql Server Compact将您的对象存储为对象，而无需序列化，它非常轻量级且速度极快，我在服务器上的大量请求中都是在高负载下使用它的

我也不建议以二进制格式（序列化）存储数据，因为在更改要存储的对象时，这将是一件非常痛苦的事情。如果您必须查看存储的内容，这也会很痛苦，因为您必须对整个集合进行反序列化

至于发送，我更喜欢使用XML序列化