短信收发类代码,CSharp代码库,德仔网

代码语言
代码分类
【CSharp】短信收发类
作者:wuyifa / 发布于2012/8/7/ 447
短信收发类
<div>1/2：PDUdecoding.cs</div>
<div>
?///文 件：PDUdecoding.cs 
///概 要：针对国内短信编码（USC2） 
///组成结构：包含四个函数： 
/// smsDecodedCenterNumber(string srvCenterNumber) 短信中心号编码 
/// smsPDUEncoded(string srvContent) 短信内容编码 
/// smsDecodedNumber(string srvNumber) 接收短信手机号编码 
/// smsDecodedsms(string strCenterNumber, string strNumber, string strSMScontent) 整个短信的编码 
/// 一个字段 
/// string nLength; //要发送内容的长度,由两部分组成,接收手机号加上要发送的内容 
using System; 
using System.Text; 
namespace GSM 
{ 
 public class PDUdecoding 
 { 
 
 public string nLength; //要发送内容的长度,由两部分组成,接收手机号加上要发送的内容 
 
 /// <summary> 
 /// 函数功能：短信内容编码 
 /// 函数名称：smsPDUEncoded(string srvContent) 
 /// 参 数：srvContent 要进行转换的短信内容,string类型 
 /// 返 回 值：编码后的短信内容，string类型 
 /// 函数说明： 
 /// 1，采用Big-Endian 字节顺序的 Unicode 格式编码，也就说把高低位的互换在这里完成了 
 /// 2，将转换后的短信内容存进字节数组 
 /// 3，去掉在进行Unicode格式编码中，两个字节中的"-",例如：00-21，变成0021 
 /// 4，将整条短信内容的长度除2，保留两位16进制数 
 /// </summary> 
 public string smsPDUEncoded(string srvContent) 
 { 
 Encoding encodingUTF = System.Text.Encoding.BigEndianUnicode; 
 string s = null; 
 byte[] encodedBytes = encodingUTF.GetBytes(srvContent); 
 for (int i = 0; i < encodedBytes.Length; i++) 
 { 
 s += BitConverter.ToString(encodedBytes, i, 1); 
 } 
 s = String.Format("{0:X2}{1}", s.Length / 2, s); 
 
 return s; 
 } 
 
 /// <summary> 
 /// 函数功能：短信中心号编码 
 /// 函数名称：smsDecodedCenterNumber(string srvCenterNumber) 
 /// 参 数：srvCenterNumber 要进行转换的短信中心号,string类型 
 /// 返 回 值：编码后的短信中心号，string类型 
 /// 函数说明： 
 /// 1，将奇数位和偶数位交换。 
 /// 2，短信中心号奇偶数交换后，看看长度是否为偶数，如果不是，最后添加F 
 /// 3，加上短信中心号类型，91为国际化 
 /// 4，计算编码后的短信中心号长度，并格化成二位的十六进制 
 /// </summary> 
 public string smsDecodedCenterNumber(string srvCenterNumber) 
 { 
 string s = null; 
 int nLength = srvCenterNumber.Length; 
 for (int i = 1; i < nLength; i += 2) //奇偶互换 
 { 
 s += srvCenterNumber[i]; 
 s += srvCenterNumber[i - 1]; 
 } 
 if (!(nLength % 2 == 0)) //是否为偶数，不是就加上F，并对最后一位与加上的F位互换 
 { 
 s += 'F'; 
 s += srvCenterNumber[nLength - 1]; 
 } 
 s = String.Format("91{0}", s); //加上91,代表短信中心类型为国际化 
 s = String.Format("{0:X2}{1}", s.Length / 2, s); //编码后短信中心号长度，并格式化成二位十六制 
 return s; 
 } 
 
