1.增加行车记录仪序列化器

2.增加Demo9
3.修改文档

README.md

@@ -282,6 +282,12 @@ JT808Serializer DT2JT808Serializer = new JT808Serializer(DT2JT808Config);
 
 [可以参考Simples的Demo8](https://github.com/SmallChi/JT808/blob/master/src/JT808.Protocol.Test/Simples/Demo8.cs)
 
+### 举个栗子9
+
+增加行车记录仪序列化器，既可以单独的存在，也可以组装在808的数据包当中。
+
+[可以参考Simples的Demo9](https://github.com/SmallChi/JT808/blob/master/src/JT808.Protocol.Test/Simples/Demo9.cs)
+
 ## NuGet安装
 
 | Package Name          | Version                                            | Downloads                                           |

src/JT808.Protocol.Test/Simples/Demo9.cs

@@ -0,0 +1,123 @@
+using JT808.Protocol.Enums;
+using JT808.Protocol.Interfaces;
+using JT808.Protocol.Internal;
+using JT808.Protocol.Extensions;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using Xunit;
+using JT808.Protocol.MessageBody;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.MessagePack;
+using System.Text.Json;
+using JT808.Protocol.MessageBody.CarDVR;
+
+namespace JT808.Protocol.Test.Simples
+{
+    public class Demo9
+    {
+        JT808CarDVRSerializer JT808CarDVRSerializer;
+        JT808Serializer JT808Serializer;
+        IJT808Config jT808Config;
+        public Demo9()
+        {
+            jT808Config = new DefaultGlobalConfig();
+            JT808CarDVRSerializer = new JT808CarDVRSerializer(jT808Config);
+            JT808Serializer = new JT808Serializer(jT808Config);
+        }
+
+        [Fact]
+        public void Test1()
+        {
+            JT808CarDVRSerializer jT808CarDVRSerializer = jT808Config.GetCarDVRSerializer();
+            Assert.Equal(jT808CarDVRSerializer.SerializerId, JT808CarDVRSerializer.SerializerId);
+        }
+
+        [Fact]
+        public void Test2()
+        {
+            JT808CarDVRDownPackage jT808CarDVRDownPackage = new JT808CarDVRDownPackage();
+            jT808CarDVRDownPackage.CommandId = JT808CarDVRCommandID.设置初始里程.ToByteValue();
+            jT808CarDVRDownPackage.Bodies = new JT808_CarDVR_Down_0xC4()
+            {
+                 FirstInstallTime=DateTime.Parse("2020-03-25 10:26:01"),
+                 FirstMileage="1234",
+                 RealTime = DateTime.Parse("2020-03-25 10:26:01"),
+                 TotalMilage="123456"
+            };
+            byte[] downData = JT808CarDVRSerializer.Serialize(jT808CarDVRDownPackage);
+            var downHex = downData.ToHexString();
+            Assert.Equal("557AC40014002003251026012003251026010000123400123456A9", downHex);
+        }
+
+        [Fact]
+        public void Test3()
+        {
+            var data = "557AC40014002003251026012003251026010000123400123456A9".ToHexBytes();
+            JT808CarDVRDownPackage jT808CarDVRDownPackage = JT808CarDVRSerializer.DownDeserialize(data);
+            Assert.Equal(JT808CarDVRCommandID.设置初始里程.ToByteValue(), jT808CarDVRDownPackage.CommandId);
+            var value = jT808CarDVRDownPackage.Bodies as JT808_CarDVR_Down_0xC4;    
+            Assert.Equal(DateTime.Parse("2020-03-25 10:26:01"), value.FirstInstallTime);
+            Assert.Equal(DateTime.Parse("2020-03-25 10:26:01"), value.RealTime);
+            Assert.Equal("1234", value.FirstMileage);
+            Assert.Equal("123456", value.TotalMilage);
+        }
+
+        [Fact]
+        public void Test4()
+        {
+            JT808CarDVRUpPackage package = new JT808CarDVRUpPackage();
+            package.CommandId = JT808CarDVRCommandID.设置初始里程.ToByteValue();
+            package.Bodies = new JT808_CarDVR_Up_0xC4()
+            {
+                
+            };
+            byte[] data = JT808CarDVRSerializer.Serialize(package);
+            var hex = data.ToHexString();
+            Assert.Equal("557AC4000000EB", hex);
+        }
+
+        [Fact]
+        public void Test5()
+        {
+            var data = "557AC4000000EB".ToHexBytes();
+            JT808CarDVRUpPackage package = JT808CarDVRSerializer.UpDeserialize(data);
+            Assert.Equal(JT808CarDVRCommandID.设置初始里程.ToByteValue(), package.CommandId);
+            Assert.Null(package.Bodies);
+        }
+
+        [Fact]
+        public void Test6()
+        {
+            JT808_0x8701 value = new JT808_0x8701();
+            value.CommandId = 0x82;
+            value.JT808CarDVRDownPackage = new JT808CarDVRDownPackage
+            {
+                CommandId = 0x82,
+                Bodies = new JT808_CarDVR_Down_0x82()
+                {
+                    VehicleNo = "粤B12345",
+                    VehicleType = "重型货车",
+                    Vin = "12345678912345678"
+                }
+            };
+            var hex = JT808Serializer.Serialize(value).ToHexString();
+            Assert.Equal("82557A820027003132333435363738393132333435363738D4C142313233343500000000D6D8D0CDBBF5B3B500008E", hex);
+        }
+
+        [Fact]
+        public void Test7()
+        {
+            byte[] bytes = "82557A820027003132333435363738393132333435363738D4C142313233343500000000D6D8D0CDBBF5B3B500008E".ToHexBytes();
+            JT808_0x8701 value = JT808Serializer.Deserialize<JT808_0x8701>(bytes);
+            Assert.Equal(0x82, value.CommandId);
+            var body = value.JT808CarDVRDownPackage as JT808CarDVRDownPackage;
+            Assert.Equal(0x82, body.CommandId);
+            var subBody = body.Bodies as JT808_CarDVR_Down_0x82;
+            Assert.Equal("粤B12345", subBody.VehicleNo);
+            Assert.Equal("重型货车", subBody.VehicleType);
+            Assert.Equal("12345678912345678", subBody.Vin);
+        }
+    }
+}

src/JT808.Protocol/Extensions/JT808ConfigExtensions.cs

@@ -10,6 +10,7 @@ namespace JT808.Protocol
     public static class JT808ConfigExtensions
     {
         private readonly static ConcurrentDictionary<string, JT808Serializer> jT808SerializerDict = new ConcurrentDictionary<string, JT808Serializer>(StringComparer.OrdinalIgnoreCase);
+        private readonly static ConcurrentDictionary<string, JT808CarDVRSerializer> jT808CarDVRSerializer = new ConcurrentDictionary<string, JT808CarDVRSerializer>(StringComparer.OrdinalIgnoreCase);
         public static object GetMessagePackFormatterByType(this IJT808Config jT808Config,Type type)
         {
             if (!jT808Config.FormatterFactory.FormatterDict.TryGetValue(type.GUID, out var formatter))
@@ -34,6 +35,15 @@ namespace JT808.Protocol
         {
             return (IJT808Analyze)GetAnalyzeByType(jT808Config, typeof(T));
         }
+        public static JT808CarDVRSerializer GetCarDVRSerializer(this IJT808Config jT808Config)
+        {
+            if(!jT808CarDVRSerializer.TryGetValue(jT808Config.ConfigId,out var serializer))
+            {
+                serializer = new JT808CarDVRSerializer(jT808Config);
+                jT808CarDVRSerializer.TryAdd(jT808Config.ConfigId, serializer);
+            }
+            return serializer;
+        }       
         public static JT808Serializer GetSerializer(this IJT808Config jT808Config)
         {
             if(!jT808SerializerDict.TryGetValue(jT808Config.ConfigId,out var serializer))

src/JT808.Protocol/Interfaces/GlobalConfigBase.cs

@@ -28,8 +28,6 @@ namespace JT808.Protocol.Interfaces
             JT808_0x8500_2019_Factory = new JT808_0x8500_2019_Factory();
             JT808_CarDVR_Up_Factory = new JT808_CarDVR_Up_Factory();
             JT808_CarDVR_Down_Factory = new JT808_CarDVR_Down_Factory();
-            IJT808_CarDVR_Up_Package = new JT808CarDVRUpPackage();
-            IJT808_CarDVR_Down_Package = new JT808CarDVRDownPackage();
             TerminalPhoneNoLength = 12;
             Trim = true;
         }
@@ -52,10 +50,7 @@ namespace JT808.Protocol.Interfaces
         public virtual IJT808_0x8500_2019_Factory JT808_0x8500_2019_Factory { get; set; }
         public IJT808_CarDVR_Up_Factory JT808_CarDVR_Up_Factory { get; set; }
         public IJT808_CarDVR_Down_Factory JT808_CarDVR_Down_Factory { get; set; }
-        public IJT808_CarDVR_Up_Package IJT808_CarDVR_Up_Package { get; set; }
-        public IJT808_CarDVR_Down_Package IJT808_CarDVR_Down_Package { get; set; }
         public bool SkipCarDVRCRCCode { get; set; }
-
         public virtual IJT808Config Register(params Assembly[] externalAssemblies)
         {
             if (externalAssemblies != null)

src/JT808.Protocol/Interfaces/IJT808Config.cs

@@ -69,14 +69,6 @@ namespace JT808.Protocol
         /// </summary>
         IJT808_CarDVR_Down_Factory JT808_CarDVR_Down_Factory { get; set; }
         /// <summary>
-        /// 记录仪上行包
-        /// </summary>
-        public IJT808_CarDVR_Up_Package IJT808_CarDVR_Up_Package { get; set; }
-        /// <summary>
-        /// 记录仪下行包
-        /// </summary>
-        public IJT808_CarDVR_Down_Package IJT808_CarDVR_Down_Package { get; set; }
-        /// <summary>
         /// 统一编码
         /// </summary>
         Encoding Encoding { get; set; }

src/JT808.Protocol/JT808.Protocol.xml

@@ -2714,16 +2714,6 @@
             记录仪下行命令字工厂
             </summary>
         </member>
-        <member name="P:JT808.Protocol.IJT808Config.IJT808_CarDVR_Up_Package">
-            <summary>
-            记录仪上行包
-            </summary>
-        </member>
-        <member name="P:JT808.Protocol.IJT808Config.IJT808_CarDVR_Down_Package">
-            <summary>
-            记录仪下行包
-            </summary>
-        </member>
         <member name="P:JT808.Protocol.IJT808Config.Encoding">
             <summary>
             统一编码
@@ -5541,7 +5531,8 @@
         <member name="P:JT808.Protocol.MessageBody.JT808_0x8003.AgainPackageCount">
             <summary>
             重传包总数
-            n
+            2013 byte
+            2019 ushort
             </summary>
         </member>
         <member name="P:JT808.Protocol.MessageBody.JT808_0x8003.AgainPackageData">

src/JT808.Protocol/JT808CarDVRDownPackage.cs

@@ -109,13 +109,15 @@ namespace JT808.Protocol
                 }
             }
             var carDVRCheckCode = reader.ReadCarDVRCheckCode(currentPosition);
-            if (!config.SkipCarDVRCRCCode)
+            value.CheckCode = reader.ReadByte();
+            if (carDVRCheckCode.RealXorCheckCode != carDVRCheckCode.CalculateXorCheckCode)
             {
-                if (carDVRCheckCode.RealXorCheckCode != carDVRCheckCode.CalculateXorCheckCode)
-                    throw new JT808Exception(JT808ErrorCode.CarDVRCheckCodeNotEqual, $"{reader.RealCheckXorCode}!={reader.CalculateCheckXorCode}");
+                writer.WriteString($"[{value.CheckCode.ReadNumber()}]校验位错误", $"{reader.RealCheckXorCode}!={reader.CalculateCheckXorCode}");
+            }
+            else
+            {
+                writer.WriteNumber($"[{value.CheckCode.ReadNumber()}]校验位", value.CheckCode);
             }
-            value.CheckCode = reader.ReadByte();
-            writer.WriteNumber($"[{value.CheckCode.ReadNumber()}]校验位", value.CheckCode);
             writer.WriteEndObject();
         }
     }

src/JT808.Protocol/JT808CarDVRSerializer.cs

@@ -0,0 +1,238 @@
+using JT808.Protocol.Enums;
+using JT808.Protocol.Extensions;
+using JT808.Protocol.Formatters;
+using JT808.Protocol.Interfaces;
+using JT808.Protocol.Internal;
+using JT808.Protocol.MessagePack;
+using System;
+using System.IO;
+using System.Text;
+using System.Text.Json;
+
+namespace JT808.Protocol
+{
+    public  class JT808CarDVRSerializer
+    {
+        public readonly static JT808CarDVRUpPackage JT808CarDVRUpPackage = new JT808CarDVRUpPackage();
+
+        public readonly static JT808CarDVRDownPackage JT808CarDVRDownPackage = new JT808CarDVRDownPackage();
+
+        public JT808CarDVRSerializer(IJT808Config jT808Config)
+        {
+            this.jT808Config = jT808Config;
+        }
+
+        public JT808CarDVRSerializer():this(new DefaultGlobalConfig())
+        {
+
+        }
+
+        public string SerializerId => jT808Config.ConfigId;
+
+        private readonly IJT808Config jT808Config;
+
+        public byte[] Serialize(JT808CarDVRUpPackage package, JT808Version version = JT808Version.JTT2013, int minBufferSize = 4096)
+        {
+            byte[] buffer = JT808ArrayPool.Rent(minBufferSize);
+            try
+            {
+                JT808MessagePackWriter jT808MessagePackWriter = new JT808MessagePackWriter(buffer, version);
+                package.Serialize(ref jT808MessagePackWriter, package, jT808Config);
+                return jT808MessagePackWriter.FlushAndGetEncodingArray();
+            }
+            finally
+            {
+                JT808ArrayPool.Return(buffer);
+            }
+        }
+
+        public ReadOnlySpan<byte> SerializeReadOnlySpan(JT808CarDVRUpPackage package, JT808Version version = JT808Version.JTT2013, int minBufferSize = 4096)
+        {
+            byte[] buffer = JT808ArrayPool.Rent(minBufferSize);
+            try
+            {
+                JT808MessagePackWriter jT808MessagePackWriter = new JT808MessagePackWriter(buffer, version);
+                package.Serialize(ref jT808MessagePackWriter, package, jT808Config);
+                return jT808MessagePackWriter.FlushAndGetEncodingReadOnlySpan();
+            }
+            finally
+            {
+                JT808ArrayPool.Return(buffer);
+            }
+        }
+
+        public byte[] Serialize(JT808CarDVRDownPackage package, JT808Version version = JT808Version.JTT2013, int minBufferSize = 4096)
+        {
+            byte[] buffer = JT808ArrayPool.Rent(minBufferSize);
+            try
+            {
+                JT808MessagePackWriter jT808MessagePackWriter = new JT808MessagePackWriter(buffer, version);
+                package.Serialize(ref jT808MessagePackWriter, package, jT808Config);
+                return jT808MessagePackWriter.FlushAndGetEncodingArray();
+            }
+            finally
+            {
+                JT808ArrayPool.Return(buffer);
+            }
+        }
+
+        public ReadOnlySpan<byte> SerializeReadOnlySpan(JT808CarDVRDownPackage package, JT808Version version = JT808Version.JTT2013, int minBufferSize = 4096)
+        {
+            byte[] buffer = JT808ArrayPool.Rent(minBufferSize);
+            try
+            {
+                JT808MessagePackWriter jT808MessagePackWriter = new JT808MessagePackWriter(buffer, version);
+                package.Serialize(ref jT808MessagePackWriter, package, jT808Config);
+                return jT808MessagePackWriter.FlushAndGetEncodingReadOnlySpan();
+            }
+            finally
+            {
+                JT808ArrayPool.Return(buffer);
+            }
+        }
+
+        public JT808CarDVRUpPackage UpDeserialize(ReadOnlySpan<byte> bytes, JT808Version version = JT808Version.JTT2013)
+        {
+            JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
+            return JT808CarDVRUpPackage.Deserialize(ref jT808MessagePackReader, jT808Config);
+        }
+
+        public JT808CarDVRDownPackage DownDeserialize(ReadOnlySpan<byte> bytes, JT808Version version = JT808Version.JTT2013)
+        {
+            JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
+            return JT808CarDVRDownPackage.Deserialize(ref jT808MessagePackReader, jT808Config);
+        }
+
+        public byte [] Serialize<T>(T obj, JT808Version version = JT808Version.JTT2013, int minBufferSize = 4096)
+        {
+            byte[] buffer = JT808ArrayPool.Rent(minBufferSize);
+            try
+            {
+                var formatter = jT808Config.GetMessagePackFormatter<T>();
+                JT808MessagePackWriter jT808MessagePackWriter = new JT808MessagePackWriter(buffer, version);
+                formatter.Serialize(ref jT808MessagePackWriter, obj, jT808Config);
+                return jT808MessagePackWriter.FlushAndGetEncodingArray();
+            }
+            finally
+            {
+                JT808ArrayPool.Return(buffer);
+            }
+        }
+
+        public ReadOnlySpan<byte> SerializeReadOnlySpan<T>(T obj, JT808Version version = JT808Version.JTT2013, int minBufferSize = 4096)
+        {
+            byte[] buffer = JT808ArrayPool.Rent(minBufferSize);
+            try
+            {
+                var formatter = jT808Config.GetMessagePackFormatter<T>();
+                JT808MessagePackWriter jT808MessagePackWriter = new JT808MessagePackWriter(buffer, version);
+                formatter.Serialize(ref jT808MessagePackWriter, obj, jT808Config);
+                return jT808MessagePackWriter.FlushAndGetEncodingReadOnlySpan();
+            }
+            finally
+            {
+                JT808ArrayPool.Return(buffer);
+            }
+        }
+
+        public T Deserialize<T>(ReadOnlySpan<byte> bytes, JT808Version version = JT808Version.JTT2013)
+        {
+            JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
+            var formatter = jT808Config.GetMessagePackFormatter<T>();
+            return formatter.Deserialize(ref jT808MessagePackReader, jT808Config);
+        }
+
+        public dynamic Deserialize(ReadOnlySpan<byte> bytes, Type type, JT808Version version = JT808Version.JTT2013)
+        {
+            var formatter = jT808Config.GetMessagePackFormatterByType(type);
+            JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
+            return JT808MessagePackFormatterResolverExtensions.JT808DynamicDeserialize(formatter,ref jT808MessagePackReader, jT808Config);
+        }
+
+        public string UpAnalyze(ReadOnlySpan<byte> bytes,  JT808Version version = JT808Version.JTT2013, JsonWriterOptions options = default)
+        {
+            JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
+            using(MemoryStream memoryStream = new MemoryStream())
+            using (Utf8JsonWriter utf8JsonWriter = new Utf8JsonWriter(memoryStream, options))
+            {
+                JT808CarDVRUpPackage.Analyze(ref jT808MessagePackReader, utf8JsonWriter, jT808Config);
+                utf8JsonWriter.Flush();
+                string value = Encoding.UTF8.GetString(memoryStream.ToArray());
+                return value; 
+            }   
+        }
+
+        public string DownAnalyze(ReadOnlySpan<byte> bytes, JT808Version version = JT808Version.JTT2013, JsonWriterOptions options = default)
+        {
+            JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
+            using (MemoryStream memoryStream = new MemoryStream())
+            using (Utf8JsonWriter utf8JsonWriter = new Utf8JsonWriter(memoryStream, options))
+            {
+                JT808CarDVRDownPackage.Analyze(ref jT808MessagePackReader, utf8JsonWriter, jT808Config);
+                utf8JsonWriter.Flush();
+                string value = Encoding.UTF8.GetString(memoryStream.ToArray());
+                return value;
+            }
+        }
+
+        public string Analyze<T>(ReadOnlySpan<byte> bytes, JT808Version version = JT808Version.JTT2013, JsonWriterOptions options = default)
+        {
+            JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
+            var analyze = jT808Config.GetAnalyze<T>();
+            using (MemoryStream memoryStream = new MemoryStream())
+            using (Utf8JsonWriter utf8JsonWriter = new Utf8JsonWriter(memoryStream, options))
+            {
+                if (!CheckPackageType(typeof(T))) utf8JsonWriter.WriteStartObject();
+                analyze.Analyze(ref jT808MessagePackReader, utf8JsonWriter, jT808Config);
+                if (!CheckPackageType(typeof(T))) utf8JsonWriter.WriteEndObject();
+                utf8JsonWriter.Flush();
+                string value = Encoding.UTF8.GetString(memoryStream.ToArray());
+                return value;
+            }
+        }
+
+        public byte[] UpAnalyzeJsonBuffer(ReadOnlySpan<byte> bytes, JT808Version version = JT808Version.JTT2013, JsonWriterOptions options = default)
+        {
+            JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
+            using (MemoryStream memoryStream = new MemoryStream())
+            using (Utf8JsonWriter utf8JsonWriter = new Utf8JsonWriter(memoryStream, options))
+            {
+                JT808CarDVRUpPackage.Analyze(ref jT808MessagePackReader, utf8JsonWriter, jT808Config);
+                utf8JsonWriter.Flush();
+                return memoryStream.ToArray();
+            }
+        }
+
+        public byte[] DownAnalyzeJsonBuffer(ReadOnlySpan<byte> bytes, JT808Version version = JT808Version.JTT2013, JsonWriterOptions options = default)
+        {
+            JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
+            using (MemoryStream memoryStream = new MemoryStream())
+            using (Utf8JsonWriter utf8JsonWriter = new Utf8JsonWriter(memoryStream, options))
+            {
+                JT808CarDVRDownPackage.Analyze(ref jT808MessagePackReader, utf8JsonWriter, jT808Config);
+                utf8JsonWriter.Flush();
+                return memoryStream.ToArray();
+            }
+        }
+
+        public byte[] AnalyzeJsonBuffer<T>(ReadOnlySpan<byte> bytes, JT808Version version = JT808Version.JTT2013, JsonWriterOptions options = default)
+        {
+            JT808MessagePackReader jT808MessagePackReader = new JT808MessagePackReader(bytes, version);
+            var analyze = jT808Config.GetAnalyze<T>();
+            using (MemoryStream memoryStream = new MemoryStream())
+            using (Utf8JsonWriter utf8JsonWriter = new Utf8JsonWriter(memoryStream, options))
+            {
+                if (!CheckPackageType(typeof(T))) utf8JsonWriter.WriteStartObject();
+                analyze.Analyze(ref jT808MessagePackReader, utf8JsonWriter, jT808Config);
+                if (!CheckPackageType(typeof(T))) utf8JsonWriter.WriteEndObject();
+                utf8JsonWriter.Flush();
+                return memoryStream.ToArray();
+            }
+        }
+
+        private static bool CheckPackageType(Type type)
+        {
+            return type == typeof(JT808CarDVRUpPackage) || type == typeof(JT808CarDVRDownPackage);
+        }
+    }
+}

src/JT808.Protocol/JT808CarDVRUpPackage.cs

@@ -66,13 +66,15 @@ namespace JT808.Protocol
                 }
             }
             var carDVRCheckCode = reader.ReadCarDVRCheckCode(currentPosition);
