ReverseWordTransform.cs
5.1 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
using System.Text;
namespace HHECS.Infrastructure.Transfer
{
/// <summary>
/// 按照字节错位的数据转换类
/// </summary>
public class ReverseWordTransform : ByteTransformBase
{
#region Constructor
/// <summary>
/// 实例化一个默认的对象
/// </summary>
public ReverseWordTransform()
{
DataFormat = DataFormat.ABCD;
}
/// <summary>
/// 使用指定的数据解析来实例化对象
/// </summary>
/// <param name="dataFormat">数据规则</param>
public ReverseWordTransform(DataFormat dataFormat) : base(dataFormat)
{
}
#endregion
#region Private Method
/// <summary>
/// 按照字节错位的方法
/// </summary>
/// <param name="buffer">实际的字节数据</param>
/// <param name="index">起始字节位置</param>
/// <param name="length">数据长度</param>
/// <returns>处理过的数据信息</returns>
private byte[] ReverseBytesByWord(byte[] buffer, int index, int length)
{
if (buffer == null) return null;
// copy data
byte[] tmp = new byte[length];
for (int i = 0; i < length; i++)
{
tmp[i] = buffer[index + i];
}
// change
for (int i = 0; i < length / 2; i++)
{
byte b = tmp[i * 2 + 0];
tmp[i * 2 + 0] = tmp[i * 2 + 1];
tmp[i * 2 + 1] = b;
}
return tmp;
}
private byte[] ReverseBytesByWord(byte[] buffer)
{
return ReverseBytesByWord(buffer, 0, buffer.Length);
}
#endregion
#region Public Properties
/// <summary>
/// 字符串数据是否按照字来反转
/// </summary>
public bool IsStringReverse { get; set; }
#endregion
#region Get Value From Bytes
/// <summary>
/// 从缓存中提取short结果
/// </summary>
/// <param name="buffer">缓存数据</param>
/// <param name="index">索引位置</param>
/// <returns>short对象</returns>
public override short TransInt16(byte[] buffer, int index)
{
return base.TransInt16(ReverseBytesByWord(buffer, index, 2), 0);
}
/// <summary>
/// 从缓存中提取ushort结果
/// </summary>
/// <param name="buffer">缓存数据</param>
/// <param name="index">索引位置</param>
/// <returns>ushort对象</returns>
public override ushort TransUInt16(byte[] buffer, int index)
{
return base.TransUInt16(ReverseBytesByWord(buffer, index, 2), 0);
}
/// <summary>
/// 从缓存中提取string结果，使用指定的编码
/// </summary>
/// <param name="buffer">缓存对象</param>
/// <param name="index">索引位置</param>
/// <param name="length">byte数组长度</param>
/// <param name="encoding">字符串的编码</param>
/// <returns>string对象</returns>
public override string TransString(byte[] buffer, int index, int length, Encoding encoding)
{
byte[] tmp = TransByte(buffer, index, length);
if (IsStringReverse)
{
return encoding.GetString(ReverseBytesByWord(tmp));
}
else
{
return encoding.GetString(tmp);
}
}
#endregion
#region Get Bytes From Value
/// <summary>
/// short数组变量转化缓存数据
/// </summary>
/// <param name="values">等待转化的数组</param>
/// <returns>buffer数据</returns>
public override byte[] TransByte(short[] values)
{
byte[] buffer = base.TransByte(values);
return ReverseBytesByWord(buffer);
}
/// <summary>
/// ushort数组变量转化缓存数据
/// </summary>
/// <param name="values">等待转化的数组</param>
/// <returns>buffer数据</returns>
public override byte[] TransByte(ushort[] values)
{
byte[] buffer = base.TransByte(values);
return ReverseBytesByWord(buffer);
}
/// <summary>
/// 使用指定的编码字符串转化缓存数据
/// </summary>
/// <param name="value">等待转化的数据</param>
/// <param name="encoding">字符串的编码方式</param>
/// <returns>buffer数据</returns>
public override byte[] TransByte(string value, Encoding encoding)
{
if (value == null) return null;
byte[] buffer = encoding.GetBytes(value);
buffer = SoftBasic.ArrayExpandToLengthEven(buffer);
if (IsStringReverse)
{
return ReverseBytesByWord(buffer);
}
else
{
return buffer;
}
}
#endregion
}
}