ft: cs 序列化代码修正 默认使用大端格式

src/writeCs/gCsCode.cs

@@ -1,14 +1,30 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Data;
 using System.IO;
+using MiscUtil.Conversion;
+using MiscUtil.IO;
 
-namespace ProtoMsg
+namespace GenProto
 {
-    public static class Protocol
+    public static class ProtocolCore
     {
+        public interface ISerialize
+        {
+            void Serialize(EndianBinaryWriter binaryWriter);
+            byte[] Serialize();
+        }
+
+        public interface IDeserialize<T>
+        {
+            void Deserialize(EndianBinaryReader binaryReader);
+            void Deserialize(byte[] data);
+        }
+
         public enum BasicTypeEnum
         {
+            Custom = 0x00,
             Boolean = 0x01,
             Int8 = 0x02,
             UInt8 = 0x03,
@@ -39,11 +55,11 @@ namespace ProtoMsg
                 float => BasicTypeEnum.Float,
                 double => BasicTypeEnum.Double,
                 string => BasicTypeEnum.String,
-                _ => throw new InvalidOperationException($"unexpect type: {value.GetType().FullName}")
+                _ => BasicTypeEnum.Custom,
             };
         }
 
-        public static void WriteValue<T>(this BinaryWriter binaryWriter, T value)
+        public static void WriteValue<T>(this EndianBinaryWriter binaryWriter, T value)
         {
             switch (value)
             {
@@ -81,46 +97,134 @@ namespace ProtoMsg
                     binaryWriter.Write(doubleValue);
                     break;
                 case string stringValue:
-                    binaryWriter.Write(stringValue);
+                    var bytesLength = (ushort)binaryWriter.Encoding.GetByteCount(stringValue);
+                    binaryWriter.Write(bytesLength);
+                    var bytes = binaryWriter.Encoding.GetBytes(stringValue);
+                    binaryWriter.Write(bytes);
                     break;
                 default:
-                    throw new InvalidOperationException($"unexpect type: {value.GetType().FullName}");
+                {
+                    switch (value)
+                    {
+                        case IList listValue:
+                            binaryWriter.WriteList(listValue);
+                            break;
+                        case ISerialize serialize:
+                            serialize.Serialize(binaryWriter);
+                            break;
+                        default:
+                            if (value != null)
+                            {
+                                throw new InvalidOperationException($"unexpect type: {value.GetType().FullName}");
+                            }
+
+                            break;
+                    }
+                    break;
+                }
             }
         }
 
 
-        public static void WriteList<T>(this BinaryWriter binaryWriter, IList<T> list)
+        public static void WriteList(this EndianBinaryWriter binaryWriter, IList list)
         {
-            var length = (ushort) (list?.Count ?? 0);
+            var length = (ushort)(list?.Count ?? 0);
             binaryWriter.Write(length);
 
             if (list == null) return;
             for (var idx = 0; idx < length; idx++)
             {
                 var value = list[idx];
+                binaryWriter.WriteValue(value);
+            }
+        }
 
-                if (idx == 0)
-                {
-                    var basicType = JudgeType(value);
-                    binaryWriter.Write((byte) basicType);
-                }
+        public static void ReadValue(this EndianBinaryReader binaryReader, out bool value)
+        {
+            value = binaryReader.ReadBoolean();
+        }
 
-                binaryWriter.WriteValue(value);
+        public static void ReadValue(this EndianBinaryReader binaryReader, out sbyte value)
+        {
+            value = binaryReader.ReadSByte();
+        }
+
+        public static void ReadValue(this EndianBinaryReader binaryReader, out byte value)
+        {
+            value = binaryReader.ReadByte();
+        }
+
+        public static void ReadValue(this EndianBinaryReader binaryReader, out ushort value)
+        {
+            value = binaryReader.ReadUInt16();
+        }
+
+        public static void ReadValue(this EndianBinaryReader binaryReader, out short value)
+        {
+            value = binaryReader.ReadInt16();
+        }
+
+        public static void ReadValue(this EndianBinaryReader binaryReader, out int value)
+        {
+            value = binaryReader.ReadInt32();
+        }
+
+        public static void ReadValue(this EndianBinaryReader binaryReader, out uint value)
+        {
+            value = binaryReader.ReadUInt32();
+        }
+
+        public static void ReadValue(this EndianBinaryReader binaryReader, out long value)
+        {
+            value = binaryReader.ReadInt64();
+        }
+
+        public static void ReadValue(this EndianBinaryReader binaryReader, out ulong value)
+        {
+            value = binaryReader.ReadUInt64();
+        }
+
+        public static void ReadValue(this EndianBinaryReader binaryReader, out float value)
+        {
+            value = binaryReader.ReadSingle();
+        }
+
+        public static void ReadValue(this EndianBinaryReader binaryReader, out double value)
+        {
+            value = binaryReader.ReadDouble();
+        }
+
+        public static void ReadValue(this EndianBinaryReader binaryReader, out string value)
+        {
+            var bytesLength = binaryReader.ReadUInt16();
+            var bytes = binaryReader.ReadBytes(bytesLength);
+            value = binaryReader.Encoding.GetString(bytes, 0, bytes.Length);
+        }
+
+        public static void ReadValue<T>(this EndianBinaryReader binaryReader, out T value) where T : new()
+        {
+            value = default;
+            value = new T();
+            if (value is not IDeserialize<T> deserialize)
+            {
+                throw new InvalidOperationException($"error type: {typeof(T).FullName}");
             }
+
+            deserialize.Deserialize(binaryReader);
         }
 
-        public static void ReadList(this BinaryReader binaryReader, out IList list)
+        public static void ReadValue<T>(this EndianBinaryReader binaryReader, out List class="p"><T> outList, BasicTypeEnum basicTypeEnum) where T : new()
         {
+            outList = default;
+            IList list = default;
+
             var length = binaryReader.ReadUInt16();
             if (length <= 0)
             {
-                list = default;
                 return;
             }
 
-            list = default;
-            var basicTypeEnum = (BasicTypeEnum) binaryReader.ReadByte();
-            for (int idx = 0; idx < length; idx++)
+            for (var idx = 0; idx < length; idx++)
             {
                 switch (basicTypeEnum)
                 {
@@ -184,18 +288,147 @@ namespace ProtoMsg
                         var stringValue = binaryReader.ReadString();
                         list.Add(stringValue);
                         break;
+                    case BasicTypeEnum.Custom:
+                        list ??= new List<T>(length);
+                        if (new T() is IDeserialize<T> item)
+                            {
+                                item.Deserialize(binaryReader);
+                                list.Add(item);
+                            }
+                        break;
                     default:
-                        throw new ArgumentOutOfRangeException();
+                        throw new InvalidOperationException();
                 }
             }
+
+            outList = list as List<T>;
         }
     }
