List 通过二进制格式化程序进行列表序列化和反序列化

我有课。我想序列化一个包含该类对象的列表。我想使用二进制格式化程序。 这是我的班级：

[Serializable]
public class Section :ISerializable
{
    private double ClearCover;
    private string SectionName;

    private double Diameter;

    public double Height;
    private double Width;

    private double InternalDiameter;
    private double ExternalDiameter;

    private double InternalHeight;
    private double ExternalHeight;
    private double InternalWidth;
    private double ExternalWidth;

    private double WebWidth;
    private double FlangeWidth;
    private double FlangeThickness;



    public double clearCover
    {
        get { return ClearCover; } 
        set { ClearCover = value; }
    }
    public string sectionName
    {
        get{return SectionName;} 
        set{SectionName=value;} 
    }

    public double diameter
    {
        get { return Diameter; } 
        set { Diameter = value; }
    }

    public double height
    {
        set { Height = value; }
        get { return Height; }
    }
    public double width
    {
        set { Width = value; }
        get { return Width; }
    }

    public double internalDiameter
    {
        set { InternalDiameter = value; } 
        get { return InternalDiameter; }
    }
    public double externalDiameter
    {
        set { ExternalDiameter = value; } 
        get { return ExternalDiameter; }
    }

    public double internalHeight
    {
        set { InternalHeight = value; }
        get { return InternalHeight; }
    }
    public double externalHeight
    {
        set { ExternalHeight = value; } 
        get { return ExternalHeight; }
    }
    public double internalWidth
    {
        set { InternalWidth = value; } 
        get { return InternalWidth; }
    }
    public double externalWidth
    {
        set { ExternalWidth = value; } 
        get { return ExternalWidth; }
    }

    public double flangeWidth
    {
        set { FlangeWidth = value; }
        get { return FlangeWidth; }
    }
    public double flangeThickness
    {
        set { FlangeThickness = value; }
        get { return FlangeThickness; }
    }
    public double webWidth
    {
        set { WebWidth = value; }
        get { return WebWidth; }
    }




    public Section() { }

    protected Section(SerializationInfo info, StreamingContext context)
    {
        sectionName = info.GetString("Section Name");
        clearCover = info.GetDouble("Clear Cover");

        diameter = info.GetDouble("Diameter");

        //internalDiameter = info.GetDouble("Internal Diameter");
        //externalDiameter = info.GetDouble("External Diameter");


        height = info.GetDouble("Height");
        width = info.GetDouble("Width");



        internalHeight = info.GetDouble("Internal Height");
        externalHeight = info.GetDouble("External Height");
        internalWidth = info.GetDouble("Internal Width");
        externalWidth = info.GetDouble("External Width");

        flangeWidth = info.GetDouble("Flange Width");
        flangeThickness = info.GetDouble("Flange Thickness");
        webWidth = info.GetDouble("Web Width");



    }

    public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
    {
        info.AddValue("Section Name", sectionName);
        info.AddValue("Clear Cover", clearCover);

        info.AddValue("Diameter",diameter);

        //info.AddValue("Internal Diameter", internalDiameter);
        //info.AddValue("External Diameter", externalDiameter);

        info.AddValue("Height",height);
        info.AddValue("Width",width);

        info.AddValue("Internal Height",internalHeight);
        info.AddValue("External Height",externalHeight);
        info.AddValue("Internal Width",internalWidth);
        info.AddValue("External Width",externalWidth);

        info.AddValue("Flange Width",flangeWidth);
        info.AddValue("Flange Thickness", flangeThickness);
        info.AddValue("Web Width", webWidth);


    }


}

---

我在序列化方面没有任何问题。但对于反序列化，它只能反序列化第一个对象，而不是所有对象。我该怎么办，请帮帮我

从OP的一封单独的电子邮件中，获得了以下方法（我整理了一点，没有太多）：

然而，事实并非如此。要以这种方式反序列化项，我们必须执行以下操作：

public static List<Section> DeserializeList(string filename)
{
    using (FileStream streamIn = File.OpenRead(filename))
    {
        List<Section> list = new List<Section>();
        BinaryFormatter formatter = new BinaryFormatter();
        while(streamIn.Position != streamIn.Length)
        {
            list.Add((Section) formatter.Deserialize(streamIn));
        }
        return list;
    }
}

以及序列化/反序列化：

static void Main()
{
    if (File.Exists("foo.bin")) File.Delete("foo.bin"); // start afresh

    Serialize(new Section { Diameter = 1.2, ClearCover = 3.4 }, "foo.bin");
    Serialize(new Section { Diameter = 5.6, ClearCover = 7.8 }, "foo.bin");

    var clone = DeserializeList("foo.bin");
}
static void Serialize(object obj, string filename)
{
    using (FileStream streamOut = new FileStream(filename, FileMode.Append))
    {
        Serializer.NonGeneric.SerializeWithLengthPrefix(
            streamOut, obj, PrefixStyle.Base128, Serializer.ListItemTag);
    }
}


