diff --git a/src/writeCs/ProtocolMsg.cs b/src/writeCs/ProtocolMsg.cs
index 46819fa..1ae82ce 100644
--- a/src/writeCs/ProtocolMsg.cs
+++ b/src/writeCs/ProtocolMsg.cs
@@ -328,6 +328,7 @@ namespace GenProto
 
     public class AllType : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<AllType>
     {
+        public const int protoId = 11;
         public bool Bool;
         public sbyte Int8;
         public byte UInt8;
diff --git a/src/writeCs/cs序列化1.jpg b/src/writeCs/cs序列化1.jpg
new file mode 100644
index 0000000..4b56c06
Binary files /dev/null and b/src/writeCs/cs序列化1.jpg differ
diff --git a/src/writeCs/cs序列化2.png b/src/writeCs/cs序列化2.png
new file mode 100644
index 0000000..b11a219
Binary files /dev/null and b/src/writeCs/cs序列化2.png differ
diff --git a/src/writeCs/gCsCode.cs b/src/writeCs/gCsCode.cs
index f407563..447ea52 100644
--- a/src/writeCs/gCsCode.cs
+++ b/src/writeCs/gCsCode.cs
@@ -190,4 +190,19 @@ namespace ProtoMsg
             }
         }
     }
-}
\ No newline at end of file
+}
+
+        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);
+        }
\ No newline at end of file
diff --git a/src/writeCs/gCsField.erl b/src/writeCs/gCsField.erl
index 2cdac94..8806f1d 100644
--- a/src/writeCs/gCsField.erl
+++ b/src/writeCs/gCsField.erl
@@ -15,85 +15,36 @@
    , <<"double">>
 ]).
 
--define(TypeList, [
-   <<"bool">>
-   , <<"int8">>
-   , <<"uint8">>
-   , <<"int16">>
-   , <<"uint16">>
-   , <<"int32">>
-   , <<"uint32">>
-   , <<"int64">>
-   , <<"uint64">>
-   , <<"integer">>
-   , <<"number">>
-   , <<"float">>
-   , <<"double">>
-   , <<"string">>
-]).
-
 -define(TypeValue, [
-   {<<"bool">>, <<"false">>, <<"boolean()">>}
-   , {<<"int8">>, <<"0">>, <<"int8()">>}
-   , {<<"uint8">>, <<"0">>, <<"uint8()">>}
-   , {<<"int16">>, <<"0">>, <<"int16()">>}
-   , {<<"uint16">>, <<"0">>, <<"uint16()">>}
-   , {<<"int32">>, <<"0">>, <<"int32()">>}
-   , {<<"uint32">>, <<"0">>, <<"uint32()">>}
-   , {<<"int64">>, <<"0">>, <<"int64()">>}
-   , {<<"uint64">>, <<"0">>, <<"uint64()">>}
-   , {<<"integer">>, <<"0">>, <<"integer()">>}
-   , {<<"number">>, <<"0">>, <<"number()">>}
-   , {<<"float">>, <<"0.0">>, <<"float()">>}
-   , {<<"double">>, <<"0.0">>, <<"double()">>}
-   , {<<"string">>, <<"\"\"">>, <<"string()">>}
-]).
+   {<<"bool">>, <<"bool">>}
+   , {<<"int8">>, <<"sbyte">>}
+   , {<<"uint8">>, <<"byte">>}
+   , {<<"int16">>, <<"short">>}
+   , {<<"uint16">>, <<"ushort">>}
+   , {<<"int32">>, <<"int">>}
+   , {<<"uint32">>, <<"uint">>}
+   , {<<"int64">>, <<"long">>}
+   , {<<"uint64">>, <<"ulong">>}
+   , {<<"float">>, <<"float">>}
+   , {<<"double">>, <<"double">>}
+   , {<<"string">>, <<"string">>}
+   ]).
 
 builtRecStr({TypeStr, NameStr}) ->
    case lists:keyfind(TypeStr, 1, ?TypeValue) of
-      {TypeStr, DefValueStr, DefTypeStr} ->
-         <<NameStr/binary, " = ", DefValueStr/binary, " :: ", DefTypeStr/binary, "\n">>;
+      {TypeStr, CSTypeStr} ->
+         <<"\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, _DefSubValueStr, DefSubTypeStr} ->
-                     <<NameStr/binary, " = [] :: [", DefSubTypeStr/binary, "]\n">>;
+                  {SubTypeStr, SubCSTypeStr} ->
+                     <<"\t\tpublic List<", SubCSTypeStr/binary, "> ", NameStr/binary, ";\n">>;
                   _ ->
-                     <<NameStr/binary, " = [] :: [#", SubTypeStr/binary, "{}]\n">>
+                     <<"\t\tpublic List<", SubTypeStr/binary, "> ", NameStr/binary, ";\n">>
                end;
             _ ->
-               <<NameStr/binary, " = undefined :: #", TypeStr/binary, "{}\n">>
+               <<"\t\tpublic ", TypeStr/binary, " ", NameStr/binary, ";\n">>
          end
    end.
-
-builtPackStr(TypeStr) ->
-   case lists:member(TypeStr, ?TypeList) of
-      true ->
-         <<"?", TypeStr/binary, "(">>;
-      _ ->
-         case TypeStr of
-            <<"list[", LeftStr/binary>> ->
-               [SubTypeStr | _] = re:split(LeftStr, <<"\\]">>, [{return, binary}]),
-               SubStr =
-                  case lists:member(SubTypeStr, ?TypeList) of
-                     true ->
-                        SubTypeStr;
-                     _ ->
-                        <<"record">>
-                  end,
-               <<"?list_", SubStr/binary, "(">>;
-            _ ->
-               <<"?record(">>
-         end
-   end.
-
-isBaseType(TypeStr) ->
-   lists:member(TypeStr, ?TypeList).
-
-
-
-
-
-
diff --git a/src/writeCs/gCsGen.erl b/src/writeCs/gCsGen.erl
index ce1ac71..45707c5 100644
--- a/src/writeCs/gCsGen.erl
+++ b/src/writeCs/gCsGen.erl
@@ -1,22 +1,35 @@
 -module(gCsGen).
--include("genDef.hrl").
 
 -export([
    genCs/4
 ]).
 
 protoHeader() ->
-<<"using System;
+   <<"using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Data;
 using System.IO;
 
-namespace ProtoMsg
+namespace GenProto
 {
-    public static class Protocol
+    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,
@@ -47,7 +60,7 @@ namespace ProtoMsg
                 float => BasicTypeEnum.Float,
                 double => BasicTypeEnum.Double,
                 string => BasicTypeEnum.String,
-                _ => throw new InvalidOperationException($\"unexpect type: {value.GetType().FullName}\")
+                _ => BasicTypeEnum.Custom,
             };
         }
 
@@ -92,12 +105,32 @@ namespace ProtoMsg
                     binaryWriter.Write(stringValue);
                     break;
                 default:
-                    throw new InvalidOperationException($\"unexpect type: {value.GetType().FullName}\");
+                {
+                    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<T>(this BinaryWriter binaryWriter, IList<T> list)
+        public static void WriteList(this BinaryWriter binaryWriter, IList list)
         {
             var length = (ushort) (list?.Count ?? 0);
             binaryWriter.Write(length);
@@ -117,18 +150,102 @@ namespace ProtoMsg
             }
         }
 
-        public static void ReadList(this BinaryReader binaryReader, out IList list)
+        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)
             {
-                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)
                 {
@@ -192,581 +309,98 @@ namespace ProtoMsg
                         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 ArgumentOutOfRangeException();
+                        throw new InvalidOperationException();
                 }
             }
+
+            outList = list as List<T>;
         }
     }">>.
 
 protoEnd() ->
    <<"}">>.
 