-}
+
+    public class test : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<test>
+    {
+        public const int ProtoId = 1;
+        public string aa;
+
+        public byte[] Serialize(bool bigEndian = true)
+        {
+            using var memoryStream = new MemoryStream();
+            using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
+            Serialize(binaryWriter);
+            return memoryStream.ToArray();
+        }
+
+        public void Deserialize(byte[] data, bool bigEndian = true)
+        {
+            using var memoryStream = new MemoryStream(data);
+            using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
+            Deserialize(binaryReader);
+        }
+
+        public void Serialize(EndianBinaryWriter binaryWriter)
+        {
+            binaryWriter.WriteValue(aa);
+        }
+
+        public void Deserialize(EndianBinaryReader binaryReader)
+        {
+            binaryReader.ReadValue(out aa);
+        }
+    }
+
+    public class phoneNumber : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<phoneNumber>
+    {
+        public const int ProtoId = 2;
+        public test number;
+        public int type;
+
+        public byte[] Serialize()
+        {
+            using var memoryStream = new MemoryStream();
+            using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
+            Serialize(binaryWriter);
+            return memoryStream.ToArray();
+        }
+
+        public void Deserialize(byte[] data)
+        {
+            using var memoryStream = new MemoryStream(data);
+            using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
+            Deserialize(binaryReader);
+        }
+
+        public void Serialize(EndianBinaryWriter binaryWriter)
+        {
+            binaryWriter.WriteValue(number);
+            binaryWriter.WriteValue(type);
+        }
+
+        public void Deserialize(EndianBinaryReader binaryReader)
+        {
+            binaryReader.ReadValue(out number);
+            binaryReader.ReadValue(out type);
+        }
+    }
+
+    public class person : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<person>
+    {
+        public const int ProtoId = 3;
+        public string name;
+        public int id;
+        public string email;
+        public List<phoneNumber> phone;
+
+        public byte[] Serialize()
+        {
+            using var memoryStream = new MemoryStream();
+            using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
+            Serialize(binaryWriter);
+            return memoryStream.ToArray();
+        }
+
+        public void Deserialize(byte[] data)
+        {
+            using var memoryStream = new MemoryStream(data);
+            using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
+            Deserialize(binaryReader);
+        }
+
+        public void Serialize(EndianBinaryWriter binaryWriter)
+        {
+            binaryWriter.WriteValue(name);
+            binaryWriter.WriteValue(id);
+            binaryWriter.WriteValue(email);
+            if (xx != null)
+            {
+               binaryWriter.WriteValue(1);
+               binaryWriter.WriteValue(phone);
+            }
+            else
+            {
+
+            }
+            binaryWriter.WriteValue(phone);
+        }
+
+        public void Deserialize(EndianBinaryReader binaryReader)
+        {
+            binaryReader.ReadValue(out name);
+            binaryReader.ReadValue(out id);
+            binaryReader.ReadValue(out email);
+            binaryReader.ReadValue(out phone, 0x00);
+        }
+    }
+
+    public class addressBook : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<addressBook>
+    {
+        public const int ProtoId = 4;
+        public List<person> person;
+        public List<person> other;
 
         public byte[] Serialize()
         {
             using var memoryStream = new MemoryStream();
-            using var binaryWriter = new BinaryWriter(memoryStream);
+            using var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
             Serialize(binaryWriter);
             return memoryStream.ToArray();
         }
@@ -203,6 +436,20 @@ namespace ProtoMsg
         public void Deserialize(byte[] data)
         {
             using var memoryStream = new MemoryStream(data);
-            using var binaryReader = new BinaryReader(memoryStream);
+            using var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
             Deserialize(binaryReader);
-        }
+        }
+
+        public void Serialize(EndianBinaryWriter binaryWriter)
+        {
+            binaryWriter.WriteValue(person);
+            binaryWriter.WriteValue(other);
+        }
+
+        public void Deserialize(EndianBinaryReader binaryReader)
+        {
+            binaryReader.ReadValue(out person);
+            binaryReader.ReadValue(out other);
+        }
+    }
+}

src/writeCs/gCsField.erl

@@ -15,31 +15,32 @@
    , <<"double">>
 ]).
 
