C# 结构体数组如何保存到文件并从文件解析出来

码拜

9年 ago

public struct USER_RECORD

        {
            public uint nGroupID;
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
            public byte[] szUserID;
            public uint nFinger;
            public uint nInstances;
            public VCOMWrapper.MX00_TEMPLATE_INSTANCE[] instanceRecords;
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct MX00_TEMPLATE_INSTANCE
        {
            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 2048)]
            public byte[] p378Template;
        }

List<USER_RECORD> ps = new List<USER_RECORD>();

现在要把ps保存成文件，并且下次文件能正确解析出ps?

如果结构体USER_RECORD没有instanceRecords，就可以把这个结构体转成Byte[], 然后写到文件，解析时，读取文件byte[]转成结构体，可是现在有VCOMWrapper.MX00_TEMPLATE_INSTANCE[]，　结构体转成Byte[]失败．

—-

可以用BinaryFormatter把对象序列化到文件里，也可以从文件序列化成对象。

http://msdn.microsoft.com/zh-cn/library/c5sbs8z9(v=vs.110).aspx

—-

CE 上没有BinaryFormatter

不然以前也是用这个

—-

~~CE的话就郁闷了，真的不能序列化？？

自定义FromXml-ToXml可以？

—- 10分

序列化比较简单写
http://www.cnblogs.com/yzenet/p/3622833.html

—-

引用 2 楼 wade008 的回复:

CE 上没有BinaryFormatter

不然以前也是用这个

没有BinaryFormatter也不复杂，可以自己定义一个格式，然后用BinaryWriter和BinaryReader来实现序列化。

—-

引用 4 楼 bdmh 的回复:

序列化比较简单写
http://www.cnblogs.com/yzenet/p/3622833.html

定义类