-            if (!config.SkipCarDVRCRCCode)
+            value.CheckCode = reader.ReadByte();
+            if (carDVRCheckCode.RealXorCheckCode != carDVRCheckCode.CalculateXorCheckCode)
             {
-                if (carDVRCheckCode.RealXorCheckCode != carDVRCheckCode.CalculateXorCheckCode)
-                    throw new JT808Exception(JT808ErrorCode.CarDVRCheckCodeNotEqual, $"{reader.RealCheckXorCode}!={reader.CalculateCheckXorCode}");
+                writer.WriteString($"[{value.CheckCode.ReadNumber()}]校验位错误", $"{reader.RealCheckXorCode}!={reader.CalculateCheckXorCode}");
+            }
+            else
+            {
+                writer.WriteNumber($"[{value.CheckCode.ReadNumber()}]校验位", value.CheckCode);
             }
-            value.CheckCode = reader.ReadByte();
-            writer.WriteNumber($"[{value.CheckCode.ReadNumber()}]校验位", value.CheckCode);
             writer.WriteEndObject();
         }
 

src/JT808.Protocol/MessageBody/JT808_0x0700.cs

@@ -36,7 +36,7 @@ namespace JT808.Protocol.MessageBody
             value.CommandId = reader.ReadByte();
             writer.WriteString($"[{value.CommandId.ReadNumber()}]命令字", ((JT808CarDVRCommandID)value.CommandId).ToString());
             writer.WriteStartObject(((JT808CarDVRCommandID)value.CommandId).ToString());