+-define(CustomTypeEnum, <<"0x00">>).
 -define(TypeValue, [
-   {<<"bool">>, <<"bool">>}
-   , {<<"int8">>, <<"sbyte">>}
-   , {<<"uint8">>, <<"byte">>}
-   , {<<"int16">>, <<"short">>}
-   , {<<"uint16">>, <<"ushort">>}
-   , {<<"int32">>, <<"int">>}
-   , {<<"uint32">>, <<"uint">>}
-   , {<<"int64">>, <<"long">>}
-   , {<<"uint64">>, <<"ulong">>}
-   , {<<"float">>, <<"float">>}
-   , {<<"double">>, <<"double">>}
-   , {<<"string">>, <<"string">>}
+   {<<"bool">>, <<"bool">>, <<"0x01">>}
+   , {<<"int8">>, <<"sbyte">>, <<"0x02">>}
+   , {<<"uint8">>, <<"byte">>, <<"0x03">>}
+   , {<<"int16">>, <<"short">>, <<"0x04">>}
+   , {<<"uint16">>, <<"ushort">>, <<"0x05">>}
+   , {<<"int32">>, <<"int">>, <<"0x06">>}
+   , {<<"uint32">>, <<"uint">>, <<"0x07">>}
+   , {<<"int64">>, <<"long">>, <<"0x08">>}
+   , {<<"uint64">>, <<"ulong">>, <<"0x09">>}
+   , {<<"float">>, <<"float">>, <<"0x10">>}
+   , {<<"double">>, <<"double">>, <<"0x11">>}
+   , {<<"string">>, <<"string">>, <<"0x12">>}
 ]).
 
 builtMemberStr({TypeStr, NameStr}) ->
    case lists:keyfind(TypeStr, 1, ?TypeValue) of
-      {TypeStr, CSTypeStr} ->
+      {TypeStr, CSTypeStr, _TypeEnumVale} ->
          <<"\t\tpublic ", CSTypeStr/binary, " ", NameStr/binary, ";\n">>;
       _ ->
          case TypeStr of
             <<"list[", LeftStr/binary>> ->
                [SubTypeStr | _] = re:split(LeftStr, <<"\\]">>, [{return, binary}]),
                case lists:keyfind(SubTypeStr, 1, ?TypeValue) of
-                  {SubTypeStr, SubCSTypeStr} ->
+                  {SubTypeStr, SubCSTypeStr, _TypeEnumVale} ->
                      <<"\t\tpublic List<", SubCSTypeStr/binary, "> ", NameStr/binary, ";\n">>;
                   _ ->
                      <<"\t\tpublic List<", SubTypeStr/binary, "> ", NameStr/binary, ";\n">>
@@ -48,3 +49,41 @@ builtMemberStr({TypeStr, NameStr}) ->
                <<"\t\tpublic ", TypeStr/binary, " ", NameStr/binary, ";\n">>
          end
    end.
+
+builtEncodeStr({TypeStr, NameStr}) ->
+   case lists:keyfind(TypeStr, 1, ?TypeValue) of
+      {TypeStr, _CSTypeStr, _TypeEnumVale} ->
+         <<"\t\t\tbinaryWriter.WriteValue(", NameStr/binary, ");\n">>;
+      _ ->
+         case TypeStr of
+            <<"list[", LeftStr/binary>> ->
+               [SubTypeStr | _] = re:split(LeftStr, <<"\\]">>, [{return, binary}]),
+               case lists:keyfind(SubTypeStr, 1, ?TypeValue) of
+                  {SubTypeStr, _CSTypeStr, _TypeEnumVale} ->
+                     <<"\t\t\tbinaryWriter.WriteValue(", NameStr/binary, ");\n">>;
+                  _ ->
+                     <<"\t\t\tbinaryWriter.WriteValue(", NameStr/binary, ");\n">>
+               end;
+            _ ->
+               <<"\t\t\tif (", NameStr/binary, " != null)\n\t\t\t{\n\t\t\t\tbinaryWriter.WriteValue(1);\n\t\t\t\tbinaryWriter.WriteValue(", NameStr/binary, ");\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tbinaryWriter.WriteValue(0);\n\t\t\t}\n">>
+         end
+   end.
+
+builtDecodeStr({TypeStr, NameStr}) ->
+   case lists:keyfind(TypeStr, 1, ?TypeValue) of
+      {TypeStr, _CSTypeStr, _TypeEnumVale} ->
+         <<"\t\t\tbinaryReader.ReadValue(out ", NameStr/binary, ");\n">>;
+      _ ->
+         case TypeStr of
+            <<"list[", LeftStr/binary>> ->
+               [SubTypeStr | _] = re:split(LeftStr, <<"\\]">>, [{return, binary}]),
+               case lists:keyfind(SubTypeStr, 1, ?TypeValue) of
+                  {SubTypeStr, _CSTypeStr, TypeEnumVale} ->
+                     <<"\t\t\tbinaryReader.ReadValue(out ", NameStr/binary, ", ", TypeEnumVale/binary, ");\n">>;
+                  _ ->
+                     <<"\t\t\tbinaryReader.ReadValue(out ", NameStr/binary,", ", (?CustomTypeEnum)/binary, ");\n">>
+               end;
+            _ ->
+               <<"\t\t\tif (binaryReader.ReadBoolean())\n\t\t\t{\n\t\t\t\tbinaryReader.ReadValue(out ", NameStr/binary, ");\n\t\t\t}\n">>
+         end
+   end.

src/writeCs/gCsGen.erl

@@ -5,11 +5,13 @@
 ]).
 
 protoHeader() ->
-   <<"using System;
+<<"using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Data;
 using System.IO;
