Question

I have a class. I wanna serialize and the serialize a list that contains object of that class. I want to use binary formatter.
This is my class:

[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);


    }


}

I don’t have any problem in serialization. But for deserialize, it can just deserialize first object not all of them. What should I do, please help me!

Answer 1

From a separate email from the OP, the following methods were obtained (I’ve tidied them a little, not much):

    static void Serialize(object obj, string filename)
    {
        using (FileStream streamOut = new FileStream(filename, FileMode.Append))
        {
            BinaryFormatter formatter = new BinaryFormatter();
            formatter.Serialize(streamOut, obj);
        }
    }


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

The key observation here is that it is assuming that BinaryFormatter is an appendable format, and that serializing two objects sequentially is the same as serializing 2 items at the same time (a list), for example:

    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");

However, that simply is not the case. To deserialize the items in this way, we would have to do something like:

    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;
        }
    }

which it a little vexing – not least because it can’t be applied to all streams (.Length and even .Position are not universally available).

The above should work, but I would strongly advise using an appendable format, such as protobuf. In fact, protobuf-net makes this scenario effortless, both in terms of the model:

    [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; }
    }

and the serialization / deserialization:

    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();
        }
    }

Finally, the BinaryFormatter data for those 2 rows was 750 bytes; with protobuf-net: 40 bytes.