|
|
using System;
|
|
|
using System.Collections.Generic;
|
|
|
using System.Linq;
|
|
|
using System.Text;
|
|
|
|
|
|
namespace demo.ClassHelper.TranslateFormat
|
|
|
{
|
|
|
class ConvertHelper
|
|
|
{
|
|
|
public const Byte ASCII_0 = 48;
|
|
|
public const Byte ASCII_9 = 57;
|
|
|
public const Byte ASCII_A = 65;
|
|
|
public const Byte ASCII_F = 70;
|
|
|
public const Byte ASCII_Z = 90;
|
|
|
public const Byte ASCII_a = 97;
|
|
|
public const Byte ASCII_f = 102;
|
|
|
public const Byte ASCII_z = 122;
|
|
|
|
|
|
/// <summary>
|
|
|
/// 字节转换为字符串
|
|
|
/// </summary>
|
|
|
/// <param name="val"></param>
|
|
|
/// <returns></returns>
|
|
|
public static String ByteToHexChar(Byte val)
|
|
|
{
|
|
|
return val.ToString("X2");
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 字节转换为字符串
|
|
|
/// </summary>
|
|
|
/// <param name="val"></param>
|
|
|
/// <returns></returns>
|
|
|
public static String ByteToBitString(Byte val)
|
|
|
{
|
|
|
if (val == 0)
|
|
|
{
|
|
|
return "00000000";
|
|
|
}
|
|
|
if (val == 255)
|
|
|
{
|
|
|
return "11111111";
|
|
|
}
|
|
|
|
|
|
String ret = String.Empty;
|
|
|
Int32 bitval = 0;
|
|
|
for (int bitidx = 7; bitidx > -1; --bitidx)
|
|
|
{
|
|
|
bitval = val & (1 << bitidx);
|
|
|
if (bitval > 0)
|
|
|
{
|
|
|
ret = ret + "1";
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
ret = ret + "0";
|
|
|
}
|
|
|
}
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 2个HEX字符转换为1个字节数组
|
|
|
/// </summary>
|
|
|
/// <param name="hexstr">"A1"</param>
|
|
|
/// <param name="bytes">161</param>
|
|
|
/// <returns></returns>
|
|
|
public static Boolean HexStringToByte(String hexstr, out Byte byteval)
|
|
|
{
|
|
|
byteval = 0;
|
|
|
if (hexstr.Length != 2)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
byteval = Convert.ToByte(hexstr, 16);
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// HEX字符串转换为字节数组
|
|
|
/// </summary>
|
|
|
/// <param name="hexstr"></param>
|
|
|
/// <param name="bytes"></param>
|
|
|
/// <returns></returns>
|
|
|
public static Boolean HexStringToBytes(String hexstr, out Byte[] bytes)
|
|
|
{
|
|
|
bytes = null;
|
|
|
if ((hexstr == null) || (hexstr.Length < 2))
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
if (hexstr.Length % 2 == 1)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
int bytelen = hexstr.Length / 2;
|
|
|
if (bytelen < 1)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
bytes = new Byte[bytelen];
|
|
|
|
|
|
String curbytestr = String.Empty;
|
|
|
for (int bidx = 0; bidx < bytelen; bidx++)
|
|
|
{
|
|
|
curbytestr = hexstr.Substring(bidx * 2, 2);
|
|
|
//数字的进制，它必须是 2、8、10和16.
|
|
|
bytes[bidx] = Convert.ToByte(curbytestr, 16);
|
|
|
}
|
|
|
|
|
|
if (bytes == null || bytes.Length < 1)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// HEX字符串转换为字节数组
|
|
|
/// </summary>
|
|
|
/// <param name="hexstr"></param>
|
|
|
/// <param name="bytes"></param>
|
|
|
/// <returns></returns>
|
|
|
public static Boolean HexStringToBytesWithSplitter(String hexstr, out Byte[] bytes)
|
|
|
{
|
|
|
bytes = null;
|
|
|
|
|
|
if (hexstr == null || hexstr.Length < 2)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
int charidx = 0;
|
|
|
StringBuilder strbuild = new StringBuilder(hexstr.Length);
|
|
|
//对每个字符进行判断,过滤非法字符
|
|
|
while (charidx < hexstr.Length)
|
|
|
{
|
|
|
//A-65, F-70,a-97,f-102, 0-48 9-57
|
|
|
|
|
|
if ((hexstr[charidx] >= ConvertHelper.ASCII_0 && hexstr[charidx] <= ConvertHelper.ASCII_9) ||
|
|
|
(hexstr[charidx] >= ConvertHelper.ASCII_A && hexstr[charidx] <= ConvertHelper.ASCII_F) ||
|
|
|
(hexstr[charidx] >= ConvertHelper.ASCII_a && hexstr[charidx] <= ConvertHelper.ASCII_f))
|
|
|
{
|
|
|
strbuild.Append(hexstr[charidx]);
|
|
|
}
|
|
|
|
|
|
charidx++;
|
|
|
}
|
|
|
|
|
|
String purehexstr = strbuild.ToString();
|
|
|
return HexStringToBytes(purehexstr, out bytes);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 字节数组转换为字符串
|
|
|
/// </summary>
|
|
|
/// <param name="bytes"></param>
|
|
|
/// <returns></returns>
|
|
|
public static String BytesToHexString(Byte[] bytes)
|
|
|
{
|
|
|
if (bytes == null || bytes.Length < 1)
|
|
|
{
|
|
|
return String.Empty;
|
|
|
}
|
|
|
|
|
|
StringBuilder str = new StringBuilder(bytes.Length * 2);
|
|
|
for (int i = 0; i < bytes.Length; i++)
|
|
|
{
|
|
|
str.Append(bytes[i].ToString("X2"));
|
|
|
}
|
|
|
|
|
|
return str.ToString();
|
|
|
}
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
/// 字节数组转换为字符串
|
|
|
/// </summary>
|
|
|
/// <param name="bytes"></param>
|
|
|
/// <param name="start">待转换的首个字节下标</param>
|
|
|
/// <param name="len"></param>
|
|
|
/// <param name="eachlinebytes">每隔多少字节,就插入一个换行符.0表示不换行</param>
|
|
|
/// <returns></returns>
|
|
|
public static String BytesToHexString(Byte[] bytes, Int32 start, Int32 len, Int32 eachlinebytes)
|
|
|
{
|
|
|
if (bytes == null || bytes.Length < 1 || start < 0 || len < 1 || start + len > bytes.Length)
|
|
|
{
|
|
|
return String.Empty;
|
|
|
}
|
|
|
|
|
|
Int32 curlinebytes = 0;
|
|
|
StringBuilder str = new StringBuilder(bytes.Length * 2);
|
|
|
for (int i = 0; i < len; i++)
|
|
|
{
|
|
|
str.Append(bytes[i + start].ToString("X2"));
|
|
|
if (eachlinebytes > 0)
|
|
|
{
|
|
|
curlinebytes++;
|
|
|
if (curlinebytes >= eachlinebytes)
|
|
|
{
|
|
|
str.Append(Environment.NewLine);
|
|
|
curlinebytes = 0;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return str.ToString();
|
|
|
}
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
/// 字节数组转换为带间隔符的字符串,显示用
|
|
|
/// </summary>
|
|
|
/// <param name="bytes"></param>
|
|
|
/// <param name="start">待转换的首个字节下标</param>
|
|
|
/// <param name="len"></param>
|
|
|
/// <param name="splitter"></param>
|
|
|
/// <param name="eachlinebytes">每隔多少字节,就插入一个换行符.0表示不换行</param>
|
|
|
/// <returns></returns>
|
|
|
public static String BytesToHexString(Byte[] bytes, Int32 start, Int32 len, Char splitter, Int32 eachlinebytes)
|
|
|
{
|
|
|
if (bytes == null || bytes.Length < 1 || start < 0 || len < 1 || start + len > bytes.Length)
|
|
|
{
|
|
|
return String.Empty;
|
|
|
}
|
|
|
|
|
|
Int32 curlinebytes = 0;
|
|
|
StringBuilder str = new StringBuilder(bytes.Length * 2);
|
|
|
for (int i = 0; i < bytes.Length; i++)
|
|
|
{
|
|
|
str.Append(bytes[i + start].ToString("X2"));
|
|
|
if ((Byte)(splitter) != 0)
|
|
|
{
|
|
|
str.Append(splitter);
|
|
|
}
|
|
|
|
|
|
if (eachlinebytes > 0)
|
|
|
{
|
|
|
curlinebytes++;
|
|
|
if (curlinebytes >= eachlinebytes)
|
|
|
{
|
|
|
str.Append(Environment.NewLine);
|
|
|
curlinebytes = 0;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
str.Remove(str.Length - 1, 1);
|
|
|
return str.ToString();
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 字节数组转换为ASCII字符串
|
|
|
/// </summary>
|
|
|
/// <param name="bytes"></param>
|
|
|
/// <returns></returns>
|
|
|
public static String BytesToString(Byte[] bytes)
|
|
|
{
|
|
|
String ret = Encoding.Default.GetString(bytes);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 1个字节的BCD转换为HEX
|
|
|
/// 0x12->12
|
|
|
/// </summary>
|
|
|
/// <param name="bcd">BCD字节</param>
|
|
|
/// <returns>Int32</returns>
|
|
|
public static Byte ByteBCDToHex(Byte bcd)
|
|
|
{
|
|
|
Byte result = (Byte)(bcd & 0x0F); //个位
|
|
|
bcd >>= 4;
|
|
|
result += (Byte)(bcd * 10); //十位
|
|
|
return result; //返回结果
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 把数组里的每个字节,都从HEX 转换为BCD
|
|
|
/// </summary>
|
|
|
/// <returns></returns>
|
|
|
public static Boolean ByteArrayHexToBCD(Byte[] hexbytes, Int32 hexstart, Byte[] bcdbytes, Int32 bcdstart, Int32 len)
|
|
|
{
|
|
|
if (hexbytes == null || bcdbytes == null ||
|
|
|
hexbytes.Length < 1 || bcdbytes.Length < 1 ||
|
|
|
hexstart < 0 || bcdstart < 0 ||
|
|
|
hexstart + len > hexbytes.Length ||
|
|
|
bcdstart + len > bcdbytes.Length)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
for (Int32 idx = 0; idx < len; ++idx)
|
|
|
{
|
|
|
bcdbytes[bcdstart + idx] = ByteHexToBCD(hexbytes[hexstart + idx]);
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 把数组里的每个字节,都从BCD转换为HEX
|
|
|
/// </summary>
|
|
|
/// <returns></returns>
|
|
|
public static Boolean ByteArrayBCDToHex(Byte[] bcdbytes, Int32 bcdstart, Byte[] hexbytes, Int32 hexstart, Int32 len)
|
|
|
{
|
|
|
if (hexbytes == null || bcdbytes == null ||
|
|
|
hexbytes.Length < 1 || bcdbytes.Length < 1 ||
|
|
|
hexstart < 0 || bcdstart < 0 ||
|
|
|
hexstart + len > hexbytes.Length ||
|
|
|
bcdstart + len > bcdbytes.Length)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
for (Int32 idx = 0; idx < len; ++idx)
|
|
|
{
|
|
|
hexbytes[hexstart + idx] = ByteBCDToHex(bcdbytes[bcdstart + idx]);
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 1个字节的HEX转换为BCD
|
|
|
/// 64->0x64
|
|
|
/// </summary>
|
|
|
/// <param name="bcd">BCD字节</param>
|
|
|
/// <returns>Int32</returns>
|
|
|
public static Byte ByteHexToBCD(Byte val)
|
|
|
{
|
|
|
//如果超过99,则转换99
|
|
|
if (val > 99)
|
|
|
{
|
|
|
return 0x99;
|
|
|
}
|
|
|
Byte lowval = (Byte)(val % 10);//个位
|
|
|
Byte highval = (Byte)((val / 10) % 10);//十位
|
|
|
Byte ret = (Byte)(lowval + (highval << 4));
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// ASCII字符串转换为字节数组
|
|
|
/// </summary>
|
|
|
/// <param name="asciistr"></param>
|
|
|
/// <param name="bytes"></param>
|
|
|
/// <returns></returns>
|
|
|
public static Boolean StringToBytes(String asciistr, out Byte[] bytes)
|
|
|
{
|
|
|
bytes = Encoding.Default.GetBytes(asciistr);
|
|
|
if (bytes == null || bytes.Length < 1)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Boolean 转换为 Int32
|
|
|
/// </summary>
|
|
|
/// <param name="bl"></param>
|
|
|
/// <returns></returns>
|
|
|
public static Int32 BooleanToInt32(Boolean bl)
|
|
|
{
|
|
|
return bl ? 1 : 0;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Boolean 转换为 Int32 的字符串
|
|
|
/// </summary>
|
|
|
/// <param name="bl"></param>
|
|
|
/// <returns></returns>
|
|
|
public static String BooleanToInt32String(Boolean bl)
|
|
|
{
|
|
|
return bl ? "1" : "0";
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Int32 转换为 Boolean
|
|
|
/// </summary>
|
|
|
/// <param name="intval"></param>
|
|
|
/// <returns></returns>
|
|
|
public static Boolean Int32ToBoolean(Int32 intval)
|
|
|
{
|
|
|
return (intval == 0) ? false : true;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// Int32 的字符串 转换为 Boolean
|
|
|
/// </summary>
|
|
|
/// <param name="intstr"></param>
|
|
|
/// <returns></returns>
|
|
|
public static Boolean Int32StringToBoolean(String intstr)
|
|
|
{
|
|
|
if (intstr.Length < 1)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
return (intstr[0] == '0') ? false : true;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 各种枚举值转换为Int32String
|
|
|
/// </summary>
|
|
|
/// <param name="bl"></param>
|
|
|
/// <returns></returns>
|
|
|
public static String Int32ToString(Int32 enumval)
|
|
|
{
|
|
|
return enumval.ToString();
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 使用指定间隔符,把字符串分割为多个子串,合并为List
|
|
|
/// </summary>
|
|
|
/// <param name="rawdata"></param>
|
|
|
/// <param name="splitter"></param>
|
|
|
/// <param name="strlist"></param>
|
|
|
/// <returns></returns>
|
|
|
public static Boolean StringToIntArray(String rawdata, char splitter, ref Int32[] intarray)
|
|
|
{
|
|
|
List<String> strlst = null;
|
|
|
Boolean bl = StringToList(rawdata, splitter, ref strlst);
|
|
|
if (!bl)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
List<int> intlist = new List<int>();
|
|
|
Int32 val;
|
|
|
for (int i = 0; i < strlst.Count; i++)
|
|
|
{
|
|
|
bl = Int32.TryParse(strlst[i], out val);
|
|
|
if (bl)
|
|
|
{
|
|
|
intlist.Add(val);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (intlist.Count < 1)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
intarray = intlist.ToArray();
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
/// 使用指定间隔符,把List合并为一个字符串
|
|
|
/// </summary>
|
|
|
/// <param name="strlist"></param>
|
|
|
/// <param name="splitter"></param>
|
|
|
/// <param name="result"></param>
|
|
|
/// <returns></returns>
|
|
|
public static Boolean ListToString(List<String> strlist, char splitter, out String result)
|
|
|
{
|
|
|
result = String.Empty;
|
|
|
if ((strlist == null || strlist.Count < 1))
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
foreach (String item in strlist)
|
|
|
{
|
|
|
result = result + item + splitter;
|
|
|
}
|
|
|
|
|
|
result = result.Remove(result.Length - 1, 1);
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
|
|
|
///// <summary>
|
|
|
///// 使用指定间隔符,把字符串分割为多个子串,合并为BindingList
|
|
|
///// </summary>
|
|
|
///// <param name="rawdata"></param>
|
|
|
///// <param name="splitter"></param>
|
|
|
///// <param name="strlist"></param>
|
|
|
///// <returns></returns>
|
|
|
//public static Boolean StringToBindingList(String rawdata, char splitter, out ObservableCollection<String> strlist)
|
|
|
//{
|
|
|
// strlist = new ObservableCollection<string>();
|
|
|
// if (String.IsNullOrEmpty(rawdata))
|
|
|
// {
|
|
|
// return false;
|
|
|
// }
|
|
|
|
|
|
// String[] ary = rawdata.Split(splitter);
|
|
|
// if ((ary == null) || (ary.Length < 1))
|
|
|
// {
|
|
|
// return false;
|
|
|
// }
|
|
|
|
|
|
// for (int i = 0; i < ary.Length; i++)
|
|
|
// {
|
|
|
// strlist.Add(ary[i]);
|
|
|
// }
|
|
|
// return true;
|
|
|
//}
|
|
|
|
|
|
///// <summary>
|
|
|
///// 使用指定间隔符,把BindingList合并为一个字符串
|
|
|
///// </summary>
|
|
|
///// <param name="strlist"></param>
|
|
|
///// <param name="splitter"></param>
|
|
|
///// <param name="result"></param>
|
|
|
///// <returns></returns>
|
|
|
//public static Boolean BindingListToString(ObservableCollection<String> strlist, char splitter, out String result)
|
|
|
//{
|
|
|
// result = String.Empty;
|
|
|
// if ((strlist == null || strlist.Count < 1))
|
|
|
// {
|
|
|
// return false;
|
|
|
// }
|
|
|
|
|
|
// StringBuilder tmpstr = new StringBuilder(4096);
|
|
|
// foreach (String item in strlist)
|
|
|
// {
|
|
|
// tmpstr.Append(item);
|
|
|
// tmpstr.Append(splitter);
|
|
|
// }
|
|
|
|
|
|
// tmpstr.Remove(result.Length - 1, 1);
|
|
|
// result = tmpstr.ToString();
|
|
|
// return true;
|
|
|
//}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 使用指定间隔符,把字符串分割为多个子串,合并为List
|
|
|
/// </summary>
|
|
|
/// <param name="rawdata"></param>
|
|
|
/// <param name="splitter"></param>
|
|
|
/// <param name="strlist"></param>
|
|
|
/// <returns></returns>
|
|
|
public static Boolean StringToIntList(String rawdata, char splitter, ref List<Int32> intlist)
|
|
|
{
|
|
|
List<String> strlst = null;
|
|
|
Boolean bl = StringToList(rawdata, splitter, ref strlst);
|
|
|
if (!bl)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
intlist = new List<int>();
|
|
|
Int32 val;
|
|
|
for (int i = 0; i < strlst.Count; i++)
|
|
|
{
|
|
|
bl = Int32.TryParse(strlst[i], out val);
|
|
|
if (bl)
|
|
|
{
|
|
|
intlist.Add(val);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return (intlist.Count > 0);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 使用指定间隔符,把字符串分割为多个子串,合并为List
|
|
|
/// </summary>
|
|
|
/// <param name="rawdata"></param>
|
|
|
/// <param name="splitter"></param>
|
|
|
/// <param name="strlist"></param>
|
|
|
/// <returns></returns>
|
|
|
public static Boolean StringToList(String rawdata, char splitter, ref List<String> strlist)
|
|
|
{
|
|
|
if (String.IsNullOrEmpty(rawdata))
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
String[] ary = rawdata.Split(splitter);
|
|
|
if ((ary == null) || (ary.Length < 1))
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
if (strlist == null)
|
|
|
{
|
|
|
strlist = new List<string>();
|
|
|
}
|
|
|
strlist.AddRange(ary);
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 把字符串列表转换为Boolean数组
|
|
|
/// </summary>
|
|
|
/// <param name="boolliststr"></param>
|
|
|
/// <param name="boolary"></param>
|
|
|
/// <returns></returns>
|
|
|
public static Boolean StringToBooleanArray(String boolliststr, ref Boolean[] boolary)
|
|
|
{
|
|
|
if (boolary == null)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
Int32 len = (boolliststr.Length > boolary.Length) ? boolary.Length : boolliststr.Length;
|
|
|
for (Int32 idx = 0; idx < len; ++idx)
|
|
|
{
|
|
|
boolary[idx] = (boolliststr[idx] == '0') ? false : true;
|
|
|
}
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 把Boolean数组转换为字符串列表
|
|
|
/// </summary>
|
|
|
/// <param name="boolary"></param>
|
|
|
/// <param name="boolliststr"></param>
|
|
|
/// <returns></returns>
|
|
|
public static String BooleanArrayToString(Boolean[] boolary)
|
|
|
{
|
|
|
if (boolary == null)
|
|
|
{
|
|
|
return String.Empty;
|
|
|
}
|
|
|
String boolliststr = String.Empty;
|
|
|
String itemstr = String.Empty;
|
|
|
foreach (Boolean bl in boolary)
|
|
|
{
|
|
|
itemstr = bl ? "1" : "0";
|
|
|
boolliststr = boolliststr + itemstr;
|
|
|
}
|
|
|
|
|
|
return boolliststr;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 把Boolean数组转换为数值数组
|
|
|
/// </summary>
|
|
|
/// <param name="boolary"></param>
|
|
|
/// <param name="intarray"></param>
|
|
|
/// <returns></returns>
|
|
|
public static Boolean BooleanArrayToInt32Array(Boolean[] boolary, Int32[] intarray)
|
|
|
{
|
|
|
if (boolary == null || intarray == null ||
|
|
|
boolary.Length < 1 || intarray.Length < 1 || boolary.Length != intarray.Length)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
for (Int32 idx = 0; idx < intarray.Length; ++idx)
|
|
|
{
|
|
|
intarray[idx] = boolary[idx] ? 1 : 0;
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 把Boolean数组转换为数值数组
|
|
|
/// </summary>
|
|
|
/// <param name="boolary"></param>
|
|
|
/// <param name="intarray"></param>
|
|
|
/// <returns></returns>
|
|
|
public static Int32[] BooleanArrayToInt32Array(Boolean[] boolary)
|
|
|
{
|
|
|
if (boolary == null || boolary.Length < 1)
|
|
|
{
|
|
|
return null;
|
|
|
}
|
|
|
|
|
|
Int32[] intarray = new Int32[boolary.Length];
|
|
|
for (Int32 idx = 0; idx < boolary.Length; ++idx)
|
|
|
{
|
|
|
intarray[idx] = boolary[idx] ? 1 : 0;
|
|
|
}
|
|
|
return intarray;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 把Boolean数组转换为数值数组
|
|
|
/// </summary>
|
|
|
/// <param name="boolary"></param>
|
|
|
/// <param name="intarray"></param>
|
|
|
/// <returns></returns>
|
|
|
public static Boolean Int32ArrayToBooleanArray(Int32[] intarray, Boolean[] boolary)
|
|
|
{
|
|
|
if (boolary == null || intarray == null ||
|
|
|
boolary.Length < 1 || intarray.Length < 1 || boolary.Length != intarray.Length)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
for (Int32 idx = 0; idx < intarray.Length; ++idx)
|
|
|
{
|
|
|
boolary[idx] = (intarray[idx] == 0) ? false : true;
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
/// 把Boolean数组转换为数值数组
|
|
|
/// </summary>
|
|
|
/// <param name="boolary"></param>
|
|
|
/// <param name="intarray"></param>
|
|
|
/// <returns></returns>
|
|
|
public static Boolean[] Int32ArrayToBooleanArray(Int32[] intarray)
|
|
|
{
|
|
|
if (intarray == null || intarray.Length < 1)
|
|
|
{
|
|
|
return null;
|
|
|
}
|
|
|
Boolean[] boolary = new Boolean[intarray.Length];
|
|
|
for (Int32 idx = 0; idx < intarray.Length; ++idx)
|
|
|
{
|
|
|
boolary[idx] = (intarray[idx] == 0) ? false : true;
|
|
|
}
|
|
|
return boolary;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 字节转换为Int16
|
|
|
/// </summary>
|
|
|
/// <param name="bytes"></param>
|
|
|
/// <returns></returns>
|
|
|
public static Int32 BytesToInt16(Byte[] bytes)
|
|
|
{
|
|
|
if (bytes == null || bytes.Length < 2)
|
|
|
{
|
|
|
return 0;
|
|
|
}
|
|
|
Int32 ret = bytes[0] + (bytes[1] << 8);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 字节转换为Int16
|
|
|
/// </summary>
|
|
|
/// <param name="bytes"></param>
|
|
|
/// <returns></returns>
|
|
|
public static Int32 BytesToInt16(Byte[] bytes, Int32 startidx)
|
|
|
{
|
|
|
if (bytes == null || startidx < 0 || startidx + 2 > bytes.Length)
|
|
|
{
|
|
|
return 0;
|
|
|
}
|
|
|
Int32 ret = bytes[startidx] + (bytes[startidx + 1] << 8);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 字节转换为Int32
|
|
|
/// </summary>
|
|
|
/// <param name="bytes"></param>
|
|
|
/// <returns></returns>
|
|
|
public static Int32 BytesToInt32(Byte[] bytes)
|
|
|
{
|
|
|
if (bytes == null || bytes.Length < 4)
|
|
|
{
|
|
|
return 0;
|
|
|
}
|
|
|
Int32 ret = bytes[0] + (bytes[1] << 8) + (bytes[2] << 16) + (bytes[3] << 24);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 字节转换为Int32
|
|
|
/// </summary>
|
|
|
/// <param name="bytes"></param>
|
|
|
/// <returns></returns>
|
|
|
public static Int32 BytesToInt32(Byte[] bytes, Int32 startidx)
|
|
|
{
|
|
|
if (bytes == null || startidx < 0 || startidx + 4 > bytes.Length)
|
|
|
{
|
|
|
return 0;
|
|
|
}
|
|
|
Int32 ret = bytes[startidx] +
|
|
|
(bytes[startidx + 1] << 8) +
|
|
|
(bytes[startidx + 2] << 16) +
|
|
|
(bytes[startidx + 3] << 24);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
/// 将字符串转成二进制
|
|
|
/// </summary>
|
|
|
/// <param name="s"></param>
|
|
|
/// <returns></returns>
|
|
|
public static string StringToBinary(string s)
|
|
|
{
|
|
|
byte[] data = Encoding.Unicode.GetBytes(s);
|
|
|
StringBuilder result = new StringBuilder(data.Length * 8);
|
|
|
|
|
|
foreach (byte b in data)
|
|
|
{
|
|
|
result.Append(Convert.ToString(b, 2).PadLeft(8, '0'));
|
|
|
}
|
|
|
return result.ToString();
|
|
|
}
|
|
|
|
|
|
/// 将二进制转成字符串
|
|
|
/// </summary>
|
|
|
/// <param name="s"></param>
|
|
|
/// <returns></returns>
|
|
|
public static string BinaryToString(string s)
|
|
|
{
|
|
|
System.Text.RegularExpressions.CaptureCollection cs =
|
|
|
System.Text.RegularExpressions.Regex.Match(s, @"([01]{8})+").Groups[1].Captures;
|
|
|
byte[] data = new byte[cs.Count];
|
|
|
for (int i = 0; i < cs.Count; i++)
|
|
|
{
|
|
|
data[i] = Convert.ToByte(cs[i].Value, 2);
|
|
|
}
|
|
|
return Encoding.Unicode.GetString(data, 0, data.Length);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// <函数：Decode>
|
|
|
/// 作用：将16进制数据编码转化为字符串，是Encode的逆过程
|
|
|
/// </summary>
|
|
|
/// <param name="strDecode"></param>
|
|
|
/// <returns></returns>
|
|
|
public static string Decode(string strDecode)
|
|
|
{
|
|
|
string sResult = "";
|
|
|
for (int i = 0; i < strDecode.Length / 4; i++)
|
|
|
{
|
|
|
sResult += (char)short.Parse(strDecode.Substring(i * 4, 4), global::System.Globalization.NumberStyles.HexNumber);
|
|
|
}
|
|
|
return sResult;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// <函数：Encode>
|
|
|
/// 作用：将字符串内容转化为16进制数据编码，其逆过程是Decode
|
|
|
/// 参数说明：
|
|
|
/// strEncode 需要转化的原始字符串
|
|
|
/// 转换的过程是直接把字符转换成Unicode字符,比如数字"3"-->0033,汉字"我"-->U+6211
|
|
|
/// 函数decode的过程是encode的逆过程.
|
|
|
/// </summary>
|
|
|
/// <param name="strEncode"></param>
|
|
|
/// <returns></returns>
|
|
|
public static string Encode(string strEncode)
|
|
|
{
|
|
|
string strReturn = "";// 存储转换后的编码
|
|
|
foreach (short shortx in strEncode.ToCharArray())
|
|
|
{
|
|
|
strReturn += shortx.ToString("X4");
|
|
|
}
|
|
|
return strReturn;
|
|
|
}
|
|
|
|
|
|
public static string StringToHexString(string s, Encoding encode)
|
|
|
{
|
|
|
byte[] b = encode.GetBytes(s);//按照指定编码将string编程字节数组
|
|
|
string result = string.Empty;
|
|
|
for (int i = 0; i < b.Length; i++)//逐字节变为16进制字符，以%隔开
|
|
|
{
|
|
|
//result += "%" + Convert.ToString(b[i], 16);
|
|
|
result += Convert.ToString(b[i], 16) + " ";
|
|
|
}
|
|
|
result = result.TrimEnd();
|
|
|
return result;
|
|
|
}
|
|
|
public static string HexStringToString(string hs, Encoding encode)
|
|
|
{
|
|
|
//以%分割字符串，并去掉空字符
|
|
|
//string[] chars = hs.Split(new char[] { '%' }, StringSplitOptions.RemoveEmptyEntries);
|
|
|
string[] chars = hs.Split(new char[] { ' ' },StringSplitOptions.RemoveEmptyEntries);
|
|
|
byte[] b = new byte[chars.Length];
|
|
|
//逐个字符变为16进制字节数据
|
|
|
for (int i = 0; i < chars.Length; i++)
|
|
|
{
|
|
|
b[i] = Convert.ToByte(chars[i], 16);
|
|
|
}
|
|
|
//按照指定编码将字节数组变为字符串
|
|
|
return encode.GetString(b);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 字符串转16进制字节数组
|
|
|
/// </summary>
|
|
|
/// <param name="hexString"></param>
|
|
|
/// <returns></returns>
|
|
|
public static byte[] strToToHexByte(string hexString)
|
|
|
{
|
|
|
//hexString = hexString.Trim();
|
|
|
//hexString = hexString.Replace(" ", "");
|
|
|
//if ((hexString.Length % 2) != 0)
|
|
|
// hexString += " ";
|
|
|
//byte[] returnBytes = new byte[hexString.Length / 2];
|
|
|
//for (int i = 0; i < returnBytes.Length; i++)
|
|
|
// returnBytes[i] = Convert.ToByte(hexString.Substring(i * 2, 2), 16);
|
|
|
//return returnBytes;
|
|
|
string[] chars = hexString.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
|
|
|
byte[] b = new byte[chars.Length];
|
|
|
//逐个字符变为16进制字节数据
|
|
|
for (int i = 0; i < chars.Length; i++)
|
|
|
{
|
|
|
b[i] = Convert.ToByte(chars[i], 16);
|
|
|
}
|
|
|
return b;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 从汉字转换到16进制
|
|
|
/// </summary>
|
|
|
/// <param name="s"></param>
|
|
|
/// <param name="charset">编码,如"utf-8","gb2312"</param>
|
|
|
/// <param name="fenge">是否每字符用逗号分隔</param>
|
|
|
/// <returns></returns>
|
|
|
public static string ToHex(string s, string charset, bool fenge)
|
|
|
{
|
|
|
if ((s.Length % 2) != 0)
|
|
|
{
|
|
|
s += " ";//空格
|
|
|
//throw new ArgumentException("s is not valid chinese string!");
|
|
|
}
|
|
|
System.Text.Encoding chs = System.Text.Encoding.GetEncoding(charset);
|
|
|
byte[] bytes = chs.GetBytes(s);
|
|
|
string str = "";
|
|
|
for (int i = 0; i < bytes.Length; i++)
|
|
|
{
|
|
|
str += string.Format("{0:X}", bytes[i]);
|
|
|
if (fenge && (i != bytes.Length - 1))
|
|
|
{
|
|
|
str += string.Format("{0}", ",");
|
|
|
}
|
|
|
}
|
|
|
return str.ToLower();
|
|
|
}
|
|
|
|
|
|
///<summary>
|
|
|
/// 从16进制转换成汉字
|
|
|
/// </summary>
|
|
|
/// <param name="hex"></param>
|
|
|
/// <param name="charset">编码,如"utf-8","gb2312"</param>
|
|
|
/// <returns></returns>
|
|
|
public static string UnHex(string hex, string charset)
|
|
|
{
|
|
|
if (hex == null)
|
|
|
throw new ArgumentNullException("hex");
|
|
|
hex = hex.Replace(",", "");
|
|
|
hex = hex.Replace("\n", "");
|
|
|
hex = hex.Replace("\\", "");
|
|
|
hex = hex.Replace(" ", "");
|
|
|
if (hex.Length % 2 != 0)
|
|
|
{
|
|
|
hex += "20";//空格
|
|
|
}
|
|
|
// 需要将 hex 转换成 byte 数组。
|
|
|
byte[] bytes = new byte[hex.Length / 2];
|
|
|
|
|
|
for (int i = 0; i < bytes.Length; i++)
|
|
|
{
|
|
|
try
|
|
|
{
|
|
|
// 每两个字符是一个 byte。
|
|
|
bytes[i] = byte.Parse(hex.Substring(i * 2, 2),
|
|
|
System.Globalization.NumberStyles.HexNumber);
|
|
|
}
|
|
|
catch
|
|
|
{
|
|
|
// Rethrow an exception with custom message.
|
|
|
throw new ArgumentException("hex is not a valid hex number!", "hex");
|
|
|
}
|
|
|
}
|
|
|
System.Text.Encoding chs = System.Text.Encoding.GetEncoding(charset);
|
|
|
return chs.GetString(bytes);
|
|
|
}
|
|
|
|
|
|
// //十进制转二进制
|
|
|
|
|
|
//Console.WriteLine("十进制166的二进制表示: "+Convert.ToString(166, 2));
|
|
|
|
|
|
// //十进制转八进制
|
|
|
|
|
|
//Console.WriteLine("十进制166的八进制表示: "+Convert.ToString(166, 8));
|
|
|
|
|
|
////十进制转十六进制 Console.WriteLine("十进制166的十六进制表示: "+Convert.ToString(166, 16));
|
|
|
|
|
|
////二进制转十进制
|
|
|
|
|
|
//Console.WriteLine("二进制 111101 的十进制表示: "+Convert.ToInt32("111101", 2));
|
|
|
|
|
|
// //八进制转十进制
|
|
|
|
|
|
//Console.WriteLine("八进制 44 的十进制表示: "+Convert.ToInt32("44", 8));
|
|
|
|
|
|
////十六进制转十进制
|
|
|
|
|
|
//Console.WriteLine("十六进制 CC的十进制表示: "+Convert.ToInt32("CC", 16));
|
|
|
|
|
|
}
|
|
|
}
|