-genMsgHrl([], _Index, _Len, HrlBinStr) ->
-   HrlBinStr;
-genMsgHrl([FieldInfo | FieldList], Index, Len, HrlBinStr) ->
-   TemStr =
-      case Index of
-         Len ->
-            <<"">>;
-         _ ->
-            <<", ">>
-      end,
-   RecStr = <<TemStr/binary, (gErlField:builtRecStr(FieldInfo))/binary, (case Index == 1 of true -> <<"">>; _ -> <<"\t">> end)/binary>>,
-   genMsgHrl(FieldList, Index - 1, Len, <<HrlBinStr/binary, RecStr/binary>>).
-
-spellHead([], _Index, HeadBinStr) ->
-   HeadBinStr;
-spellHead([_FieldInfo | FieldList], Index, HeadBinStr) ->
-   spellHead(FieldList, Index + 1, <<HeadBinStr/binary, ", V", (integer_to_binary(Index))/binary>>).
-
-spellBody([], _Index, BodyBinStr) ->
-   BodyBinStr;
-spellBody([{FieldType, _FieldName}], Index, BodyBinStr) ->
-   TemV = <<"V", (integer_to_binary(Index))/binary>>,
-   <<BodyBinStr/binary, (gErlField:builtPackStr(FieldType))/binary, TemV/binary, ")">>;
-spellBody([{FieldType, _FieldName} | FieldList], Index, BodyBinStr) ->
-   TemV = <<"V", (integer_to_binary(Index))/binary>>,
-   NewBodyBinStr = <<BodyBinStr/binary, (gErlField:builtPackStr(FieldType))/binary, TemV/binary, "), ">>,
-   spellBody(FieldList, Index + 1, NewBodyBinStr).
-
-spellErrCodeHrl([], ErrBinStr) ->
-   ErrBinStr;
-spellErrCodeHrl([{ErrName, ErrCodeId, ComDesc} | SortedErrList], ErrBinStr) ->
-   ErrStr = <<"-define(", ErrName/binary, ", ", (integer_to_binary(ErrCodeId))/binary, ").\t\t%% ", ComDesc/binary, "\n">>,
-   spellErrCodeHrl(SortedErrList, <<ErrBinStr/binary, ErrStr/binary>>).
-
-genEncodeRec({MsgName, MsgId, FieldList}, IsForBin) ->
-   FieldLen = length(FieldList),
-   TemStr = spellHead(FieldList, 1, <<"">>),
-   HeadStr =
-      case IsForBin of
-         true ->
-            <<"encodeIol(", MsgName/binary, ", {_", TemStr/binary, "}) ->\n\t">>;
-         _ ->
-            <<"subEncode(", MsgName/binary, ", {_", TemStr/binary, "}) ->\n\t">>
-      end,
+spellClassHead(MsgName, MsgId) ->
+   <<"\tpublic class ", MsgName/binary, " : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<", MsgName/binary, ">\n\t{\n\t\tpublic const int ProtoId = ", (integer_to_binary(MsgId))/binary, ";\n">>.
 
-   BodyStr = spellBody(FieldList, 1, <<"">>),
-   case IsForBin of
-      true ->
-         case FieldLen > 0 of
-            true ->
-               <<HeadStr/binary, "[<<", (integer_to_binary(MsgId))/binary, ":16/big-unsigned>>, ", BodyStr/binary, "];\n">>;
-            _ ->
-               <<HeadStr/binary, "[<<", (integer_to_binary(MsgId))/binary, ":16/big-unsigned>>];\n">>
-         end;
-      _ ->
-         case FieldLen > 0 of
-            true ->
-               <<HeadStr/binary, "[", BodyStr/binary, "];\n">>;
-            _ ->
-               <<HeadStr/binary, "[];\n">>
-         end
-   end.
-
-resetPd() ->
-   erlang:put(pd_v, 0),
-   erlang:put(pd_len, 0),
-   erlang:put(pd_bool, 0),
-   erlang:put(pd_leftBin, 0),
-   erlang:put(pd_intBits, 0),
-   erlang:put(pd_numBits, 0),
-   erlang:put(pd_listBin, 0),
-   erlang:put(pd_isUndef, 0),
-   erlang:put(pd_isCalcRefSize, 0).
-
-getIndexStr(Type) ->
-   Index = erlang:get(Type),
-   integer_to_binary(Index).
-
-useIndexStr(Type) ->
-   Index = erlang:get(Type) + 1,
-   erlang:put(Type, Index),
-   integer_to_binary(Index).
-
-isCalcRefSize() ->
-   erlang:get(pd_isCalcRefSize) > 0.
-
-initSubRec() ->
-   erlang:put(pd_subRec, []).
-
-getSubRec() ->
-   erlang:get(pd_subRec).
-
-initSubSubRec() ->
-   erlang:put(pd_subSubRec, []).
-
-getSubSubRec() ->
-   erlang:get(pd_subSubRec).
-
-addSubRec({MsgName, _MsgId, _FieldList} = Info, IsForBin) when IsForBin ->
-   OldList = erlang:get(pd_subRec),
-   case lists:keyfind(MsgName, 1, OldList) of
-      false ->
-         erlang:put(pd_subRec, [Info | OldList]);
-      _ ->
-         ignore
-   end;
-addSubRec({MsgName, _MsgId, _FieldList} = Info, _IsForBin) ->
-   OldAllList = erlang:get(pd_subRec),
-   case lists:keyfind(MsgName, 1, OldAllList) of
-      false ->
-         erlang:put(pd_subRec, [Info | OldAllList]),
-         OldSubList = erlang:get(pd_subSubRec),
-         case lists:keyfind(MsgName, 1, OldSubList) of
-            false ->
-               erlang:put(pd_subSubRec, [Info | OldSubList]);
-            _ ->
-               ignore
-         end;
-      _ ->
-         ignore
-   end.
-
-genDecodeBin({MsgName, MsgId, FieldList}, SortedSProtoList, IsForBin) ->
-   FieldLen = length(FieldList),
-   case IsForBin of
-      true ->
-         HeadStr = <<"decodeBin(", (integer_to_binary(MsgId))/binary, ", LeftBin", (getIndexStr(pd_leftBin))/binary, ") ->\n">>;
-      _ ->
-         HeadStr = <<"decodeRec(", (integer_to_binary(MsgId))/binary, ", LeftBin", (getIndexStr(pd_leftBin))/binary, ") ->\n">>
-   end,
+spellClassMember(FieldList) ->
+   <<<<(gCsField:builtRecStr(OneTypeName))/binary>> || OneTypeName <- FieldList>>.
 