 /// <summary> 
 /// 函数功能：接收短信手机号编码 
 /// 函数名称：smsDecodedNumber(string srvNumber) 
 /// 参 数：srvCenterNumber 要进行转换的短信中心号,string类型 
 /// 返 回 值：编码后的接收短信手机号，string类型 
 /// 函数说明： 
 /// 1，检查当前接收手机号是否按标准格式书写，不是，就补上&ldquo;86&rdquo; 
 /// 1，将奇数位和偶数位交换。 
 /// 2，短信中心号奇偶数交换后，看看长度是否为偶数，如果不是，最后添加F 
 /// </summary> 
 public string smsDecodedNumber(string srvNumber) 
 { 
 string s = null; 
 if (!(srvNumber.Substring(0, 2) == "86")) 
 { 
 srvNumber = String.Format("86{0}", srvNumber); //检查当前接收手机号是否按标准格式书写，不是，就补上&ldquo;86&rdquo; 
 } 
 int nLength = srvNumber.Length; 
 for (int i = 1; i < nLength; i += 2) //将奇数位和偶数位交换 
 { 
 s += srvNumber[i]; 
 s += srvNumber[i - 1]; 
 } 
 if (!(nLength % 2 == 0)) //是否为偶数，不是就加上F，并对最后一位与加上的F位互换 
 { 
 s += 'F'; 
 s += srvNumber[nLength - 1]; 
 } 
 return s; 
 } 
 
 /// <summary> 
 /// 函数功能：整个短信的编码 
 /// 函数名称：smsDecodedsms(string strCenterNumber, string strNumber, string strSMScontent) 
 /// 参 数：strCenterNumber 要进行转换的短信中心号,string类型 
 /// strNumber 接收手机号码，string类型 
 /// strSMScontent 短信内容 
 /// 返 回 值：完整的短信编码，可以在AT指令中执行，string类型 
 /// 函数说明： 
 /// 11000D91和000800 在国内，根据PDU编码原则，我们写死在此，详细解释请看我的文章 
 /// </summary> 
 public string smsDecodedsms(string strCenterNumber, string strNumber, string strSMScontent) 
 { 
 string s = String.Format("{0}11000D91{1}000800{2}", smsDecodedCenterNumber(strCenterNumber), smsDecodedNumber(strNumber), smsPDUEncoded(strSMScontent)); 
 nLength = String.Format("{0:D2}", (s.Length - smsDecodedCenterNumber(strCenterNumber).Length) / 2); 
 //获取短信内容加上手机号码长度 
 return s; 
 } 
 } 
}
<div>
2/2：JustinIO.cs</div>
<div>?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
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272 using System; 
using System.Runtime.InteropServices; 
 
namespace JustinIO 
{ 
 class CommPort 
 { 
 public string PortNum; 
 public int BaudRate; 
 public byte ByteSize; 
 public byte Parity; // 0-4=no,odd,even,mark,space 
 public byte StopBits; // 0,1,2 = 1, 1.5, 2 
 public int ReadTimeout; 
 
 //comm port win32 file handle 
 private int hComm = -1; 
 
 public bool Opened = false; 
 
 //win32 api constants 
 private const uint GENERIC_READ = 0x80000000; 
 private const uint GENERIC_WRITE = 0x40000000; 
 private const int OPEN_EXISTING = 3; 
 private const int INVALID_HANDLE_VALUE = -1; 
 