+using MiscUtil.Conversion;
+using MiscUtil.IO;
 
 namespace GenProto
 {
@@ -17,13 +19,13 @@ namespace GenProto
     {
         public interface ISerialize
         {
-            void Serialize(BinaryWriter binaryWriter);
+            void Serialize(EndianBinaryWriter binaryWriter);
             byte[] Serialize();
         }
 
         public interface IDeserialize<T>
         {
-            void Deserialize(BinaryReader binaryReader);
+            void Deserialize(EndianBinaryReader binaryReader);
             void Deserialize(byte[] data);
         }
 
@@ -64,7 +66,7 @@ namespace GenProto
             };
         }
 
-        public static void WriteValue<T>(this BinaryWriter binaryWriter, T value)
+        public static void WriteValue<T>(this EndianBinaryWriter binaryWriter, T value)
         {
             switch (value)
             {
@@ -102,11 +104,13 @@ namespace GenProto
                     binaryWriter.Write(doubleValue);
                     break;
                 case string stringValue:
-                    binaryWriter.Write(stringValue);
+                    var bytesLength = (ushort)binaryWriter.Encoding.GetByteCount(stringValue);
+                    binaryWriter.Write(bytesLength);
+                    var bytes = binaryWriter.Encoding.GetBytes(stringValue);
+                    binaryWriter.Write(bytes);
                     break;
                 default:
                 {
-                    binaryWriter.Write(value != null);
                     switch (value)
                     {
                         case IList listValue:
@@ -123,104 +127,92 @@ namespace GenProto
 
                             break;
                     }
-
                     break;
                 }
             }
         }
 
 
-        public static void WriteList(this BinaryWriter binaryWriter, IList list)
+        public static void WriteList(this EndianBinaryWriter binaryWriter, IList list)
         {
-            var length = (ushort) (list?.Count ?? 0);
+            var length = (ushort)(list?.Count ?? 0);
             binaryWriter.Write(length);
 
             if (list == null) return;
             for (var idx = 0; idx < length; idx++)
             {
                 var value = list[idx];
-
-                if (idx == 0)
-                {
-                    var basicType = JudgeType(value);
-                    binaryWriter.Write((byte) basicType);
-                }
-
                 binaryWriter.WriteValue(value);
             }
         }
 
-        public static void ReadValue(this BinaryReader binaryReader, out bool value)
+        public static void ReadValue(this EndianBinaryReader binaryReader, out bool value)
         {
             value = binaryReader.ReadBoolean();
         }
 
-        public static void ReadValue(this BinaryReader binaryReader, out sbyte value)
+        public static void ReadValue(this EndianBinaryReader binaryReader, out sbyte value)
         {
             value = binaryReader.ReadSByte();
         }
 
-        public static void ReadValue(this BinaryReader binaryReader, out byte value)
+        public static void ReadValue(this EndianBinaryReader binaryReader, out byte value)
         {
             value = binaryReader.ReadByte();
         }
 
-        public static void ReadValue(this BinaryReader binaryReader, out ushort value)
+        public static void ReadValue(this EndianBinaryReader binaryReader, out ushort value)
         {
             value = binaryReader.ReadUInt16();
         }
 
-        public static void ReadValue(this BinaryReader binaryReader, out short value)
+        public static void ReadValue(this EndianBinaryReader binaryReader, out short value)
         {
             value = binaryReader.ReadInt16();
         }
 
-        public static void ReadValue(this BinaryReader binaryReader, out int value)
+        public static void ReadValue(this EndianBinaryReader binaryReader, out int value)
         {
             value = binaryReader.ReadInt32();
         }
 
-        public static void ReadValue(this BinaryReader binaryReader, out uint value)
+        public static void ReadValue(this EndianBinaryReader binaryReader, out uint value)
         {
             value = binaryReader.ReadUInt32();
         }
 
-        public static void ReadValue(this BinaryReader binaryReader, out long value)
+        public static void ReadValue(this EndianBinaryReader binaryReader, out long value)
         {
             value = binaryReader.ReadInt64();
         }
 
-        public static void ReadValue(this BinaryReader binaryReader, out ulong value)
+        public static void ReadValue(this EndianBinaryReader binaryReader, out ulong value)
         {
             value = binaryReader.ReadUInt64();
         }
 
-        public static void ReadValue(this BinaryReader binaryReader, out float value)
+        public static void ReadValue(this EndianBinaryReader binaryReader, out float value)
         {
             value = binaryReader.ReadSingle();
         }
 
-        public static void ReadValue(this BinaryReader binaryReader, out double value)
+        public static void ReadValue(this EndianBinaryReader binaryReader, out double value)
         {
             value = binaryReader.ReadDouble();
         }
 
-        public static void ReadValue(this BinaryReader binaryReader, out string value)
+        public static void ReadValue(this EndianBinaryReader binaryReader, out string value)
         {
-            value = binaryReader.ReadString();
+            var bytesLength = binaryReader.ReadUInt16();
+            var bytes = binaryReader.ReadBytes(bytesLength);
+            value = binaryReader.Encoding.GetString(bytes, 0, bytes.Length);
         }
 