-   FunBody =
-      fun({FieldType, _FieldName}, {IsSimple, StrAcc}) ->
-         case FieldType of
-            <<"bool">> ->
-               TemStr =
-                  case IsSimple of
-                     true ->
-                        GetLeftBinStr1 = getIndexStr(pd_leftBin),
-                        UseLeftBinStr1 = useIndexStr(pd_leftBin),
-                        <<"LeftBin", UseLeftBinStr1/binary, "/binary>> = LeftBin", GetLeftBinStr1/binary, ",\n">>;
-                     _ ->
-                        <<"">>
-                  end,
-               UseBoolStr = useIndexStr(pd_bool),
-               GetLeftBinStr2 = getIndexStr(pd_leftBin),
-               UseLeftBinStr2 = useIndexStr(pd_leftBin),
-               BoolStr = <<"\t<<Bool", UseBoolStr/binary, ":8/big-unsigned, LeftBin", UseLeftBinStr2/binary, "/binary>> = LeftBin", GetLeftBinStr2/binary, ",\n">>,
-               UseVStr = useIndexStr(pd_v),
-               VStr = <<"\tV", UseVStr/binary, " = Bool", UseBoolStr/binary, " =:= 1,\n">>,
-               {false, <<StrAcc/binary, TemStr/binary, BoolStr/binary, VStr/binary>>};
-            <<"int8">> ->
-               TemStr =
-                  case IsSimple of
-                     true ->
-                        UseVStr = useIndexStr(pd_v),
-                        <<"V", UseVStr/binary, ":8/big-signed, ">>;
-                     _ ->
-                        UseVStr = useIndexStr(pd_v),
-                        <<"\t<<V", UseVStr/binary, ":8/big-signed, ">>
-                  end,
-               {true, <<StrAcc/binary, TemStr/binary>>};
-            <<"uint8">> ->
-               TemStr =
-                  case IsSimple of
-                     true ->
-                        UseVStr = useIndexStr(pd_v),
-                        <<"V", UseVStr/binary, ":8/big-unsigned, ">>;
-                     _ ->
-                        UseVStr = useIndexStr(pd_v),
-                        <<"\t<<V", UseVStr/binary, ":8/big-unsigned, ">>
-                  end,
-               {true, <<StrAcc/binary, TemStr/binary>>};
-            <<"int16">> ->
-               TemStr =
-                  case IsSimple of
-                     true ->
-                        UseVStr = useIndexStr(pd_v),
-                        <<"V", UseVStr/binary, ":16/big-signed, ">>;
-                     _ ->
-                        UseVStr = useIndexStr(pd_v),
-                        <<"\t<<V", UseVStr/binary, ":16/big-signed, ">>
-                  end,
-               {true, <<StrAcc/binary, TemStr/binary>>};
-            <<"uint16">> ->
-               TemStr =
-                  case IsSimple of
-                     true ->
-                        UseVStr = useIndexStr(pd_v),
-                        <<"V", UseVStr/binary, ":16/big-unsigned, ">>;
-                     _ ->
-                        UseVStr = useIndexStr(pd_v),
-                        <<"\t<<V", UseVStr/binary, ":16/big-unsigned, ">>
-                  end,
-               {true, <<StrAcc/binary, TemStr/binary>>};
-            <<"int32">> ->
-               TemStr =
-                  case IsSimple of
-                     true ->
-                        UseVStr = useIndexStr(pd_v),
-                        <<"V", UseVStr/binary, ":32/big-signed, ">>;
-                     _ ->
-                        UseVStr = useIndexStr(pd_v),
-                        <<"\t<<V", UseVStr/binary, ":32/big-signed, ">>
-                  end,
-               {true, <<StrAcc/binary, TemStr/binary>>};
-            <<"uint32">> ->
-               TemStr =
-                  case IsSimple of
-                     true ->
-                        UseVStr = useIndexStr(pd_v),
-                        <<"V", UseVStr/binary, ":32/big-unsigned, ">>;
-                     _ ->
-                        UseVStr = useIndexStr(pd_v),
-                        <<"\t<<V", UseVStr/binary, ":32/big-unsigned, ">>
-                  end,
-               {true, <<StrAcc/binary, TemStr/binary>>};
-            <<"int64">> ->
-               TemStr =
-                  case IsSimple of
-                     true ->
-                        UseVStr = useIndexStr(pd_v),
-                        <<"V", UseVStr/binary, ":64/big-signed, ">>;
-                     _ ->
-                        UseVStr = useIndexStr(pd_v),
-                        <<"\t<<V", UseVStr/binary, ":64/big-signed, ">>
-                  end,
-               {true, <<StrAcc/binary, TemStr/binary>>};
-            <<"uint64">> ->
-               TemStr =
-                  case IsSimple of
-                     true ->
-                        UseVStr = useIndexStr(pd_v),
-                        <<"V", UseVStr/binary, ":64/big-unsigned, ">>;
-                     _ ->
-                        UseVStr = useIndexStr(pd_v),
-                        <<"\t<<V", UseVStr/binary, ":64/big-unsigned, ">>
-                  end,
-               {true, <<StrAcc/binary, TemStr/binary>>};
-            <<"float">> ->
-               TemStr =
-                  case IsSimple of
-                     true ->
-                        UseVStr = useIndexStr(pd_v),
-                        <<"V", UseVStr/binary, ":32/big-float, ">>;
-                     _ ->
-                        UseVStr = useIndexStr(pd_v),
-                        <<"\t<<V", UseVStr/binary, ":32/big-float, ">>
-                  end,
-               {true, <<StrAcc/binary, TemStr/binary>>};
-            <<"double">> ->
-               TemStr =
-                  case IsSimple of
-                     true ->
-                        UseVStr = useIndexStr(pd_v),
-                        <<"V", UseVStr/binary, ":64/big-float, ">>;
-                     _ ->
-                        UseVStr = useIndexStr(pd_v),
-                        <<"\t<<V", UseVStr/binary, ":64/big-float, ">>
-                  end,
-               {true, <<StrAcc/binary, TemStr/binary>>};
-            <<"string">> ->
-               TemStr =
-                  case IsSimple of
-                     true ->
-                        GetLeftBinStr1 = getIndexStr(pd_leftBin),
-                        UseLeftBinStr1 = useIndexStr(pd_leftBin),
-                        <<"LeftBin", UseLeftBinStr1/binary, "/binary>> = LeftBin", GetLeftBinStr1/binary, ",\n">>;
-                     _ ->
-                        <<"">>
-                  end,
-               UseLenStr = useIndexStr(pd_len),
-               GetLeftBinStr2 = getIndexStr(pd_leftBin),
-               UseLeftBinStr2 = useIndexStr(pd_leftBin),
-               UseVStr = useIndexStr(pd_v),
-               RefSizeStr =
-                  case isCalcRefSize() of
-                     false ->
-                        useIndexStr(pd_isCalcRefSize),
-                        <<"\tRefSize = binary:referenced_byte_size(LeftBin0),\n">>;
-                     _ ->
-                        <<"">>
-                  end,
-               StrStr = <<"\t<<Len", UseLenStr/binary, ":16/big-unsigned, TemStrV", UseVStr/binary, ":Len", UseLenStr/binary, "/binary, LeftBin", UseLeftBinStr2/binary, "/binary>> = LeftBin", GetLeftBinStr2/binary, ",\n">>,
-               VStr = <<"\tcase Len", UseLenStr/binary, " < ?BinaryShareSize of\n\t\t",
-                  "true ->\n\t\t\tV", UseVStr/binary, " = TemStrV", UseVStr/binary, ";\n\t\t",
-                  "_ ->\n\t\t\tcase RefSize / Len", UseLenStr/binary, " > ?BinaryCopyRatio of\n\t\t\t\t",
-                  "true ->\n\t\t\t\t\tV", UseVStr/binary, " = binary:copy(TemStrV", UseVStr/binary, ");\n\t\t\t\t",
-                  "_ ->\n\t\t\t\t\tV", UseVStr/binary, " = TemStrV", UseVStr/binary, "\n\t\t\tend\n\tend,\n">>,
-               {false, <<StrAcc/binary, TemStr/binary, RefSizeStr/binary, StrStr/binary, VStr/binary>>};
-            <<"integer">> ->
-               TemStr =
-                  case IsSimple of
-                     true ->
-                        UseVStr = useIndexStr(pd_v),
-                        UseIntBitsStr = useIndexStr(pd_intBits),
-                        <<"IntBits", UseIntBitsStr/binary, ":8, V", UseVStr/binary, ":IntBits", UseIntBitsStr/binary, "/big-signed, ">>;
-                     _ ->
-                        UseVStr = useIndexStr(pd_v),
-                        UseIntBitsStr = useIndexStr(pd_intBits),
-                        <<"\t<<IntBits", UseIntBitsStr/binary, ":8, V", UseVStr/binary, ":IntBits", UseIntBitsStr/binary, "/big-signed, ">>
-                  end,
-               {true, <<StrAcc/binary, TemStr/binary>>};
-            <<"number">> ->
-               TemStr =
-                  case IsSimple of
-                     true ->
-                        GetLeftBinStr1 = getIndexStr(pd_leftBin),
-                        UseLeftBinStr1 = useIndexStr(pd_leftBin),
-                        <<"LeftBin", UseLeftBinStr1/binary, "/binary>> = LeftBin", GetLeftBinStr1/binary, ",\n">>;
-                     _ ->
-                        <<"">>
-                  end,
-               UseNumBitsStr = useIndexStr(pd_numBits),
-               GetLeftBinStr2 = getIndexStr(pd_leftBin),
-               UseLeftBinStr2 = useIndexStr(pd_leftBin),
-               NumStr = <<"\t<<NumBits", UseNumBitsStr/binary, ":8, LeftBin", UseLeftBinStr2/binary, "/binary>> = LeftBin", GetLeftBinStr2/binary, ",\n">>,
-               UseVStr = useIndexStr(pd_v),
-               UseLeftBinStr3 = useIndexStr(pd_leftBin),
-               VStr =
-                  <<"\tcase NumBits", UseNumBitsStr/binary, " of\n\t\t33-> \n\t\t\t<<V", UseVStr/binary, ":32/big-float, LeftBin", UseLeftBinStr3/binary,
-                  "/binary>> = LeftBin", UseLeftBinStr2/binary, ";\n\t\t65 ->\n\t\t\t<<V", UseVStr/binary, ":64/big-float, LeftBin", UseLeftBinStr3/binary,
-                  "/binary>> = LeftBin", UseLeftBinStr2/binary, ";\n\t\t_ ->\n\t\t\t<<V", UseVStr/binary, ":NumBits", UseNumBitsStr/binary, "/big-signed, LeftBin", UseLeftBinStr3/binary,
-                  "/binary>> = LeftBin", UseLeftBinStr2/binary, "\n\tend,\n">>,
-               {false, <<StrAcc/binary, TemStr/binary, NumStr/binary, VStr/binary>>};
-            <<"list[", LeftStr/binary>> ->
-               [SubTypeStr | _] = re:split(LeftStr, <<"\\]">>, [{return, binary}]),
-               TemStr =
-                  case IsSimple of
-                     true ->
-                        GetLeftBinStr1 = getIndexStr(pd_leftBin),
-                        UseLeftBinStr1 = useIndexStr(pd_leftBin),
-                        <<"LeftBin", UseLeftBinStr1/binary, "/binary>> = LeftBin", GetLeftBinStr1/binary, ",\n">>;
-                     _ ->
-                        <<"">>
-                  end,
-
-               UseLenStr = useIndexStr(pd_len),
-               GetLeftBinStr2 = getIndexStr(pd_leftBin),
-               UseLeftBinStr2 = useIndexStr(pd_leftBin),
-               UseVStr = useIndexStr(pd_v),
-               UseListBinStr = useIndexStr(pd_listBin),
-               GetLeftBinStr3 = getIndexStr(pd_leftBin),
-               UseLeftBinStr3 = useIndexStr(pd_leftBin),
-               LenStr = <<"\t<<Len", UseLenStr/binary, ":16/big-unsigned, LeftBin", UseLeftBinStr2/binary, "/binary>> = LeftBin", GetLeftBinStr2/binary, ",\n">>,
-               DeListStr =
-                  case SubTypeStr of
-                     <<"bool">> ->
-                        ListBinStr = <<"\t<<ListBin", UseListBinStr/binary, ":Len", UseLenStr/binary, "/big-binary-unit:8, LeftBin", UseLeftBinStr3/binary, "/binary>> = LeftBin", GetLeftBinStr3/binary, ",\n">>,
-                        VStr = <<"\tV", UseVStr/binary, " = [TemV =:= 1 || <<TemV:8/big-unsigned>> <= ListBin", UseListBinStr/binary, "],\n">>,
-                        <<ListBinStr/binary, VStr/binary>>;
-                     <<"int8">> ->
-                        ListBinStr = <<"\t<<ListBin", UseListBinStr/binary, ":Len", UseLenStr/binary, "/big-binary-unit:8, LeftBin", UseLeftBinStr3/binary, "/binary>> = LeftBin", GetLeftBinStr3/binary, ",\n">>,
-                        VStr = <<"\tV", UseVStr/binary, " = [TemV || <<TemV:8/big-signed>> <= ListBin", UseListBinStr/binary, "],\n">>,
-                        <<ListBinStr/binary, VStr/binary>>;
-                     <<"uint8">> ->
-                        ListBinStr = <<"\t<<ListBin", UseListBinStr/binary, ":Len", UseLenStr/binary, "/big-binary-unit:8, LeftBin", UseLeftBinStr3/binary, "/binary>> = LeftBin", GetLeftBinStr3/binary, ",\n">>,
-                        VStr = <<"\tV", UseVStr/binary, " = [TemV || <<TemV:8/big-unsigned>> <= ListBin", UseListBinStr/binary, "],\n">>,
-                        <<ListBinStr/binary, VStr/binary>>;
-                     <<"int16">> ->
-                        ListBinStr = <<"\t<<ListBin", UseListBinStr/binary, ":Len", UseLenStr/binary, "/big-binary-unit:16, LeftBin", UseLeftBinStr3/binary, "/binary>> = LeftBin", GetLeftBinStr3/binary, ",\n">>,
-                        VStr = <<"\tV", UseVStr/binary, " = [TemV || <<TemV:16/big-signed>> <= ListBin", UseListBinStr/binary, "],\n">>,
-                        <<ListBinStr/binary, VStr/binary>>;
-                     <<"uint16">> ->
-                        ListBinStr = <<"\t<<ListBin", UseListBinStr/binary, ":Len", UseLenStr/binary, "/big-binary-unit:16, LeftBin", UseLeftBinStr3/binary, "/binary>> = LeftBin", GetLeftBinStr3/binary, ",\n">>,
-                        VStr = <<"\tV", UseVStr/binary, " = [TemV || <<TemV:16/big-unsigned>> <= ListBin", UseListBinStr/binary, "],\n">>,
-                        <<ListBinStr/binary, VStr/binary>>;
-                     <<"int32">> ->
-                        ListBinStr = <<"\t<<ListBin", UseListBinStr/binary, ":Len", UseLenStr/binary, "/big-binary-unit:32, LeftBin", UseLeftBinStr3/binary, "/binary>> = LeftBin", GetLeftBinStr3/binary, ",\n">>,
-                        VStr = <<"\tV", UseVStr/binary, " = [TemV || <<TemV:32/big-signed>> <= ListBin", UseListBinStr/binary, "],\n">>,
-                        <<ListBinStr/binary, VStr/binary>>;
-                     <<"uint32">> ->
-                        ListBinStr = <<"\t<<ListBin", UseListBinStr/binary, ":Len", UseLenStr/binary, "/big-binary-unit:32, LeftBin", UseLeftBinStr3/binary, "/binary>> = LeftBin", GetLeftBinStr3/binary, ",\n">>,
-                        VStr = <<"\tV", UseVStr/binary, " = [TemV || <<TemV:32/big-unsigned>> <= ListBin", UseListBinStr/binary, "],\n">>,
-                        <<ListBinStr/binary, VStr/binary>>;
-                     <<"int64">> ->
-                        ListBinStr = <<"\t<<ListBin", UseListBinStr/binary, ":Len", UseLenStr/binary, "/big-binary-unit:64, LeftBin", UseLeftBinStr3/binary, "/binary>> = LeftBin", GetLeftBinStr3/binary, ",\n">>,
-                        VStr = <<"\tV", UseVStr/binary, " = [TemV || <<TemV:64/big-signed>> <= ListBin", UseListBinStr/binary, "],\n">>,
-                        <<ListBinStr/binary, VStr/binary>>;
-                     <<"uint64">> ->
-                        ListBinStr = <<"\t<<ListBin", UseListBinStr/binary, ":Len", UseLenStr/binary, "/big-binary-unit:64, LeftBin", UseLeftBinStr3/binary, "/binary>> = LeftBin", GetLeftBinStr3/binary, ",\n">>,
-                        VStr = <<"\tV", UseVStr/binary, " = [TemV || <<TemV:64/big-unsigned>> <= ListBin", UseListBinStr/binary, "],\n">>,
-                        <<ListBinStr/binary, VStr/binary>>;
-                     <<"integer">> ->
-                        <<"\t{V", UseVStr/binary, ", LeftBin", UseLeftBinStr3/binary, "} = deIntegerList(Len", UseLenStr/binary, ", LeftBin", GetLeftBinStr3/binary, ", []),\n">>;
-                     <<"number">> ->
-                        <<"\t{V", UseVStr/binary, ", LeftBin", UseLeftBinStr3/binary, "} = deNumberList(Len", UseLenStr/binary, ", LeftBin", GetLeftBinStr3/binary, ", []),\n">>;
-                     <<"float">> ->
-                        ListBinStr = <<"\t<<ListBin", UseListBinStr/binary, ":Len", UseLenStr/binary, "/big-binary-unit:32, LeftBin", UseLeftBinStr3/binary, "/binary>> = LeftBin", GetLeftBinStr3/binary, ",\n">>,
-                        VStr = <<"\tV", UseVStr/binary, " = [TemV || <<TemV:32/big-float>> <= ListBin", UseListBinStr/binary, "],\n">>,
-                        <<ListBinStr/binary, VStr/binary>>;
-                     <<"double">> ->
-                        ListBinStr = <<"\t<<ListBin", UseListBinStr/binary, ":Len", UseLenStr/binary, "/big-binary-unit:64, LeftBin", UseLeftBinStr3/binary, "/binary>> = LeftBin", GetLeftBinStr3/binary, ",\n">>,
-                        VStr = <<"\tV", UseVStr/binary, " = [TemV || <<TemV:64/big-float>> <= ListBin", UseListBinStr/binary, "],\n">>,
-                        <<ListBinStr/binary, VStr/binary>>;
-                     <<"string">> ->
-                        case isCalcRefSize() of
-                           true ->
-                              <<"\t{V", UseVStr/binary, ", LeftBin", UseLeftBinStr3/binary, "} = deStringList(Len", UseLenStr/binary, ", LeftBin", GetLeftBinStr3/binary, ", RefSize, []),\n">>;
-                           _ ->
-                              useIndexStr(pd_isCalcRefSize),
-                              RefSizeStr = <<"\tRefSize = binary:referenced_byte_size(LeftBin0),\n">>,
-                              VStr = <<"\t{V", UseVStr/binary, ", LeftBin", UseLeftBinStr3/binary, "} = deStringList(Len", UseLenStr/binary, ", LeftBin", GetLeftBinStr3/binary, ", RefSize, []),\n">>,
-                              <<RefSizeStr/binary, VStr/binary>>
-                        end;
-                     ListRecord ->
-                        case lists:keyfind(ListRecord, 1, SortedSProtoList) of
-                           {ListRecord, ListMsgId, _} = RecordInfo ->
-                              addSubRec(RecordInfo, IsForBin),
-                              <<"\t{V", UseVStr/binary, ", LeftBin", UseLeftBinStr3/binary, "} = deRecordList(Len", UseLenStr/binary, ", ", (integer_to_binary(ListMsgId))/binary, ", LeftBin", GetLeftBinStr3/binary, ", []),\n">>;
-                           _ ->
-                              io:format("this an Record undefined :~p~n", [ListRecord]),
-                              throw(record_undefined)
-                        end
-                  end,
-               {false, <<StrAcc/binary, TemStr/binary, LenStr/binary, DeListStr/binary>>};
-            OtherRecord ->
-               TemStr =
-                  case IsSimple of
-                     true ->
-                        GetLeftBinStr1 = getIndexStr(pd_leftBin),
-                        UseLeftBinStr1 = useIndexStr(pd_leftBin),
-                        <<"LeftBin", UseLeftBinStr1/binary, "/binary>> = LeftBin", GetLeftBinStr1/binary, ",\n">>;
-                     _ ->
-                        <<"">>
-                  end,
-               UseIsUndefStr = useIndexStr(pd_isUndef),
-               GetLeftBinStr2 = getIndexStr(pd_leftBin),
-               UseLeftBinStr2 = useIndexStr(pd_leftBin),
-               IsStr = <<"\t<<IsUndef", UseIsUndefStr/binary, ":8/big-unsigned, LeftBin", UseLeftBinStr2/binary, "/binary>> = LeftBin", GetLeftBinStr2/binary, ",\n">>,
-               UseVStr = useIndexStr(pd_v),
-               UseLeftBinStr3 = useIndexStr(pd_leftBin),
-               case lists:keyfind(OtherRecord, 1, SortedSProtoList) of
-                  {OtherRecord, OtherMsgId, _} = RecordInfo ->
-                     addSubRec(RecordInfo, IsForBin),
-                     VStr = <<"\tcase IsUndef", UseIsUndefStr/binary, " of\n\t\t0 ->\n\t\t\tV", UseVStr/binary, " = undefined,\n\t\t\tLeftBin", UseLeftBinStr3/binary, " = LeftBin", UseLeftBinStr2/binary,
-                     " ;\n\t\t_ ->\n\t\t\t{V", UseVStr/binary, ", LeftBin", UseLeftBinStr3/binary, "} = ", "decodeRec(", (integer_to_binary(OtherMsgId))/binary, ", LeftBin", UseLeftBinStr2/binary, ")\n\tend,\n">>,
-                     {false, <<StrAcc/binary, TemStr/binary, IsStr/binary, VStr/binary>>};
-                  _ ->
-                     io:format("this an Record undefined :~p~n", [OtherRecord]),
-                     throw(record_undefined)
-               end
-         end
-      end,
+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\tSerialize(binaryWriter);
+\t\t\treturn memoryStream.ToArray();
+\t\t}
 