 [StructLayout(LayoutKind.Sequential)] 
 public struct DCB 
 { 
 //taken from c struct in platform sdk 
 public int DCBlength; // sizeof(DCB) 
 public int BaudRate; // 指定当前波特率 current baud rate 
 // these are the c struct bit fields, bit twiddle flag to set 
 public int fBinary; // 指定是否允许二进制模式,在windows95中必须主TRUE binary mode, no EOF check 
 public int fParity; // 指定是否允许奇偶校验 enable parity checking 
 public int fOutxCtsFlow; // 指定CTS是否用于检测发送控制，当为TRUE是CTS为OFF，发送将被挂起。 CTS output flow control 
 public int fOutxDsrFlow; // 指定CTS是否用于检测发送控制 DSR output flow control 
 public int fDtrControl; // DTR_CONTROL_DISABLE值将DTR置为OFF, DTR_CONTROL_ENABLE值将DTR置为ON, DTR_CONTROL_HANDSHAKE允许DTR"握手" DTR flow control type 
 public int fDsrSensitivity; // 当该值为TRUE时DSR为OFF时接收的字节被忽略 DSR sensitivity 
 public int fTXContinueOnXoff; // 指定当接收缓冲区已满,并且驱动程序已经发送出XoffChar字符时发送是否停止。TRUE时，在接收缓冲区接收到缓冲区已满的字节XoffLim且驱动程序已经发送出XoffChar字符中止接收字节之后，发送继续进行。　FALSE时，在接收缓冲区接收到代表缓冲区已空的字节XonChar且驱动程序已经发送出恢复发送的XonChar之后，发送继续进行。XOFF continues Tx 
 public int fOutX; // TRUE时，接收到XoffChar之后便停止发送接收到XonChar之后将重新开始 XON/XOFF out flow control 
 public int fInX; // TRUE时，接收缓冲区接收到代表缓冲区满的XoffLim之后，XoffChar发送出去接收缓冲区接收到代表缓冲区空的XonLim之后，XonChar发送出去 XON/XOFF in flow control 
 public int fErrorChar; // 该值为TRUE且fParity为TRUE时，用ErrorChar 成员指定的字符代替奇偶校验错误的接收字符 enable error replacement 
 public int fNull; // eTRUE时，接收时去掉空（0值）字节 enable null stripping 
 public int fRtsControl; // RTS flow control 
 
 /* 
 RTS_CONTROL_DISABLE时,RTS置为OFF 
 RTS_CONTROL_ENABLE时, RTS置为ON 
 RTS_CONTROL_HANDSHAKE时, 
 当接收缓冲区小于半满时RTS为ON 
 当接收缓冲区超过四分之三满时RTS为OFF 
 RTS_CONTROL_TOGGLE时, 
 当接收缓冲区仍有剩余字节时RTS为ON ,否则缺省为OFF 
 */
 
 public int fAbortOnError; // TRUE时,有错误发生时中止读和写操作 abort on error 
 public int fDummy2; // 未使用 reserved 
 
 public uint flags; 
 public ushort wReserved; // 未使用,必须为0 not currently used 
 public ushort XonLim; // 指定在XON字符发送这前接收缓冲区中可允许的最小字节数 transmit XON threshold 
 public ushort XoffLim; // 指定在XOFF字符发送这前接收缓冲区中可允许的最小字节数 transmit XOFF threshold 
 public byte ByteSize; // 指定端口当前使用的数据位 number of bits/byte, 4-8 
 public byte Parity; // 指定端口当前使用的奇偶校验方法,可能为:EVENPARITY,MARKPARITY,NOPARITY,ODDPARITY 0-4=no,odd,even,mark,space 
 public byte StopBits; // 指定端口当前使用的停止位数,可能为:ONESTOPBIT,ONE5STOPBITS,TWOSTOPBITS 0,1,2 = 1, 1.5, 2 
 public char XonChar; // 指定用于发送和接收字符XON的值 Tx and Rx XON character 
 public char XoffChar; // 指定用于发送和接收字符XOFF值 Tx and Rx XOFF character 
 public char ErrorChar; // 本字符用来代替接收到的奇偶校验发生错误时的值 error replacement character 
 public char EofChar; // 当没有使用二进制模式时,本字符可用来指示数据的结束 end of input character 
 public char EvtChar; // 当接收到此字符时,会产生一个事件 received event character 
 public ushort wReserved1; // 未使用 reserved; do not use 
 } 
 
 [StructLayout(LayoutKind.Sequential)] 
 private struct COMMTIMEOUTS 
 { 
 public int ReadIntervalTimeout; 
 public int ReadTotalTimeoutMultiplier; 
 public int ReadTotalTimeoutConstant; 
 public int WriteTotalTimeoutMultiplier; 
 public int WriteTotalTimeoutConstant; 
 } 
 