public static List<Section> DeserializeList(string filename)
{
    using (FileStream streamIn = File.OpenRead(filename))
    {
        return Serializer.DeserializeItems<Section>(
            streamIn, PrefixStyle.Base128, Serializer.ListItemTag).ToList();
    }
}

static void Main（）
{
如果（File.Exists（“foo.bin”））File.Delete（“foo.bin”）；//重新开始
序列化（新节{Diameter=1.2，ClearCover=3.4}，“foo.bin”）；
序列化（新节{Diameter=5.6，ClearCover=7.8}，“foo.bin”）；
var clone=反序列化列表（“foo.bin”）；
}
静态void序列化（对象obj，字符串文件名）
{
使用（FileStream streamOut=newfilestream（filename，FileMode.Append））
{
Serializer.NonGeneric.SerializeWithLength前缀(
streamOut、obj、PrefixStyle.Base128、Serializer.ListItemTag）；
}
}
公共静态列表反序列化列表（字符串文件名）
{
使用（FileStream streamIn=File.OpenRead（文件名））
{
返回Serializer.DeserializeItems(
streamIn，PrefixStyle.Base128，Serializer.ListItemTag）.ToList（）；
}
}

---

最后，这两行的

BinaryFormatter

数据为750字节；protobuf net:40字节。

对于第一部分（使用二进制格式化程序），它给出了以下错误：无法将“System.Collections.Generic.List`1[KSU.Section]”类型的对象强制转换为“KSU.Section”。这没有道理。根据您编写的代码，它不会将任何内容强制转换为节类型objectI测试一个包含9975行*4列的简单列表的最终格式，它为序列化和反序列化提供了很长的时间，并且文件大小约为10GB（OMG）@SharifLotfi大小通常是序列化数据的真实反映；如果您不认为10GB是正确的，我非常乐意在更多方面了解您的方案detail@MarcGravell谢谢，我确实在我的代码中检查了一下&我发现了一个很大的错误，我在serialize函数中编写了list，

serialize（list，filename）

而不是

serialize（new obj，filename）

，这是我的错误，很抱歉，现在我的文件大小是2MB，但是序列化程序需要很长时间（大约01:15分钟），反序列化速度非常快，这是我的类obj:

[ProtoContract]公共类obj{[ProtoMember（1）]公共字符串s1{get；set；}[ProtoMember（2）]公共字符串s2{get；set；}[ProtoMember（3）]公共字符串s3{get；set；}[ProtoMember（3）]（4） [public double d1{get；set；}}

@Sharif我很乐意尝试并提供帮助，但要调查性能问题，我真的需要能够在本地重新编译它；那里真的没有足够的数据让我这么做。你有虚拟的（或真实的，如果不是PII的话）数据/代码我可以重新编译吗？可能还值得给我发电子邮件。

public static List<Section> DeserializeList(string filename)
{
    using (FileStream streamIn = File.OpenRead(filename))
    {
        List<Section> list = new List<Section>();
        BinaryFormatter formatter = new BinaryFormatter();
        while(streamIn.Position != streamIn.Length)
        {
            list.Add((Section) formatter.Deserialize(streamIn));
        }
        return list;
    }
}

[ProtoContract]
public class Section
{
    [ProtoMember(1)] public double ClearCover { get; set; }
    [ProtoMember(2)] public string SectionName { get; set; }
    [ProtoMember(3)] public double Diameter { get; set; }
    [ProtoMember(4)] public double Height { get; set; }
    [ProtoMember(5)] public double Width { get; set; }
    [ProtoMember(6)] public double InternalDiameter { get; set; }
    [ProtoMember(7)] public double ExternalDiameter { get; set; }
    [ProtoMember(8)] public double InternalHeight { get; set; }
    [ProtoMember(9)] public double ExternalHeight { get; set; }
    [ProtoMember(10)] public double InternalWidth { get; set; }
    [ProtoMember(11)] public double ExternalWidth { get; set; }
    [ProtoMember(12)] public double FlangeWidth { get; set; }
    [ProtoMember(13)] public double FlangeThickness { get; set; }
    [ProtoMember(14)] public double WebWidth { get; set; }
}

static void Main()
{
    if (File.Exists("foo.bin")) File.Delete("foo.bin"); // start afresh

    Serialize(new Section { Diameter = 1.2, ClearCover = 3.4 }, "foo.bin");
    Serialize(new Section { Diameter = 5.6, ClearCover = 7.8 }, "foo.bin");

    var clone = DeserializeList("foo.bin");
}
static void Serialize(object obj, string filename)
{
    using (FileStream streamOut = new FileStream(filename, FileMode.Append))
    {
        Serializer.NonGeneric.SerializeWithLengthPrefix(
            streamOut, obj, PrefixStyle.Base128, Serializer.ListItemTag);
    }
}


public static List<Section> DeserializeList(string filename)
{
    using (FileStream streamIn = File.OpenRead(filename))
    {
        return Serializer.DeserializeItems<Section>(
            streamIn, PrefixStyle.Base128, Serializer.ListItemTag).ToList();
    }
}