-   {LIsSimple, BodyStr} = lists:foldl(FunBody, {false, <<"">>}, FieldList),
-   LBodyStr =
-      case LIsSimple of
-         true ->
-            LGetLeftBinStr = getIndexStr(pd_leftBin),
-            LUseLeftBinStr = useIndexStr(pd_leftBin),
-            <<BodyStr/binary, "LeftBin", LUseLeftBinStr/binary, "/binary>> = LeftBin", LGetLeftBinStr/binary, ",\n">>;
-         _ ->
-            BodyStr
-      end,
+\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\tDeserialize(binaryReader);
+\t\t}\n">>.
 
-   RetStr =
-      case IsForBin of
-         true ->
-            MsgIndex = MsgId div ?MsgIdSegSize,
-            Handler = erlang:get(pd_handler),
-            {MsgIndex, ModName} = lists:keyfind(MsgIndex, 1, Handler),
-            HandleName = <<ModName/binary, "Her">>,
-            case FieldLen > 0 of
-               true ->
-                  FunRec =
-                     fun(N, Acc) ->
-                        <<Acc/binary, ", V", (integer_to_binary(N))/binary>>
-                     end,
-                  RecStr = lists:foldl(FunRec, <<"">>, lists:seq(1, FieldLen)),
-                  <<"\t{", HandleName/binary, ", ", MsgName/binary, ", {", MsgName/binary, RecStr/binary, "}};\n">>;
-               _ ->
-                  <<"\t{", HandleName/binary, ", ", MsgName/binary, ", {", MsgName/binary, "}};\n">>
-            end;
-         _ ->
-            case FieldLen > 0 of
-               true ->
-                  FunRec =
-                     fun(N, Acc) ->
-                        <<Acc/binary, ", V", (integer_to_binary(N))/binary>>
-                     end,
-                  RecStr = lists:foldl(FunRec, <<"">>, lists:seq(1, FieldLen)),
-                  <<"\tMsgRec = {", MsgName/binary, RecStr/binary, "},\n\t{MsgRec, LeftBin", (getIndexStr(pd_leftBin))/binary, "};\n">>;
-               _ ->
-                  <<"\t{{", MsgName/binary, "}, ", "<<>>};\n">>
-            end
-      end,
-   <<HeadStr/binary, LBodyStr/binary, RetStr/binary>>.
+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/binary, FunBody/binary, "\t\t}\n">>.
 