 [StructLayout(LayoutKind.Sequential)] 
 private struct OVERLAPPED 
 { 
 public int Internal; 
 public int InternalHigh; 
 public int Offset; 
 public int OffsetHigh; 
 public int hEvent; 
 } 
 
 [DllImport("kernel32.dll")] 
 private static extern int CreateFile( 
 string lpFileName, // 要打开的串口名称 
 uint dwDesiredAccess, // 指定串口的访问方式，一般设置为可读可写方式 
 int dwShareMode, // 指定串口的共享模式，串口不能共享，所以设置为0 
 int lpSecurityAttributes, // 设置串口的安全属性，WIN9X下不支持，应设为NULL 
 int dwCreationDisposition, // 对于串口通信，创建方式只能为OPEN_EXISTING 
 int dwFlagsAndAttributes, // 指定串口属性与标志，设置为FILE_FLAG_OVERLAPPED(重叠I/O操作)，指定串口以异步方式通信 
 int hTemplateFile // 对于串口通信必须设置为NULL 
 ); 
 [DllImport("kernel32.dll")] 
 private static extern bool GetCommState( 
 int hFile, //通信设备句柄 
 ref DCB lpDCB // 设备控制块DCB 
 ); 
 [DllImport("kernel32.dll")] 
 private static extern bool BuildCommDCB( 
 string lpDef, // 设备控制字符串 
 ref DCB lpDCB // 设备控制块 
 ); 
 [DllImport("kernel32.dll")] 
 private static extern bool SetCommState( 
 int hFile, // 通信设备句柄 
 ref DCB lpDCB // 设备控制块 
 ); 
 [DllImport("kernel32.dll")] 
 private static extern bool GetCommTimeouts( 
 int hFile, // 通信设备句柄 handle to comm device 
 ref COMMTIMEOUTS lpCommTimeouts // 超时时间 time-out values 
 ); 
 [DllImport("kernel32.dll")] 
 private static extern bool SetCommTimeouts( 
 int hFile, // 通信设备句柄 handle to comm device 
 ref COMMTIMEOUTS lpCommTimeouts // 超时时间 time-out values 
 ); 
 [DllImport("kernel32.dll")] 
 private static extern bool ReadFile( 
 int hFile, // 通信设备句柄 handle to file 
 byte[] lpBuffer, // 数据缓冲区 data buffer 
 int nNumberOfBytesToRead, // 多少字节等待读取 number of bytes to read 
 ref int lpNumberOfBytesRead, // 读取多少字节 number of bytes read 
 ref OVERLAPPED lpOverlapped // 溢出缓冲区 overlapped buffer 
 ); 
 [DllImport("kernel32.dll")] 
 private static extern bool WriteFile( 
 int hFile, // 通信设备句柄 handle to file 
 byte[] lpBuffer, // 数据缓冲区 data buffer 
 int nNumberOfBytesToWrite, // 多少字节等待写入 number of bytes to write 
 ref int lpNumberOfBytesWritten, // 已经写入多少字节 number of bytes written 
 ref OVERLAPPED lpOverlapped // 溢出缓冲区 overlapped buffer 
 ); 
 [DllImport("kernel32.dll")] 
 private static extern bool CloseHandle( 
 int hObject // handle to object 
 ); 
 [DllImport("kernel32.dll")] 
 private static extern uint GetLastError(); 
 