-            config.IJT808_CarDVR_Up_Package.Analyze(ref reader, writer, config);
+            JT808CarDVRSerializer.JT808CarDVRUpPackage.Analyze(ref reader, writer, config);
             writer.WriteEndObject();
             writer.WriteEndObject();
         }
@@ -46,8 +46,7 @@ namespace JT808.Protocol.MessageBody
             JT808_0x0700 value = new JT808_0x0700();
             value.ReplyMsgNum = reader.ReadUInt16();
             value.CommandId = reader.ReadByte();
-            object obj = config.GetMessagePackFormatterByType(config.IJT808_CarDVR_Up_Package.GetType());
-            value.JT808CarDVRUpPackage = JT808MessagePackFormatterResolverExtensions.JT808DynamicDeserialize(obj, ref reader, config);
+            value.JT808CarDVRUpPackage = JT808CarDVRSerializer.JT808CarDVRUpPackage.Deserialize(ref reader, config);
             return value;
         }
 
@@ -55,9 +54,7 @@ namespace JT808.Protocol.MessageBody
         {
             writer.WriteUInt16(value.ReplyMsgNum);
             writer.WriteByte(value.CommandId);
-            object obj = config.GetMessagePackFormatterByType(config.IJT808_CarDVR_Up_Package.GetType());
-            JT808MessagePackFormatterResolverExtensions.JT808DynamicSerialize(obj, ref writer, value.JT808CarDVRUpPackage, config);
-
+            JT808CarDVRSerializer.JT808CarDVRUpPackage.Serialize(ref writer, value.JT808CarDVRUpPackage, config);
         }
     }
 }