-genCs(SortedSProtoList, SortedErrList, HrlDir, ErlDir) ->
-   initSubRec(),
-   FunSpell =
-      fun({MsgName, MsgId, FieldList} = MsgInfo, {MsgHrlAcc, MsgEncodeAcc, MsgDecodeAcc, MsgIdAcc, MsgNameAcc}) ->
-         %% gen hrl str
-         Len = erlang:length(FieldList),
-         LastFieldStr = genMsgHrl(FieldList, Len, Len, <<"">>),
-         HrlStr = <<"-record(", MsgName/binary, ", {\n\t", LastFieldStr/binary, "}).\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>>,
+   <<FunHead/binary, FunBody/binary, "\t\t}\n">>.
 
-         %% gen getMsgId  getMsgType str
-         IdStr = <<"getMsgId(", MsgName/binary, ")-> ", (integer_to_binary(MsgId))/binary, ";\n">>,
-         NameStr = <<"getMsgName(", (integer_to_binary(MsgId))/binary, ")-> ", MsgName/binary, ";\n">>,
+spellClassEnd() ->
+   <<"\t}\n">>.
 
-         %% gen encodeRec Str
-         EncodeStr = genEncodeRec(MsgInfo, true),
+genCs(SortedSProtoList, _SortedErrList, _HrlDir, CSDir) ->
+   FunSpell =
+      fun({MsgName, MsgId, FieldList}, ClassBinAcc) ->
+         H = spellClassHead(MsgName, MsgId),
+         M = spellClassMember(FieldList),
+         DS = spellCalssDSTem(),
+         S = spellCalssSerialize(FieldList),
+         D = spellCalssDeserialize(FieldList),
+         E = spellClassEnd(),
+         <<ClassBinAcc/binary, H/binary, M/binary, DS/binary, S/binary, D/binary, E/binary>>
+      end,
+   LastClassBinAcc = lists:foldl(FunSpell, <<>>, SortedSProtoList),
 