-        public static void ReadValue<T>(this BinaryReader binaryReader, out T value) where T : new()
+        public static void ReadValue<T>(this EndianBinaryReader binaryReader, out T value) where T : new()
         {
             value = default;
-            var haveValue = binaryReader.ReadBoolean();
-            if (!haveValue)
-            {
-                return;
-            }
-
             value = new T();
-            if (!(value is IDeserialize<T> deserialize))
+            if (value is not IDeserialize<T> deserialize)
             {
                 throw new InvalidOperationException($\"error type: {typeof(T).FullName}\");
             }
@@ -228,15 +220,10 @@ namespace GenProto
             deserialize.Deserialize(binaryReader);
         }
 
-        public static void ReadValue<T>(this BinaryReader binaryReader, out List<T> outList) where T : new()
+        public static void ReadValue<T>(this EndianBinaryReader binaryReader, out List<T> outList, BasicTypeEnum basicTypeEnum) where T : new()
         {
             outList = default;
             IList list = default;
-            var haveValue = binaryReader.ReadBoolean();
-            if (!haveValue)
-            {
-                return;
-            }
 
             var length = binaryReader.ReadUInt16();
             if (length <= 0)
@@ -244,7 +231,6 @@ namespace GenProto
                 return;
             }
 
-            var basicTypeEnum = (BasicTypeEnum) binaryReader.ReadByte();
             for (var idx = 0; idx < length; idx++)
             {
                 switch (basicTypeEnum)
@@ -311,19 +297,12 @@ namespace GenProto
                         break;
                     case BasicTypeEnum.Custom:
                         list ??= new List<T>(length);
-                        var state = binaryReader.ReadBoolean();
-                        if (state)
-                        {
-                            if (new T() is IDeserialize<T> item)
+                        if (new T() is IDeserialize<T> item)
                             {
                                 item.Deserialize(binaryReader);
                                 list.Add(item);
                             }
-                        }
-
                         break;
-
-
                     default:
                         throw new InvalidOperationException();
                 }
@@ -344,7 +323,7 @@ spellClassMember(FieldList) ->
 
 spellCalssDSTem() ->
    <<"\n\t\tpublic byte[] Serialize()\n\t\t{\n\t\t\tusing var memoryStream = new MemoryStream();
-\t\t\tusing var binaryWriter = new BinaryWriter(memoryStream);
+\t\t\tusing var binaryWriter = new EndianBinaryWriter(EndianBitConverter.Big, memoryStream);
 \t\t\tSerialize(binaryWriter);
 \t\t\treturn memoryStream.ToArray();
 \t\t}
@@ -352,18 +331,18 @@ spellCalssDSTem() ->
 \t\tpublic void Deserialize(byte[] data)
 \t\t{
 \t\t\tusing var memoryStream = new MemoryStream(data);
-\t\t\tusing var binaryReader = new BinaryReader(memoryStream);
+\t\t\tusing var binaryReader = new EndianBinaryReader(EndianBitConverter.Big, memoryStream);
 \t\t\tDeserialize(binaryReader);
 \t\t}\n">>.
 
 spellCalssSerialize(FieldList) ->
-   FunHead = <<"\t\tpublic void Serialize(BinaryWriter binaryWriter)\n\t\t{\n">>,
-   FunBody = <<<<"\t\t\tbinaryWriter.WriteValue(", NameStr/binary, ");\n">> || {_TypeStr, NameStr} <- FieldList>>,
+   FunHead = <<"\t\tpublic void Serialize(EndianBinaryWriter binaryWriter)\n\t\t{\n">>,
+   FunBody = <<<<(gCsField:builtEncodeStr(OneTypeName))/binary>> || OneTypeName <- FieldList>>,
    <<FunHead/binary, FunBody/binary, "\t\t}\n">>.
 
 spellCalssDeserialize(FieldList) ->
    FunHead = <<"\t\tpublic void Deserialize(BinaryReader binaryReader)\n\t\t{\n">>,
-   FunBody = <<<<"\t\t\tbinaryReader.ReadValue(out ", NameStr/binary, ");\n">> || {_TypeStr, NameStr} <- FieldList>>,
+   FunBody = <<<<(gCsField:builtDecodeStr(OneTypeName))/binary>> || OneTypeName <- FieldList>>,
    <<FunHead/binary, FunBody/binary, "\t\t}\n">>.
 
 spellClassEnd() ->

src/writeCs/sample/ProtocolMsg.cs