public class UserRecord
    {
        [XmlElement]
        private uint nGroupID;
        private  byte[] szUserID;
        private  uint nFinger;
        private  uint nInstance;
        private  VCOMWrapper.MX00_TEMPLATE_INSTANCE[] instanceRecords;
        public UserRecord()
        {
        }
        public UserRecord(uint nGroupID, byte[] szUserID, uint nFinger, uint nInstance, VCOMWrapper.MX00_TEMPLATE_INSTANCE[] instanceRecords)
        {
            this.nGroupID = nGroupID;
            this.szUserID = new byte[32];
            Array.Copy(szUserID, this.szUserID, szUserID.Length);
            this.nFinger = nFinger;
            this.Instance = nInstance;
            this.instanceRecords = new VCOMWrapper.MX00_TEMPLATE_INSTANCE[3];
            Array.Copy(instanceRecords, this.instanceRecords, instanceRecords.Length);
        }
｝

调用

List<UserRecord> ps = new List<UserRecord>();
ps.Add(new UserRecord(nGroupID, userRecord.szUserID, userRecord.nFinger, nInstances, instanceRecords));
                    XmlSerializer ser = new XmlSerializer(typeof(List<UserRecord>));
                    FileStream fs = File.Create(strFile);
                    ser.Serialize(fs, ps);
                    fs.Close();

这样序列化出来的文件如下：
<UserRecord>
<GroupID>5</GroupID>
<Finger>4294967211</Finger>
<Instance>3</Instance>
</UserRecord>

并没有szUserID和instanceRecords, 这是什么问题？

—- 90分

        public static void Serialize(USER_RECORD rec, string path)
        {
            using (BinaryWriter wr = new BinaryWriter(File.OpenWrite(path)))
            {
                Serialize(rec, wr);
            }
        }
        public static USER_RECORD Deserialize(string path)
        {
            using (BinaryReader rd = new BinaryReader(File.OpenRead(path)))
            {
                return Deserialize(rd);
            }
        }
        private static void Serialize(USER_RECORD rec, BinaryWriter output)
        {
            output.Write(rec.nGroupID);
            WriteByteArray(rec.szUserID, output);
            output.Write(rec.nFinger);
            output.Write(rec.nInstances);
            if (rec.nInstances > 0)
            {
                MX00_TEMPLATE_INSTANCE[] array = rec.instanceRecords;
                Debug.Assert(array != null && array.Length == rec.nInstances);
                for (int i = 0; i < rec.nInstances; i++)
                {
                    MX00_TEMPLATE_INSTANCE inst = array[i];
                    WriteByteArray(inst.p378Template, output);
                }
            }
        }
        private static void WriteByteArray(byte[] data, BinaryWriter output)
        {
            if (data != null)
            {
                output.Write(data.Length);
                output.Write(data);
            }
            else
                output.Write(-1);
        }
        private static byte[] ReadByteArray(BinaryReader input)
        {
            int len = input.ReadInt32();
            if (len >= 0)
            {
                if (len > 0)
                    return input.ReadBytes(len);
                else
                    return new byte[0];
            }
            else
                return null;
        }
        private static USER_RECORD Deserialize(BinaryReader input)
        {
            USER_RECORD rec = new USER_RECORD();
            int len;
            rec.nGroupID = input.ReadUInt32();
            rec.szUserID = ReadByteArray(input);
            rec.nFinger = input.ReadUInt32();
            len = (int)(rec.nInstances = input.ReadUInt32());
            MX00_TEMPLATE_INSTANCE[] array = new MX00_TEMPLATE_INSTANCE[len];
            for (int i = 0; i < len; i++)
            {
                MX00_TEMPLATE_INSTANCE inst = new MX00_TEMPLATE_INSTANCE();
                inst.p378Template = ReadByteArray(input);
                array[i] = inst;
            }
            rec.instanceRecords = array;
            return rec;
        }

—-

引用 7 楼 effun 的回复:

        public static void Serialize(USER_RECORD rec, string path)
        {
            using (BinaryWriter wr = new BinaryWriter(File.OpenWrite(path)))
            {
                Serialize(rec, wr);
            }
        }

        public static USER_RECORD Deserialize(string path)
        {
            using (BinaryReader rd = new BinaryReader(File.OpenRead(path)))
            {
                return Deserialize(rd);
            }
        }

        private static void Serialize(USER_RECORD rec, BinaryWriter output)
        {
            output.Write(rec.nGroupID);

            WriteByteArray(rec.szUserID, output);
            output.Write(rec.nFinger);
            output.Write(rec.nInstances);

            if (rec.nInstances > 0)
            {
                MX00_TEMPLATE_INSTANCE[] array = rec.instanceRecords;

                Debug.Assert(array != null && array.Length == rec.nInstances);

                for (int i = 0; i < rec.nInstances; i++)
                {
                    MX00_TEMPLATE_INSTANCE inst = array[i];
                    WriteByteArray(inst.p378Template, output);
                }
            }
        }

        private static void WriteByteArray(byte[] data, BinaryWriter output)
        {
            if (data != null)
            {
                output.Write(data.Length);
                output.Write(data);
            }
            else
                output.Write(-1);
        }

        private static byte[] ReadByteArray(BinaryReader input)
        {
            int len = input.ReadInt32();

            if (len >= 0)
            {
                if (len > 0)
                    return input.ReadBytes(len);
                else
                    return new byte[0];
            }
            else
                return null;
        }

        private static USER_RECORD Deserialize(BinaryReader input)
        {
            USER_RECORD rec = new USER_RECORD();
            int len;

            rec.nGroupID = input.ReadUInt32();
            rec.szUserID = ReadByteArray(input);
            rec.nFinger = input.ReadUInt32();
            len = (int)(rec.nInstances = input.ReadUInt32());

            MX00_TEMPLATE_INSTANCE[] array = new MX00_TEMPLATE_INSTANCE[len];

            for (int i = 0; i < len; i++)
            {
                MX00_TEMPLATE_INSTANCE inst = new MX00_TEMPLATE_INSTANCE();
                inst.p378Template = ReadByteArray(input);
                array[i] = inst;
            }

            rec.instanceRecords = array;

            return rec;
        }

 public static void Serialize(USER_RECORD rec, string path)
        {
            using (BinaryWriter wr = new BinaryWriter(File.OpenWrite(path)))
            {
                Serialize(rec, wr);
                wr.Close();
            }
        }

        public static USER_RECORD Deserialize(string path)
        {
            using (BinaryReader rd = new BinaryReader(File.OpenRead(path)))
            {
                return Deserialize(rd);
            }
        }

这边序列化与反序列化只是一个USER_RECORD，如果要序列化List<UserRecord> ps = new List<UserRecord>();和反序列化呢？

—-

引用 7 楼 effun 的回复:

        public static void Serialize(USER_RECORD rec, string path)
        {
            using (BinaryWriter wr = new BinaryWriter(File.OpenWrite(path)))
            {
                Serialize(rec, wr);
            }
        }

        public static USER_RECORD Deserialize(string path)
        {
            using (BinaryReader rd = new BinaryReader(File.OpenRead(path)))
            {
                return Deserialize(rd);
            }
        }

        private static void Serialize(USER_RECORD rec, BinaryWriter output)
        {
            output.Write(rec.nGroupID);

            WriteByteArray(rec.szUserID, output);
            output.Write(rec.nFinger);
            output.Write(rec.nInstances);

            if (rec.nInstances > 0)
            {
                MX00_TEMPLATE_INSTANCE[] array = rec.instanceRecords;

                Debug.Assert(array != null && array.Length == rec.nInstances);

                for (int i = 0; i < rec.nInstances; i++)
                {
                    MX00_TEMPLATE_INSTANCE inst = array[i];
                    WriteByteArray(inst.p378Template, output);
                }
            }
        }

        private static void WriteByteArray(byte[] data, BinaryWriter output)
        {
            if (data != null)
            {
                output.Write(data.Length);
                output.Write(data);
            }
            else
                output.Write(-1);
        }

        private static byte[] ReadByteArray(BinaryReader input)
        {
            int len = input.ReadInt32();

            if (len >= 0)
            {
                if (len > 0)
                    return input.ReadBytes(len);
                else
                    return new byte[0];
            }
            else
                return null;
        }

        private static USER_RECORD Deserialize(BinaryReader input)
        {
            USER_RECORD rec = new USER_RECORD();
            int len;

            rec.nGroupID = input.ReadUInt32();
            rec.szUserID = ReadByteArray(input);
            rec.nFinger = input.ReadUInt32();
            len = (int)(rec.nInstances = input.ReadUInt32());

            MX00_TEMPLATE_INSTANCE[] array = new MX00_TEMPLATE_INSTANCE[len];

            for (int i = 0; i < len; i++)
            {
                MX00_TEMPLATE_INSTANCE inst = new MX00_TEMPLATE_INSTANCE();
                inst.p378Template = ReadByteArray(input);
                array[i] = inst;
            }

            rec.instanceRecords = array;

            return rec;
        }

非常感谢你为我写了这么多！这边序列化与反序列化只是一个USER_RECORD，如果要序列化List<UserRecord> ps = new List<UserRecord>();和反序列化呢？

—-

读写xml也可以实现吧

—-

WinCE 确实不支持字节流序列化。

楼主的实现方案有这么几点：
>自己手写正反序列化（自己分析字符串或字节流 —— 不建议）
>序列化成 XML；
>使用 AsGoodAsItGets.Ser*****.dll 这个第三方的字节流序列化（支持 WinCE）
>使用 http://www.shuxiaolong.com/Project/0/5I7UG4C8GQB.aspx 这个算法能支持 WinCE 的字节流正反序列化。

好吧，我承认我打了个广告，斑竹见谅。

—-

Laura.Serialization 的全部源代码在这个工程里面有：
Laura.Serialization 支持 PC 和 WinCE 的字节流正反序列化 —— 被五六个大项目所考验过。

http://www.shuxiaolong.com/Project/0/5IB56RCWWHE.aspx

—-

引用 9 楼 wade008 的回复:

非常感谢你为我写了这么多！这边序列化与反序列化只是一个USER_RECORD，如果要序列化List<UserRecord> ps = new List<UserRecord>();和反序列化呢？

我只是抛个砖，剩下这部分代码我想你自己也能够写。List<UserRecord>无非是多几个UserRecord对象，可以按照数组的办法来进行序列化和反序列化，你读懂了我的代码自然就可以写出来了。

—-

引用 13 楼 effun 的回复:

Quote: 引用 9 楼 wade008 的回复:
非常感谢你为我写了这么多！这边序列化与反序列化只是一个USER_RECORD，如果要序列化List<UserRecord> ps = new List<UserRecord>();和反序列化呢？

我只是抛个砖，剩下这部分代码我想你自己也能够写。List<UserRecord>无非是多几个UserRecord对象，可以按照数组的办法来进行序列化和反序列化，你读懂了我的代码自然就可以写出来了。

非常感谢你，自己写了List，可以了，再一次谢谢！

—-

至少2个办法：
1.序列化和反序列化；
2.转成json串保存；