-         %% gen decodeBin str
-         resetPd(),
-         DecodeStr = genDecodeBin(MsgInfo, SortedSProtoList, true),
+   %% todo error code
+   %% ErrCodeStr = spellErrCodeHrl(SortedErrList, <<>>),
 
-         {<<MsgHrlAcc/binary, HrlStr/binary>>, <<MsgEncodeAcc/binary, EncodeStr/binary>>, <<MsgDecodeAcc/binary, DecodeStr/binary>>, <<MsgIdAcc/binary, IdStr/binary>>, <<MsgNameAcc/binary, NameStr/binary>>}
-      end,
-   {MsgHrlStr, TMsgEncodeStr, TMsgDecodeStr, _TMsgIdStr, _TMsgNameStr} = lists:foldl(FunSpell, {<<>>, <<>>, <<>>, <<>>, <<>>}, SortedSProtoList),
-   MsgEncodeStr = <<TMsgEncodeStr/binary, "encodeIol(_, _) ->\n\t[].\n\n">>,
-   MsgDecodeStr = <<TMsgDecodeStr/binary, "decodeBin(_, _) ->\n\t{undefinedHer, undefined, {}}.\n\n">>,
-   _MsgIdStr = <<_TMsgIdStr/binary, "getMsgId(_) -> 0.\n\n">>,
-   _MsgNameStr = <<_TMsgNameStr/binary, "getMsgName(_) -> undefiend.\n\n">>,
-
-   ErrCodeStr = spellErrCodeHrl(SortedErrList, <<>>),
-
-   %% gen decodeRec str
-   SubRecList = getSubRec(),
-   initSubSubRec(),
-   SortedSubRecList = lists:sort(fun({_Name1, MessageId1, _FieldList1}, {_Name2, MessageId2, _FieldList2}) -> MessageId1 < MessageId2 end, SubRecList),
-   {MsgEncodeRecStr, MsgDecodeRecStr} = dealSubRec(SortedSubRecList, SortedSProtoList, <<"">>, <<"">>),
-
-   ErlHeaderStr = protoErlHeader(),
-   HrlHeaderStr = protoHrlHeader(),
-   OutputErlStr = <<ErlHeaderStr/binary, MsgEncodeRecStr/binary, MsgEncodeStr/binary, MsgDecodeRecStr/binary, MsgDecodeStr/binary>>,
-   OutputHrlStr = <<HrlHeaderStr/binary, ErrCodeStr/binary, "\n\n", MsgHrlStr/binary>>,
-   HrlFilename = do_write_hrl(HrlDir, protoMsg, OutputHrlStr),
-   ErlFilename = do_write_erl(ErlDir, protoMsg, OutputErlStr),
-
-   io:format("protoConvert hrl dir : ~s ~n", [HrlDir]),
-   io:format("protoConvert erl dir : ~s ~n", [ErlDir]),
-   io:format("protoConvert to hrl file ~s succ.~n", [HrlFilename]),
-   io:format("protoConvert to erl file ~s succ.~n", [ErlFilename]),
-   ok.
+   CSHeaderStr = protoHeader(),
+   CSEndStr = protoEnd(),
+   OutputHrlStr = <<CSHeaderStr/binary, LastClassBinAcc/binary, CSEndStr/binary>>,
+   CSFilename = do_write_cs(CSDir, protoMsg, OutputHrlStr),
 
-dealSubRec([], SortedSProtoList, SubEncodeAcc, SubDecodeAcc) ->
-   case getSubSubRec() of
-      [] ->
-         {<<SubEncodeAcc/binary, "subEncode(_, _) ->\n\t[].\n\n">>, <<SubDecodeAcc/binary, "decodeRec(_, _) ->\n\t{{}, <<>>}.\n\n">>};
-      NewAddList ->
-         initSubSubRec(),
-         SortedSubRecList = lists:sort(fun({_Name1, MessageId1, _FieldList1}, {_Name2, MessageId2, _FieldList2}) -> MessageId1 < MessageId2 end, NewAddList),
-         dealSubRec(SortedSubRecList, SortedSProtoList, SubEncodeAcc, SubDecodeAcc)
-   end;
-dealSubRec([MsgInfo | SubRecList], SortedSProtoList, SubEncodeAcc, SubDecodeAcc) ->
-   EncodeStr = genEncodeRec(MsgInfo, false),
-   resetPd(),
-   DecodeStr = genDecodeBin(MsgInfo, SortedSProtoList, false),
-   dealSubRec(SubRecList, SortedSProtoList, <<SubEncodeAcc/binary, EncodeStr/binary>>, <<SubDecodeAcc/binary, DecodeStr/binary>>).
-
-do_write_hrl(OutDir, Mod, BinStr) ->
-   Filename = filename:join([OutDir, atom_to_list(Mod) ++ ".hrl"]),
-   ok = file:write_file(Filename, BinStr),
-   Filename.
+   io:format("protoConvert erl dir : ~s ~n", [CSDir]),
+   io:format("protoConvert to erl file ~s succ.~n", [CSFilename]),
+   ok.
 
-do_write_erl(OutDir, Mod, BinStr) ->
-   Filename = filename:join([OutDir, atom_to_list(Mod) ++ ".erl"]),
+do_write_cs(OutDir, Mod, BinStr) ->
+   Filename = filename:join([OutDir, atom_to_list(Mod) ++ ".cs"]),
    case file:write_file(Filename, BinStr) of
       ok ->
          ok;
       _Ret ->
-         io:format("write to erl file error:~p ~n", [_Ret])
+         io:format("write to cs file error:~p ~n", [_Ret])
    end,
    Filename.
 