@@ -1,598 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Data;
-using System.IO;
-
-namespace GenProto
-{
-    public static class ProtocolCore
-    {
-        public interface ISerialize
-        {
-            void Serialize(BinaryWriter binaryWriter);
-            byte[] Serialize();
-        }
-
-        public interface IDeserialize<T>
-        {
-            void Deserialize(BinaryReader binaryReader);
-            void Deserialize(byte[] data);
-        }
-
-        public enum BasicTypeEnum
-        {
-            Custom = 0x00,
-            Boolean = 0x01,
-            Int8 = 0x02,
-            UInt8 = 0x03,
-            UInt16 = 0x04,
-            Int16 = 0x05,
-            Int32 = 0x06,
-            UInt32 = 0x07,
-            Int64 = 0x08,
-            UInt64 = 0x09,
-            Float = 0x10,
-            Double = 0x11,
-            String = 0x12,
-        }
-
-        public static BasicTypeEnum JudgeType<T>(T value)
-        {
-            return value switch
-            {
-                bool => BasicTypeEnum.Boolean,
-                byte => BasicTypeEnum.Int8,
-                sbyte => BasicTypeEnum.UInt8,
-                ushort => BasicTypeEnum.UInt16,
-                short => BasicTypeEnum.Int16,
-                int => BasicTypeEnum.Int32,
-                uint => BasicTypeEnum.UInt32,
-                long => BasicTypeEnum.Int64,
-                ulong => BasicTypeEnum.UInt64,
-                float => BasicTypeEnum.Float,
-                double => BasicTypeEnum.Double,
-                string => BasicTypeEnum.String,
-                _ => BasicTypeEnum.Custom,
-            };
-        }
-
-        public static void WriteValue<T>(this BinaryWriter binaryWriter, T value)
-        {
-            switch (value)
-            {
-                case bool boolValue:
-                    binaryWriter.Write(boolValue);
-                    break;
-                case byte byteValue:
-                    binaryWriter.Write(byteValue);
-                    break;
-                case sbyte sbyteValue:
-                    binaryWriter.Write(sbyteValue);
-                    break;
-                case ushort ushortValue:
-                    binaryWriter.Write(ushortValue);
-                    break;
-                case short shortValue:
-                    binaryWriter.Write(shortValue);
-                    break;
-                case int intValue:
-                    binaryWriter.Write(intValue);
-                    break;
-                case uint uintValue:
-                    binaryWriter.Write(uintValue);
-                    break;
-                case long longValue:
-                    binaryWriter.Write(longValue);
-                    break;
-                case ulong ulongValue:
-                    binaryWriter.Write(ulongValue);
-                    break;
-                case float floatValue:
-                    binaryWriter.Write(floatValue);
-                    break;
-                case double doubleValue:
-                    binaryWriter.Write(doubleValue);
-                    break;
-                case string stringValue:
-                    binaryWriter.Write(stringValue);
-                    break;
-                default:
-                {
-                    binaryWriter.Write(value != null);
-                    switch (value)
-                    {
-                        case IList listValue:
-                            binaryWriter.WriteList(listValue);
-                            break;
-                        case ISerialize serialize:
-                            serialize.Serialize(binaryWriter);
-                            break;
-                        default:
-                            if (value != null)
-                            {
-                                throw new InvalidOperationException($"unexpect type: {value.GetType().FullName}");
-                            }
-
-                            break;
-                    }
-
-                    break;
-                }
-            }
-        }
-
-
-        public static void WriteList(this BinaryWriter binaryWriter, IList list)
-        {
-            var length = (ushort) (list?.Count ?? 0);
-            binaryWriter.Write(length);
-
-            if (list == null) return;
-            for (var idx = 0; idx < length; idx++)
-            {
-                var value = list[idx];
-
-                if (idx == 0)
-                {
-                    var basicType = JudgeType(value);
-                    binaryWriter.Write((byte) basicType);
-                }
-
-                binaryWriter.WriteValue(value);
-            }
-        }
-
-        public static void ReadValue(this BinaryReader binaryReader, out bool value)
-        {
-            value = binaryReader.ReadBoolean();
-        }
-
-        public static void ReadValue(this BinaryReader binaryReader, out sbyte value)
-        {
-            value = binaryReader.ReadSByte();
-        }
-
-        public static void ReadValue(this BinaryReader binaryReader, out byte value)
-        {
-            value = binaryReader.ReadByte();
-        }
-
-        public static void ReadValue(this BinaryReader binaryReader, out ushort value)
-        {
-            value = binaryReader.ReadUInt16();
-        }
-
-        public static void ReadValue(this BinaryReader binaryReader, out short value)
-        {
-            value = binaryReader.ReadInt16();
-        }
-
-        public static void ReadValue(this BinaryReader binaryReader, out int value)
-        {
-            value = binaryReader.ReadInt32();
-        }
-
-        public static void ReadValue(this BinaryReader binaryReader, out uint value)
-        {
-            value = binaryReader.ReadUInt32();
-        }
-
-        public static void ReadValue(this BinaryReader binaryReader, out long value)
-        {
-            value = binaryReader.ReadInt64();
-        }
-
-        public static void ReadValue(this BinaryReader binaryReader, out ulong value)
-        {
-            value = binaryReader.ReadUInt64();
-        }
-
-        public static void ReadValue(this BinaryReader binaryReader, out float value)
-        {
-            value = binaryReader.ReadSingle();
-        }
-
-        public static void ReadValue(this BinaryReader binaryReader, out double value)
-        {
-            value = binaryReader.ReadDouble();
-        }
-
-        public static void ReadValue(this BinaryReader binaryReader, out string value)
-        {
-            value = binaryReader.ReadString();
-        }
-
-        public static void ReadValue<T>(this BinaryReader binaryReader, out T value) where T : new()
-        {
-            value = default;
-            var haveValue = binaryReader.ReadBoolean();
-            if (!haveValue)
-            {
-                return;
-            }
-
-            value = new T();
-            if (!(value is IDeserialize<T> deserialize))
-            {
-                throw new InvalidOperationException($"error type: {typeof(T).FullName}");
-            }
-
-            deserialize.Deserialize(binaryReader);
-        }
-
-        public static void ReadValue<T>(this BinaryReader binaryReader, out List<T> outList) where T : new()
-        {
-            outList = default;
-            IList list = default;
-            var haveValue = binaryReader.ReadBoolean();
-            if (!haveValue)
-            {
-                return;
-            }
-
-            var length = binaryReader.ReadUInt16();
-            if (length <= 0)
-            {
-                return;
-            }
-
-            var basicTypeEnum = (BasicTypeEnum) binaryReader.ReadByte();
-            for (var idx = 0; idx < length; idx++)
-            {
-                switch (basicTypeEnum)
-                {
-                    case BasicTypeEnum.Boolean:
-                        list ??= new List<bool>(length);
-                        var boolValue = binaryReader.ReadBoolean();
-                        list.Add(boolValue);
-                        break;
-                    case BasicTypeEnum.Int8:
-                        list ??= new List<sbyte>(length);
-                        var sbyteValue = binaryReader.ReadSByte();
-                        list.Add(sbyteValue);
-                        break;
-                    case BasicTypeEnum.UInt8:
-                        list ??= new List<byte>(length);
-                        var byteValue = binaryReader.ReadByte();
-                        list.Add(byteValue);
-                        break;
-                    case BasicTypeEnum.UInt16:
-                        list ??= new List<ushort>(length);
-                        var ushortValue = binaryReader.ReadUInt16();
-                        list.Add(ushortValue);
-                        break;
-                    case BasicTypeEnum.Int16:
-                        list ??= new List<short>(length);
-                        var shortValue = binaryReader.ReadInt16();
-                        list.Add(shortValue);
-                        break;
-                    case BasicTypeEnum.Int32:
-                        list ??= new List<int>(length);
-                        var intValue = binaryReader.ReadInt32();
-                        list.Add(intValue);
-                        break;
-                    case BasicTypeEnum.UInt32:
-                        list ??= new List<uint>(length);
-                        var uintValue = binaryReader.ReadUInt32();
-                        list.Add(uintValue);
-                        break;
-                    case BasicTypeEnum.Int64:
-                        list ??= new List<long>(length);
-                        var longValue = binaryReader.ReadInt64();
-                        list.Add(longValue);
-                        break;
-                    case BasicTypeEnum.UInt64:
-                        list ??= new List<ulong>(length);
-                        var ulongValue = binaryReader.ReadUInt64();
-                        list.Add(ulongValue);
-                        break;
-                    case BasicTypeEnum.Float:
-                        list ??= new List<float>(length);
-                        var singleValue = binaryReader.ReadSingle();
-                        list.Add(singleValue);
-                        break;
-                    case BasicTypeEnum.Double:
-                        list ??= new List<double>(length);
-                        var doubleValue = binaryReader.ReadDouble();
-                        list.Add(doubleValue);
-                        break;
-                    case BasicTypeEnum.String:
-                        list ??= new List<string>(length);
-                        var stringValue = binaryReader.ReadString();
-                        list.Add(stringValue);
-                        break;
-                    case BasicTypeEnum.Custom:
-                        list ??= new List<T>(length);
-                        var state = binaryReader.ReadBoolean();
-                        if (state)
-                        {
-                            if (new T() is IDeserialize<T> item)
-                            {
-                                item.Deserialize(binaryReader);
-                                list.Add(item);
-                            }
-                        }
-
-                        break;
-
-
-                    default:
-                        throw new InvalidOperationException();
-                }
-            }
-
-            outList = list as List<T>;
-        }
-    }
-
-    public class AllType : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<AllType>
-    {
-        public const int protoId = 11;
-        public bool Bool;
-        public sbyte Int8;
-        public byte UInt8;
-        public ushort UInt16;
-        public short Int16;
-        public int Int32;
-        public uint UInt32;
-        public long Int64;
-        public ulong UInt64;
-        public float Float;
-        public double Double;
-        public string String;
-        public SubType SubType;
-        public List<SubType> ListSubType;
-        public List<bool> ListBool;
-        public List<sbyte> ListInt8;
-        public List<byte> ListUInt8;
-        public List<ushort> ListUInt16;
-        public List<short> ListInt16;
-        public List<int> ListInt32;
-        public List<uint> ListUInt32;
-        public List<long> ListInt64;
-        public List<ulong> ListUInt64;
-        public List<float> ListFloat;
-        public List<double> ListDouble;
-        public List<string> ListString;
-
-        public byte[] Serialize()
-        {
-            using var memoryStream = new MemoryStream();
-            using var binaryWriter = new BinaryWriter(memoryStream);
-            Serialize(binaryWriter);
-            return memoryStream.ToArray();
-        }
-
-        public void Deserialize(byte[] data)
-        {
-            using var memoryStream = new MemoryStream(data);
-            using var binaryReader = new BinaryReader(memoryStream);
-            Deserialize(binaryReader);
-        }
-
-        public void Serialize(BinaryWriter binaryWriter)
-        {
-            binaryWriter.WriteValue(Bool);
-            binaryWriter.WriteValue(Int8);
-            binaryWriter.WriteValue(UInt8);
-            binaryWriter.WriteValue(UInt16);
-            binaryWriter.WriteValue(Int16);
-            binaryWriter.WriteValue(Int32);
-            binaryWriter.WriteValue(UInt32);
-            binaryWriter.WriteValue(Int64);
-            binaryWriter.WriteValue(UInt64);
-            binaryWriter.WriteValue(Float);
-            binaryWriter.WriteValue(Double);
-            binaryWriter.WriteValue(String);
-            binaryWriter.WriteValue(SubType);
-            binaryWriter.WriteValue(ListSubType);
-            binaryWriter.WriteValue(ListBool);
-            binaryWriter.WriteValue(ListInt8);
-            binaryWriter.WriteValue(ListUInt8);
-            binaryWriter.WriteValue(ListUInt16);
-            binaryWriter.WriteValue(ListInt16);
-            binaryWriter.WriteValue(ListInt32);
-            binaryWriter.WriteValue(ListUInt32);
-            binaryWriter.WriteValue(ListInt64);
-            binaryWriter.WriteValue(ListUInt64);
-            binaryWriter.WriteValue(ListFloat);
-            binaryWriter.WriteValue(ListDouble);
-            binaryWriter.WriteValue(ListString);
-        }
-
-
-        public void Deserialize(BinaryReader binaryReader)
-        {
-            binaryReader.ReadValue(out Bool);
-            binaryReader.ReadValue(out Int8);
-            binaryReader.ReadValue(out UInt8);
-            binaryReader.ReadValue(out UInt16);
-            binaryReader.ReadValue(out Int16);
-            binaryReader.ReadValue(out Int32);
-            binaryReader.ReadValue(out UInt32);
-            binaryReader.ReadValue(out Int64);
-            binaryReader.ReadValue(out UInt64);
-            binaryReader.ReadValue(out Float);
-            binaryReader.ReadValue(out Double);
-            binaryReader.ReadValue(out String);
-            binaryReader.ReadValue(out SubType);
-            binaryReader.ReadValue(out ListSubType);
-            binaryReader.ReadValue(out ListBool);
-            binaryReader.ReadValue(out ListInt8);
-            binaryReader.ReadValue(out ListUInt8);
-            binaryReader.ReadValue(out ListUInt16);
-            binaryReader.ReadValue(out ListInt16);
-            binaryReader.ReadValue(out ListInt32);
-            binaryReader.ReadValue(out ListUInt32);
-            binaryReader.ReadValue(out ListInt64);
-            binaryReader.ReadValue(out ListUInt64);
-            binaryReader.ReadValue(out ListFloat);
-            binaryReader.ReadValue(out ListDouble);
-            binaryReader.ReadValue(out ListString);
-        }
-    }
-
-    public class SubType : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<SubType>
-    {
-        public int Int32;
-
-        public byte[] Serialize()
-        {
-            using var memoryStream = new MemoryStream();
-            using var binaryWriter = new BinaryWriter(memoryStream);
-            Serialize(binaryWriter);
-            return memoryStream.ToArray();
-        }
-
-        public void Deserialize(byte[] data)
-        {
-            using var memoryStream = new MemoryStream(data);
-            using var binaryReader = new BinaryReader(memoryStream);
-            Deserialize(binaryReader);
-        }
-
-        public void Serialize(BinaryWriter binaryWriter)
-        {
-            binaryWriter.WriteValue(Int32);
-        }
-
-        public void Deserialize(BinaryReader binaryReader)
-        {
-            binaryReader.ReadValue(out Int32);
-        }
-    }
-
-    public class Test : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<SubType>
-    {
-        public string aa;
-        public void Serialize(BinaryWriter binaryWriter)
-        {
-            binaryWriter.WriteValue(aa);
-        }
-
-        public byte[] Serialize()
-        {
-            using var memoryStream = new MemoryStream();
-            using var binaryWriter = new BinaryWriter(memoryStream);
-            Serialize(binaryWriter);
-            return memoryStream.ToArray();
-        }
-
-        public void Deserialize(BinaryReader binaryReader)
-        {
-            binaryReader.ReadValue(out aa);
-        }
-
-        public void Deserialize(byte[] data)
-        {
-            using var memoryStream = new MemoryStream(data);
-            using var binaryReader = new BinaryReader(memoryStream);
-            Deserialize(binaryReader);
-        }
-    }
-
-    public class PhoneNumber : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<SubType>
-    {
-        public Test number;
-        public int type;
-        public void Serialize(BinaryWriter binaryWriter)
-        {
-            binaryWriter.WriteValue(number);
-            binaryWriter.WriteValue(type);
-        }
-
-        public byte[] Serialize()
-        {
-            using var memoryStream = new MemoryStream();
-            using var binaryWriter = new BinaryWriter(memoryStream);
-            Serialize(binaryWriter);
-            return memoryStream.ToArray();
-        }
-
-        public void Deserialize(BinaryReader binaryReader)
-        {
-            binaryReader.ReadValue(out number);
-            binaryReader.ReadValue(out type);
-        }
-
-        public void Deserialize(byte[] data)
-        {
-            using var memoryStream = new MemoryStream(data);
-            using var binaryReader = new BinaryReader(memoryStream);
-            Deserialize(binaryReader);
-        }
-    }
-    
-    public class Person : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<SubType>
-    {
-        public string Name;
-        public int id;
-        public string email;
-        public List<PhoneNumber> phone;
-        
-        
-        public void Serialize(BinaryWriter binaryWriter)
-        {
-            binaryWriter.WriteValue(Name);
-            binaryWriter.WriteValue(id);
-            binaryWriter.WriteValue(email);
-            binaryWriter.WriteValue(phone);
-        }
-
-        public byte[] Serialize()
-        {
-            using var memoryStream = new MemoryStream();
-            using var binaryWriter = new BinaryWriter(memoryStream);
-            Serialize(binaryWriter);
-            return memoryStream.ToArray();
-        }
-
-        public void Deserialize(BinaryReader binaryReader)
-        {
-            binaryReader.ReadValue(out Name);
-            binaryReader.ReadValue(out id);
-            binaryReader.ReadValue(out email);
-            binaryReader.ReadValue(out phone);
-        }
-
-        public void Deserialize(byte[] data)
-        {
-            using var memoryStream = new MemoryStream(data);
-            using var binaryReader = new BinaryReader(memoryStream);
-            Deserialize(binaryReader);
-        }
-    }
-
-    public class AddressBook : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<SubType>
-    {
-        public List<Person> person;
-        public List<Person> other;
-        public void Serialize(BinaryWriter binaryWriter)
-        {
-            binaryWriter.WriteValue(person);
-            binaryWriter.WriteValue(other);
-        }
-
-        public byte[] Serialize()
-        {
-            using var memoryStream = new MemoryStream();
-            using var binaryWriter = new BinaryWriter(memoryStream);
-            Serialize(binaryWriter);
-            return memoryStream.ToArray();
-        }
-
-        public void Deserialize(BinaryReader binaryReader)
-        {
-            binaryReader.ReadValue(out person);
-            binaryReader.ReadValue(out other);
-        }
-
-        public void Deserialize(byte[] data)
-        {
-            using var memoryStream = new MemoryStream(data);
-            using var binaryReader = new BinaryReader(memoryStream);
-            Deserialize(binaryReader);
-        }
-    }
-}