src/JT808.Protocol/MessageBody/JT808_0x8700.cs

@@ -29,7 +29,7 @@ namespace JT808.Protocol.MessageBody
             value.CommandId = reader.ReadByte();
             writer.WriteString($"[{value.CommandId.ReadNumber()}]命令字", ((JT808CarDVRCommandID)value.CommandId).ToString());
             writer.WriteStartObject(((JT808CarDVRCommandID)value.CommandId).ToString());
-            config.IJT808_CarDVR_Down_Package.Analyze(ref reader, writer, config);
+            JT808CarDVRSerializer.JT808CarDVRDownPackage.Analyze(ref reader, writer, config);
             writer.WriteEndObject();
             writer.WriteEndObject();
         }
@@ -38,16 +38,14 @@ namespace JT808.Protocol.MessageBody
         {
             JT808_0x8700 value = new JT808_0x8700();
             value.CommandId = reader.ReadByte();
-            object obj = config.GetMessagePackFormatterByType(config.IJT808_CarDVR_Down_Package.GetType());
-            value.JT808CarDVRDownPackage = JT808MessagePackFormatterResolverExtensions.JT808DynamicDeserialize(obj, ref reader, config);
+            value.JT808CarDVRDownPackage = JT808CarDVRSerializer.JT808CarDVRDownPackage.Deserialize(ref reader, config);
             return value;
         }
 
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8700 value, IJT808Config config)
         {
             writer.WriteByte(value.CommandId);
-            object obj = config.GetMessagePackFormatterByType(config.IJT808_CarDVR_Down_Package.GetType());
-            JT808MessagePackFormatterResolverExtensions.JT808DynamicSerialize(obj, ref writer, value.JT808CarDVRDownPackage, config);
+            JT808CarDVRSerializer.JT808CarDVRDownPackage.Serialize(ref writer, value.JT808CarDVRDownPackage, config);
         }
     }
 }