diff --git a/test/gen.sh b/test/gen.sh
index ac49ae1..ccae33e 100644
--- a/test/gen.sh
+++ b/test/gen.sh
@@ -1 +1 @@
-protoGen ../proto ./ ./
+genProto ../proto ./ ./
diff --git a/test/genProto b/test/genProto
index 3ee183b..6f34fff 100644
Binary files a/test/genProto and b/test/genProto differ
diff --git a/test/protoMsg.cs b/test/protoMsg.cs
new file mode 100644
index 0000000..5b2d169
--- /dev/null
+++ b/test/protoMsg.cs
@@ -0,0 +1,1654 @@
+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 test : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<test>
+	{
+		public const int ProtoId = 1;
+		public string aa;
+
+		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(aa);
+		}
+		public void Deserialize(BinaryReader 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 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(number);
+			binaryWriter.WriteValue(type);
+		}
+		public void Deserialize(BinaryReader 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 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(name);
+			binaryWriter.WriteValue(id);
+			binaryWriter.WriteValue(email);
+			binaryWriter.WriteValue(phone);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out name);
+			binaryReader.ReadValue(out id);
+			binaryReader.ReadValue(out email);
+			binaryReader.ReadValue(out phone);
+		}
+	}
+	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);
+			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(person);
+			binaryWriter.WriteValue(other);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out person);
+			binaryReader.ReadValue(out other);
+		}
+	}
+	public class union : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<union>
+	{
+		public const int ProtoId = 5;
+		public string test;
+		public int type;
+
+		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(test);
+			binaryWriter.WriteValue(type);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out test);
+			binaryReader.ReadValue(out type);
+		}
+	}
+	public class tbool : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tbool>
+	{
+		public const int ProtoId = 6;
+		public bool bool;
+
+		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);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out bool);
+		}
+	}
+	public class tint8 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tint8>
+	{
+		public const int ProtoId = 7;
+		public sbyte int1;
+		public sbyte int2;
+
+		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(int1);
+			binaryWriter.WriteValue(int2);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+			binaryReader.ReadValue(out int2);
+		}
+	}
+	public class tuint8 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tuint8>
+	{
+		public const int ProtoId = 8;
+		public byte int1;
+		public byte int2;
+
+		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(int1);
+			binaryWriter.WriteValue(int2);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+			binaryReader.ReadValue(out int2);
+		}
+	}
+	public class tint16 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tint16>
+	{
+		public const int ProtoId = 9;
+		public short int1;
+		public short int2;
+
+		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(int1);
+			binaryWriter.WriteValue(int2);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+			binaryReader.ReadValue(out int2);
+		}
+	}
+	public class tuint16 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tuint16>
+	{
+		public const int ProtoId = 10;
+		public ushort int1;
+		public ushort int2;
+
+		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(int1);
+			binaryWriter.WriteValue(int2);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+			binaryReader.ReadValue(out int2);
+		}
+	}
+	public class tint32 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tint32>
+	{
+		public const int ProtoId = 11;
+		public int int1;
+		public int int2;
+		public int int3;
+		public int int4;
+		public int int5;
+		public int int6;
+		public int int7;
+		public int int8;
+		public int int9;
+		public int int10;
+
+		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(int1);
+			binaryWriter.WriteValue(int2);
+			binaryWriter.WriteValue(int3);
+			binaryWriter.WriteValue(int4);
+			binaryWriter.WriteValue(int5);
+			binaryWriter.WriteValue(int6);
+			binaryWriter.WriteValue(int7);
+			binaryWriter.WriteValue(int8);
+			binaryWriter.WriteValue(int9);
+			binaryWriter.WriteValue(int10);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+			binaryReader.ReadValue(out int2);
+			binaryReader.ReadValue(out int3);
+			binaryReader.ReadValue(out int4);
+			binaryReader.ReadValue(out int5);
+			binaryReader.ReadValue(out int6);
+			binaryReader.ReadValue(out int7);
+			binaryReader.ReadValue(out int8);
+			binaryReader.ReadValue(out int9);
+			binaryReader.ReadValue(out int10);
+		}
+	}
+	public class tuint32 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tuint32>
+	{
+		public const int ProtoId = 12;
+		public uint int1;
+		public uint int2;
+
+		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(int1);
+			binaryWriter.WriteValue(int2);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+			binaryReader.ReadValue(out int2);
+		}
+	}
+	public class tint64 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tint64>
+	{
+		public const int ProtoId = 13;
+		public long int1;
+		public long int2;
+
+		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(int1);
+			binaryWriter.WriteValue(int2);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+			binaryReader.ReadValue(out int2);
+		}
+	}
+	public class tuint64 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tuint64>
+	{
+		public const int ProtoId = 14;
+		public ulong int1;
+		public ulong int2;
+
+		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(int1);
+			binaryWriter.WriteValue(int2);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+			binaryReader.ReadValue(out int2);
+		}
+	}
+	public class tinteger : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tinteger>
+	{
+		public const int ProtoId = 15;
+		public integer int1;
+		public integer int2;
+		public integer int3;
+		public integer int4;
+		public integer int5;
+		public integer int6;
+		public integer int7;
+		public integer int8;
+
+		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(int1);
+			binaryWriter.WriteValue(int2);
+			binaryWriter.WriteValue(int3);
+			binaryWriter.WriteValue(int4);
+			binaryWriter.WriteValue(int5);
+			binaryWriter.WriteValue(int6);
+			binaryWriter.WriteValue(int7);
+			binaryWriter.WriteValue(int8);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+			binaryReader.ReadValue(out int2);
+			binaryReader.ReadValue(out int3);
+			binaryReader.ReadValue(out int4);
+			binaryReader.ReadValue(out int5);
+			binaryReader.ReadValue(out int6);
+			binaryReader.ReadValue(out int7);
+			binaryReader.ReadValue(out int8);
+		}
+	}
+	public class tnumber : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tnumber>
+	{
+		public const int ProtoId = 16;
+		public number int1;
+		public number int2;
+		public number int3;
+		public number int4;
+		public number int5;
+		public number int6;
+		public number int7;
+		public number int8;
+		public number float1;
+		public number float2;
+
+		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(int1);
+			binaryWriter.WriteValue(int2);
+			binaryWriter.WriteValue(int3);
+			binaryWriter.WriteValue(int4);
+			binaryWriter.WriteValue(int5);
+			binaryWriter.WriteValue(int6);
+			binaryWriter.WriteValue(int7);
+			binaryWriter.WriteValue(int8);
+			binaryWriter.WriteValue(float1);
+			binaryWriter.WriteValue(float2);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+			binaryReader.ReadValue(out int2);
+			binaryReader.ReadValue(out int3);
+			binaryReader.ReadValue(out int4);
+			binaryReader.ReadValue(out int5);
+			binaryReader.ReadValue(out int6);
+			binaryReader.ReadValue(out int7);
+			binaryReader.ReadValue(out int8);
+			binaryReader.ReadValue(out float1);
+			binaryReader.ReadValue(out float2);
+		}
+	}
+	public class tfloat : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tfloat>
+	{
+		public const int ProtoId = 17;
+		public float int1;
+		public float int2;
+
+		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(int1);
+			binaryWriter.WriteValue(int2);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+			binaryReader.ReadValue(out int2);
+		}
+	}
+	public class tdouble : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tdouble>
+	{
+		public const int ProtoId = 18;
+		public double int1;
+		public double int2;
+
+		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(int1);
+			binaryWriter.WriteValue(int2);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+			binaryReader.ReadValue(out int2);
+		}
+	}
+	public class tstring : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tstring>
+	{
+		public const int ProtoId = 19;
+		public string int1;
+		public string int2;
+
+		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(int1);
+			binaryWriter.WriteValue(int2);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+			binaryReader.ReadValue(out int2);
+		}
+	}
+	public class tlistbool : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistbool>
+	{
+		public const int ProtoId = 20;
+		public List<bool> int1;
+
+		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(int1);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+		}
+	}
+	public class tlistint8 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistint8>
+	{
+		public const int ProtoId = 21;
+		public List<sbyte> int1;
+
+		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(int1);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+		}
+	}
+	public class tlistuint8 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistuint8>
+	{
+		public const int ProtoId = 22;
+		public List<byte> int1;
+
+		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(int1);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+		}
+	}
+	public class tlistint16 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistint16>
+	{
+		public const int ProtoId = 23;
+		public List<short> int1;
+
+		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(int1);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+		}
+	}
+	public class tlistuint16 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistuint16>
+	{
+		public const int ProtoId = 24;
+		public List<ushort> int1;
+
+		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(int1);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+		}
+	}
+	public class tlistint32 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistint32>
+	{
+		public const int ProtoId = 25;
+		public List<int> int1;
+
+		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(int1);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+		}
+	}
+	public class tlistuint32 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistuint32>
+	{
+		public const int ProtoId = 26;
+		public List<uint> int1;
+
+		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(int1);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+		}
+	}
+	public class tlistint64 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistint64>
+	{
+		public const int ProtoId = 27;
+		public List<long> int1;
+
+		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(int1);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+		}
+	}
+	public class tlistuint64 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistuint64>
+	{
+		public const int ProtoId = 28;
+		public List<ulong> int1;
+
+		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(int1);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+		}
+	}
+	public class tlistinteger : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistinteger>
+	{
+		public const int ProtoId = 29;
+		public List<integer> int1;
+
+		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(int1);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+		}
+	}
+	public class tlistnumber : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistnumber>
+	{
+		public const int ProtoId = 30;
+		public List<number> int1;
+
+		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(int1);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+		}
+	}
+	public class tlistfloat : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistfloat>
+	{
+		public const int ProtoId = 31;
+		public List<float> int1;
+
+		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(int1);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+		}
+	}
+	public class tlistdouble : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistdouble>
+	{
+		public const int ProtoId = 32;
+		public List<double> int1;
+
+		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(int1);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+		}
+	}
+	public class tliststring : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tliststring>
+	{
+		public const int ProtoId = 33;
+		public List<string> int1;
+
+		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(int1);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+		}
+	}
+	public class tlistunion : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<tlistunion>
+	{
+		public const int ProtoId = 34;
+		public List<union> int1;
+
+		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(int1);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out int1);
+		}
+	}
+	public class allType : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<allType>
+	{
+		public const int ProtoId = 35;
+		public bool bool;
+		public sbyte int8;
+		public byte uint8;
+		public short int16;
+		public ushort uint16;
+		public int int32;
+		public uint uint32;
+		public long int64;
+		public ulong uint64;
+		public integer inte8;
+		public integer uinte8;
+		public integer inte16;
+		public integer uinte16;
+		public integer inte32;
+		public integer uinte32;
+		public integer inte64;
+		public integer uinte64;
+		public number num8;
+		public number unum8;
+		public number num16;
+		public number unum16;
+		public number num32;
+		public number unum32;
+		public number num64;
+		public number unum64;
+		public number numfloat;
+		public number numdouble;
+		public float float;
+		public double double;
+		public string string1;
+		public string string2;
+		public union union;
+		public List<bool> lbool;
+		public List<sbyte> lint8;
+		public List<byte> luint8;
+		public List<short> lint16;
+		public List<ushort> luint16;
+		public List<int> lint32;
+		public List<uint> luint32;
+		public List<long> lint64;
+		public List<ulong> luint64;
+		public List<integer> linte8;
+		public List<integer> linte16;
+		public List<integer> linte32;
+		public List<integer> linte64;
+		public List<number> lnum8;
+		public List<number> lnum16;
+		public List<number> lnum32;
+		public List<number> lnum64;
+		public List<number> lnfloat32;
+		public List<number> lnfloat64;
+		public List<float> lfloat;
+		public List<double> ldouble;
+		public List<string> lstring;
+		public List<union> lunion;
+
+		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(int16);
+			binaryWriter.WriteValue(uint16);
+			binaryWriter.WriteValue(int32);
+			binaryWriter.WriteValue(uint32);
+			binaryWriter.WriteValue(int64);
+			binaryWriter.WriteValue(uint64);
+			binaryWriter.WriteValue(inte8);
+			binaryWriter.WriteValue(uinte8);
+			binaryWriter.WriteValue(inte16);
+			binaryWriter.WriteValue(uinte16);
+			binaryWriter.WriteValue(inte32);
+			binaryWriter.WriteValue(uinte32);
+			binaryWriter.WriteValue(inte64);
+			binaryWriter.WriteValue(uinte64);
+			binaryWriter.WriteValue(num8);
+			binaryWriter.WriteValue(unum8);
+			binaryWriter.WriteValue(num16);
+			binaryWriter.WriteValue(unum16);
+			binaryWriter.WriteValue(num32);
+			binaryWriter.WriteValue(unum32);
+			binaryWriter.WriteValue(num64);
+			binaryWriter.WriteValue(unum64);
+			binaryWriter.WriteValue(numfloat);
+			binaryWriter.WriteValue(numdouble);
+			binaryWriter.WriteValue(float);
+			binaryWriter.WriteValue(double);
+			binaryWriter.WriteValue(string1);
+			binaryWriter.WriteValue(string2);
+			binaryWriter.WriteValue(union);
+			binaryWriter.WriteValue(lbool);
+			binaryWriter.WriteValue(lint8);
+			binaryWriter.WriteValue(luint8);
+			binaryWriter.WriteValue(lint16);
+			binaryWriter.WriteValue(luint16);
+			binaryWriter.WriteValue(lint32);
+			binaryWriter.WriteValue(luint32);
+			binaryWriter.WriteValue(lint64);
+			binaryWriter.WriteValue(luint64);
+			binaryWriter.WriteValue(linte8);
+			binaryWriter.WriteValue(linte16);
+			binaryWriter.WriteValue(linte32);
+			binaryWriter.WriteValue(linte64);
+			binaryWriter.WriteValue(lnum8);
+			binaryWriter.WriteValue(lnum16);
+			binaryWriter.WriteValue(lnum32);
+			binaryWriter.WriteValue(lnum64);
+			binaryWriter.WriteValue(lnfloat32);
+			binaryWriter.WriteValue(lnfloat64);
+			binaryWriter.WriteValue(lfloat);
+			binaryWriter.WriteValue(ldouble);
+			binaryWriter.WriteValue(lstring);
+			binaryWriter.WriteValue(lunion);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out bool);
+			binaryReader.ReadValue(out int8);
+			binaryReader.ReadValue(out uint8);
+			binaryReader.ReadValue(out int16);
+			binaryReader.ReadValue(out uint16);
+			binaryReader.ReadValue(out int32);
+			binaryReader.ReadValue(out uint32);
+			binaryReader.ReadValue(out int64);
+			binaryReader.ReadValue(out uint64);
+			binaryReader.ReadValue(out inte8);
+			binaryReader.ReadValue(out uinte8);
+			binaryReader.ReadValue(out inte16);
+			binaryReader.ReadValue(out uinte16);
+			binaryReader.ReadValue(out inte32);
+			binaryReader.ReadValue(out uinte32);
+			binaryReader.ReadValue(out inte64);
+			binaryReader.ReadValue(out uinte64);
+			binaryReader.ReadValue(out num8);
+			binaryReader.ReadValue(out unum8);
+			binaryReader.ReadValue(out num16);
+			binaryReader.ReadValue(out unum16);
+			binaryReader.ReadValue(out num32);
+			binaryReader.ReadValue(out unum32);
+			binaryReader.ReadValue(out num64);
+			binaryReader.ReadValue(out unum64);
+			binaryReader.ReadValue(out numfloat);
+			binaryReader.ReadValue(out numdouble);
+			binaryReader.ReadValue(out float);
+			binaryReader.ReadValue(out double);
+			binaryReader.ReadValue(out string1);
+			binaryReader.ReadValue(out string2);
+			binaryReader.ReadValue(out union);
+			binaryReader.ReadValue(out lbool);
+			binaryReader.ReadValue(out lint8);
+			binaryReader.ReadValue(out luint8);
+			binaryReader.ReadValue(out lint16);
+			binaryReader.ReadValue(out luint16);
+			binaryReader.ReadValue(out lint32);
+			binaryReader.ReadValue(out luint32);
+			binaryReader.ReadValue(out lint64);
+			binaryReader.ReadValue(out luint64);
+			binaryReader.ReadValue(out linte8);
+			binaryReader.ReadValue(out linte16);
+			binaryReader.ReadValue(out linte32);
+			binaryReader.ReadValue(out linte64);
+			binaryReader.ReadValue(out lnum8);
+			binaryReader.ReadValue(out lnum16);
+			binaryReader.ReadValue(out lnum32);
+			binaryReader.ReadValue(out lnum64);
+			binaryReader.ReadValue(out lnfloat32);
+			binaryReader.ReadValue(out lnfloat64);
+			binaryReader.ReadValue(out lfloat);
+			binaryReader.ReadValue(out ldouble);
+			binaryReader.ReadValue(out lstring);
+			binaryReader.ReadValue(out lunion);
+		}
+	}
+	public class testnull : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<testnull>
+	{
+		public const int ProtoId = 36;
+
+		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)
+		{
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+		}
+	}
+	public class person1 : ProtocolCore.ISerialize, ProtocolCore.IDeserialize<person1>
+	{
+		public const int ProtoId = 1001;
+		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 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(name);
+			binaryWriter.WriteValue(id);
+			binaryWriter.WriteValue(email);
+			binaryWriter.WriteValue(phone);
+		}
+		public void Deserialize(BinaryReader binaryReader)
+		{
+			binaryReader.ReadValue(out name);
+			binaryReader.ReadValue(out id);
+			binaryReader.ReadValue(out email);
+			binaryReader.ReadValue(out phone);
+		}
+	}
+}
\ No newline at end of file
diff --git a/test/protoMsg.hrl b/test/protoMsg.hrl
index a092bf3..442cf12 100644
--- a/test/protoMsg.hrl
+++ b/test/protoMsg.hrl
@@ -8,14 +8,14 @@
 -opaque uint64() :: 0..18446744073709551615.
 -opaque double() :: float().
 
--define(ERR1, 1).		%% 辅导费
--define(ERR2, 2).		%% 444 
--define(ERR3, 3).		%% 辅导费
--define(ERR4, 4).		%% dfsf 
--define(ERR5, 5).		%% 其他注释辅导费 err6:dfff
--define(ERR7, 6).		%% def
--define(ERR8, 7).		%% 其他注释辅导费
--define(ERR6, 1001).		%% dfff
+-define(ERR1, 1001).		%% 辅导费
+-define(ERR2, 1002).		%% 444 
+-define(ERR3, 1003).		%% 辅导费
+-define(ERR4, 1004).		%% dfsf 
+-define(ERR5, 1005).		%% 其他注释辅导费
+-define(ERR6, 1006).		%% dfff
+-define(ERR7, 1007).		%% def
+-define(ERR8, 1008).		%% 其他注释辅导费 
 
 
 -record(test, {