去年接触的一个项目中,需要通过TCP与设备进行对接的,传的是Modbus协议的数据,然后后台需要可以动态配置协议解析的方式，即寄存器的解析方式，，配置信息有：Key，数据Index，源数据类型，数据库列类型，数据排列方式
一开始使用的方式是，从数据库读取出协议的配置，然后在接收到数据的时候，循环每个配置项根据配置-----解析数据------转换类型----存临时列表,,后来改进了一下,配置项存缓存,,数据库修改的时候,同时更新缓存。。
但还是慢了一点，因为需一个配置大概是20-30个数据项，每一条数据都要for循环20-30次 ，再加上还有N个根据配置的数据类型去做转换的if判断，这么一套下来，也很耗时间，但待解析的数据量大的情况下，，相对也很耗资源。。。
最后的觉得方案是：利用T4生成C#的class源码+运行时编译成类，数据直接扔class里直接解析出结果，不需要循环，也不需要if判断，因为在t4生成源码的时候，已经根据配置处理完了，因此节省了很多的时间。
不过由于T4模板的IDE支持的很不好，不过好在运行时T4模板在IDE内生成出来的类是partial的，因此，可以把大部分的代码，放在外部的C#文件里。先来看数据项的配置信息：
1 public class DataItem 2 { 3 /// <summary> 4 /// 数据项ID 5 /// </summary> 6 public ObjectId DataItemID { set; get; } 7 8 /// <summary> 9 /// 偏移量 10 /// </summary> 11 public int Pos { set; get; } 12 13 /// <summary> 14 /// 大小 15 /// </summary> 16 public int Size { set; get; } 17 18 public int BitIndex { set; get; } 19 20 /// <summary> 21 /// 数据项数据库储存类型 22 /// </summary> 23 public DbDataTypeEnum DbType { set; get; } 24 25 /// <summary> 26 /// 数据项协议源字节数组中的数据类型 27 /// </summary> 28 public DataTypeEnum SourceType { set; get; } 29 30 /// <summary> 31 /// 计算因子 32 /// </summary> 33 public decimal Factor { set; get; } 34 35 public string Key { set; get; } 36 } 37 38 /// <summary> 39 /// 对应的数据库字段类型 40 /// </summary> 41 public enum DbDataTypeEnum 42 { 43 Int32 = 0, 44 45 Int64 = 1, 46 47 Double = 2, 48 49 DateTime = 3, 50 51 Decimal = 4, 52 53 Boolean = 5 54 } 55 56 public enum DataTypeEnum 57 { 58 Int = 0, 59 60 Short = 1, 61 62 Datetime = 3, 63 64 Long = 5, 65 66 Decimal = 6, 67 68 UInt = 7, 69 70 Byte = 8, 71 72 Boolean = 9, 73 74 Bit = 10, 75 76 UShort = 11, 77 78 UByte = 12 79 }
这里为什么要区分源数据和数据库数据类型呢？主要是因为设备一般是int，short，double，float等类型，但是，对应到数据库，有时候比如说使用mongodb，之类的数据库，不一定有完全匹配的，因此需要区分两种数据项，
再来就是T4的模板 ProtocolExecuteTemplate.tt:
1 <#@ template language="C#" #> 2 <#@ assembly name="System.Core" #> 3 <#@ assembly name="Kugar.Core.NetCore" #> 4 <#@ assembly name="Kugar.Device.Service.BLL" #> 5 <#@ assembly name="Kugar.Device.Service.Data" #> 6 <#@ assembly name="MongoDB.Bson" #> 7 8 <#@ import namespace="System.Linq" #> 9 <#@ import namespace="System.Text" #> 10 <#@ import namespace="System.Collections.Generic" #> 11 <#@ import namespace="Kugar.Core.BaseStruct" #> 12 <#@ import namespace="MongoDB.Bson" #> 13 14 using System; 15 using System.Text; 16 using Kugar.Core.BaseStruct; 17 using Kugar.Core.ExtMethod; 18 using Kugar.Core.Log; 19 using Kugar.Device.Service.Data.DTO; 20 using Kugar.Device.Service.Data.Enums; 21 using MongoDB.Bson; 22 23 namespace Kugar.Device.Service.BLL 24 { 25 <# 26 var className="ProtocolExecutor_" + Protocol.Version.Replace('.','_') + "_" + this.GetNextClasID(); 27 #> 28 29 30 public class <#=className #>:IProtocolExecutor 31 { 32 private string _version=""; 33 private ObjectId _protocolID; 34 private readonly DateTime _baseDt=TimeZone.CurrentTimeZone.ToLocalTime(new System.DateTime(1970, 1, 1)); 35 36 public <#=className #> (ObjectId protocolID, string version) 37 { 38 _version=version; 39 _protocolID=protocolID; 40 } 41 42 public ObjectId ProtocolID {get{return _protocolID;}} 43 44 public BsonDocument Execute(byte[] data, int startIndex) 45 { 46 BsonDocument bson=new BsonDocument(); 47 <# 48 foreach(var item in Protocol.Items){ #> 49 bson["<#=item.Key #>"]= <#= DecodeConfig(item,0) #>; 50 <# 51 } 52 #> 53 54 return bson; 55 56 } 57 } 58 }
在直接在循环里输出解析后的语句,并且生成的类名记得后面加多一个随机数。。。。
然后再加一个ProtocolExecuteTemplate.Part.cs的部分类,补全T4模板的功能，因为在T4里IDE支持的不好，，写代码确实难受，，没直接写C#舒服：
1 public partial class ProtocolExecuteTemplate 2 { 3 private static int _classID = 0; 4 5 public ProtocolExecuteTemplate(DTO_ProtocolDataItem protocol) 6 { 7 Protocol = protocol; 8 9 } 10 11 12 13 public DTO_ProtocolDataItem Protocol { set; get; } 14 15 public string DecodeConfig(DTO_ProtocolDataItem.DataItem item,int startIndex) 16 { 17 var str = ""; 18 19 switch (item.SourceType) 20 { 21 case DataTypeEnum.Int: 22 str = $"BitConverter.ToInt32(data,startIndex + {startIndex + item.Pos})"; 23 break; 24 case DataTypeEnum.UInt: 25 str = $"BitConverter.ToUInt32(data,startIndex + {startIndex + item.Pos})"; 26 break; 27 case DataTypeEnum.Short: 28 str = $"BitConverter.ToInt16(data,startIndex + {startIndex + item.Pos})"; 29 break; 30 case DataTypeEnum.Long: 31 str= $"BitConverter.ToInt64(data,startIndex + {startIndex + item.Pos})"; 32 break; 33 case DataTypeEnum.Byte: 34 case DataTypeEnum.UByte: 35 case DataTypeEnum.Bit: 36 str = $"data[startIndex + {startIndex + item.Pos}]"; 37 break; 38 case DataTypeEnum.UShort: 39 str = $"BitConverter.ToUInt16(data,startIndex+{startIndex + item.Pos})"; 40 break; 41 default: 42 throw new ArgumentOutOfRangeException(); 43 } 44 45 if (item.SourceType==DataTypeEnum.Bit) 46 { 47 return byteToBit(str, item.BitIndex); 48 } 49 else 50 { 51 return valueTODBType(str, item.Factor, item.DbType); 52 } 53 } 54 55 private string valueTODBType(string sourceValue, decimal factor, DbDataTypeEnum dbType) 56 { 57 switch (dbType) 58 { 59 case DbDataTypeEnum.Int32: 60 return $" new BsonInt32({(factor > 0 ? $"(int)({factor}{getDecimalShortChar(factor)} * {sourceValue})" : sourceValue)})"; 61 case DbDataTypeEnum.Int64: 62 return $" new BsonInt64({(factor > 0 ? $"(long)({factor}{getDecimalShortChar(factor)} * {sourceValue})" : sourceValue)})"; 63 case DbDataTypeEnum.Double: 64 return $"new BsonDouble({(factor > 0 ? $"(double)({factor}{getDecimalShortChar(factor)} * {sourceValue})" : $"(double){sourceValue}")})"; 65 case DbDataTypeEnum.DateTime: 66 return $"new BsonDateTime(_baseDt.AddSeconds({sourceValue}))"; 67 case DbDataTypeEnum.Decimal: 68 return $"new Decimal128({(factor > 0 ? $"(decimal)({factor}{getDecimalShortChar(factor)} * {sourceValue})" : sourceValue)})"; 69 default: 70 throw new ArgumentOutOfRangeException(nameof(dbType), dbType, null); 71 } 72 } 73 74 private string byteToBit(string data, int index) 75 { 76 switch (index) 77 { 78 case 0: 79 { 80 81 return $"(({data} & 1) ==1)";//(data & 1) == 1; 82 } 83 case 1: 84 { 85 return $"(({data} & 2) ==1)";// (data & 2) == 2; 86 } 87 case 2: 88 { 89 return $"(({data} & 4) ==1)";//(data & 4) == 4; 90 } 91 case 3: 92 { 93 return $"(({data} & 8) ==1)";//(data & 8) == 8; 94 } 95 case 4: 96 { 97 return $"(({data} & 16) ==1)";//(data & 16) == 16; 98 } 99 case 5: 100 { 101 return $"(({data} & 32) ==1)";//(data & 32) == 32; 102 } 103 case 6: 104 { 105 return $"(({data} & 64) ==1)";//(data & 64) == 64; 106 } 107 case 7: 108 { 109 return $"(({data} & 128) ==1)";//(data & 128) == 128; 110 } 111 default: 112 throw new ArgumentOutOfRangeException(nameof(index)); 113 } 114 115 return $"(({data} & {index + 1}) ==1)"; 116 } 117 118 /// <summary> 119 /// 用于判断传入的fator是否需要使用deciaml进行运算,如果有小数点的,则是否decimal缩写m,,如果没有小数点,则使用普通的int类型 120 /// </summary> 121 /// <param name="value"></param> 122 /// <returns></returns> 123 private string getDecimalShortChar(decimal value) 124 { 125 return (value % 1) == 0 ? "" : "m"; 126 } 127 128 public int GetNextClasID() 129 { 130 return Interlocked.Increment(ref _classID); 131 } 132 }
这样，在运行时，即可直接生成可用于解析的类了，而且也不需要for循环判断，生成出来的类如：
1 public class ProtocolExecutor_1_1_000 2 { 3 public BsonDocument Execute(byte[] data, int startIndex) 4 { 5 BsonDocument bson = new BsonDocument(); 6 7 bson["项目名1"] = new BsonInt32(BitConverter.ToInt32(data, startIndex + 偏移量)); 8 bson["项目名2"] = new BsonInt32(BitConverter.ToInt32(data, startIndex + 偏移量)); 9 。。。。。。。 //其他数据项 10 11 return bson; 12 } 13 }
到这一步,就可以根绝配置项生成出对应的C#代码了，剩下的就是动态编译的事情了、将该代码编译出运行时Type，然后传入数据----解析出数据