 public void Open() 
 { 
 
 DCB dcbCommPort = new DCB(); 
 COMMTIMEOUTS ctoCommPort = new COMMTIMEOUTS(); 
 
 // 打开串口 OPEN THE COMM PORT. 
 hComm = CreateFile(PortNum, GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0); 
 // 如果串口没有打开，就打开 IF THE PORT CANNOT BE OPENED, BAIL OUT. 
 if (hComm == INVALID_HANDLE_VALUE) 
 { 
 throw (new ApplicationException("非法操作，不能打开串口！")); 
 } 
 
 // 设置通信超时时间 SET THE COMM TIMEOUTS. 
 GetCommTimeouts(hComm, ref ctoCommPort); 
 ctoCommPort.ReadTotalTimeoutConstant = ReadTimeout; 
 ctoCommPort.ReadTotalTimeoutMultiplier = 0; 
 ctoCommPort.WriteTotalTimeoutMultiplier = 0; 
 ctoCommPort.WriteTotalTimeoutConstant = 0; 
 SetCommTimeouts(hComm, ref ctoCommPort); 
 
 // 设置串口 SET BAUD RATE, PARITY, WORD SIZE, AND STOP BITS. 
 GetCommState(hComm, ref dcbCommPort); 
 dcbCommPort.BaudRate = BaudRate; 
 dcbCommPort.flags = 0; 
 //dcb.fBinary=1; 
 dcbCommPort.flags |= 1; 
 if (Parity > 0) 
 { 
 //dcb.fParity=1 
 dcbCommPort.flags |= 2; 
 } 
 dcbCommPort.Parity = Parity; 
 dcbCommPort.ByteSize = ByteSize; 
 dcbCommPort.StopBits = StopBits; 
 //if (!BuildCommDCB("9600,n,8,1 ", ref dcbCommPort)) 
 //{ 
 // throw (new ApplicationException("非法操作，不能打开串口！ ")); 
 //} 
 
 if (!SetCommState(hComm, ref dcbCommPort)) 
 { 
 //uint ErrorNum=GetLastError(); 
 throw (new ApplicationException("非法操作，不能打开串口！")); 
 } 
 //unremark to see if setting took correctly 
 //DCB dcbCommPort2 = new DCB(); 
 //GetCommState(hComm, ref dcbCommPort2); 
 Opened = true; 
 } 
 
 public void Close() 
 { 
 if (hComm != INVALID_HANDLE_VALUE) 
 { 
 CloseHandle(hComm); 
 } 
 } 
 
 public byte[] Read(int NumBytes) 
 { 
 byte[] BufBytes; 
 byte[] OutBytes; 
 BufBytes = new byte[NumBytes]; 
 if (hComm != INVALID_HANDLE_VALUE) 
 { 
 OVERLAPPED ovlCommPort = new OVERLAPPED(); 
 int BytesRead = 0; 
 ReadFile(hComm, BufBytes, NumBytes, ref BytesRead, ref ovlCommPort); 
 OutBytes = new byte[BytesRead]; 
 Array.Copy(BufBytes, OutBytes, BytesRead); 
 } 
 else
 { 
 throw (new ApplicationException("串口未打开！")); 
 } 
 return OutBytes; 
 } 
 
 public void Write(byte[] WriteBytes) 
 { 
 if (hComm != INVALID_HANDLE_VALUE) 
 { 
 OVERLAPPED ovlCommPort = new OVERLAPPED(); 
 int BytesWritten = 0; 
 WriteFile(hComm, WriteBytes, WriteBytes.Length, ref BytesWritten, ref ovlCommPort); 
 } 
 else
 { 
 throw (new ApplicationException("串口未打开！")); 
 } 
 } 
 } 
 
 class HexCon 
 { 
 // 把十六进制字符串转换成字节型和把字节型转换成十六进制字符串 converter hex string to byte and byte to hex string 
 public static string ByteToString(byte[] InBytes) 
 { 
 string StringOut = ""; 
 foreach (byte InByte in InBytes) 
 { 
 StringOut = StringOut + String.Format("{0:X2} ", InByte); 
 } 
 return StringOut; 
 } 
 public static byte[] StringToByte(string InString) 
 { 
 string[] ByteStrings; 
 ByteStrings = InString.Split(" ".ToCharArray()); 
 byte[] ByteOut; 
 ByteOut = new byte[ByteStrings.Length - 1]; 
 for (int i = 0; i == ByteStrings.Length - 1; i++) 
 { 
 ByteOut[i] = Convert.ToByte(("0x" + ByteStrings[i])); 
 } 
 return ByteOut; 
 } 
 } 
} 
</div>
试试其它关键字
　短信收发类　
同语言下
可能有用的
wuyifa贡献的其它代码(1)
.短信收发类