src/JT808.Protocol/MessageBody/JT808_0x8701.cs

@@ -32,7 +32,7 @@ namespace JT808.Protocol.MessageBody
             value.CommandId = reader.ReadByte();
             writer.WriteString($"[{value.CommandId.ReadNumber()}]命令字", ((JT808CarDVRCommandID)value.CommandId).ToString());
             writer.WriteStartObject(((JT808CarDVRCommandID)value.CommandId).ToString());
-            config.IJT808_CarDVR_Down_Package.Analyze(ref reader, writer, config);
+            JT808CarDVRSerializer.JT808CarDVRDownPackage.Analyze(ref reader, writer, config);
             writer.WriteEndObject();
             writer.WriteEndObject();
         }
@@ -41,16 +41,14 @@ namespace JT808.Protocol.MessageBody
         {
             JT808_0x8701 value = new JT808_0x8701();
             value.CommandId = reader.ReadByte();
-            object obj = config.GetMessagePackFormatterByType(config.IJT808_CarDVR_Down_Package.GetType());
-            value.JT808CarDVRDownPackage = JT808MessagePackFormatterResolverExtensions.JT808DynamicDeserialize(obj, ref reader, config);
+            value.JT808CarDVRDownPackage = JT808CarDVRSerializer.JT808CarDVRDownPackage.Deserialize(ref reader, config);
             return value;
         }
 
         public void Serialize(ref JT808MessagePackWriter writer, JT808_0x8701 value, IJT808Config config)
         {
             writer.WriteByte(value.CommandId);
-            object obj = config.GetMessagePackFormatterByType(config.IJT808_CarDVR_Down_Package.GetType());
-            JT808MessagePackFormatterResolverExtensions.JT808DynamicSerialize(obj, ref writer, value.JT808CarDVRDownPackage, config);
+            JT808CarDVRSerializer.JT808CarDVRDownPackage.Serialize(ref writer, value.JT808CarDVRDownPackage, config);
         }
     }
 }