zoukankan      html  css  js  c++  java
  • C# 进制之间的转换

      1 /// <summary>
      2         /// 十进制转换为二进制
      3         /// </summary>
      4         /// <param name="x"></param>
      5         /// <returns></returns>
      6         public static string DecToBin(string x)
      7         {
      8             string z = null;
      9             int X = Convert.ToInt32(x);
     10             int i = 0;
     11             long a, b = 0;
     12             while (X > 0)
     13             {
     14                 a = X%2;
     15                 X = X/2;
     16                 b = b + a*Pow(10, i);
     17                 i++;
     18             }
     19             z = Convert.ToString(b);
     20             return z;
     21         }
     22 
     23         /// <summary>
     24         /// 16进制转ASCII码
     25         /// </summary>
     26         /// <param name="hexString"></param>
     27         /// <returns></returns>
     28         public static string HexToAscii(string hexString)
     29         {
     30             StringBuilder sb = new StringBuilder();
     31             for (int i = 0; i <= hexString.Length - 2; i += 2)
     32             {
     33                 sb.Append(
     34                     Convert.ToString(
     35                         Convert.ToChar(Int32.Parse(hexString.Substring(i, 2),
     36                                                    System.Globalization.NumberStyles.HexNumber))));
     37             }
     38             return sb.ToString();
     39         }
     40 
     41         /// <summary>
     42         /// 十进制转换为八进制
     43         /// </summary>
     44         /// <param name="x"></param>
     45         /// <returns></returns>
     46         public static string DecToOtc(string x)
     47         {
     48             string z = null;
     49             int X = Convert.ToInt32(x);
     50             int i = 0;
     51             long a, b = 0;
     52             while (X > 0)
     53             {
     54                 a = X%8;
     55                 X = X/8;
     56                 b = b + a*Pow(10, i);
     57                 i++;
     58             }
     59             z = Convert.ToString(b);
     60             return z;
     61         }
     62 
     63         /// <summary>
     64         /// 十进制转换为十六进制
     65         /// </summary>
     66         /// <param name="x"></param>
     67         /// <returns></returns>
     68         public static string DecToHex(string x)
     69         {
     70             if (string.IsNullOrEmpty(x))
     71             {
     72                 return "0";
     73             }
     74             string z = null;
     75             int X = Convert.ToInt32(x);
     76             Stack a = new Stack();
     77             int i = 0;
     78             while (X > 0)
     79             {
     80                 a.Push(Convert.ToString(X%16));
     81                 X = X/16;
     82                 i++;
     83             }
     84             while (a.Count != 0)
     85                 z += ToHex(Convert.ToString(a.Pop()));
     86             if (string.IsNullOrEmpty(z))
     87             {
     88                 z = "0";
     89             }
     90             return z;
     91         }
     92 
     93         /// <summary>
     94         /// 二进制转换为十进制
     95         /// </summary>
     96         /// <param name="x"></param>
     97         /// <returns></returns>
     98         public static string BinToDec(string x)
     99         {
    100             string z = null;
    101             int X = Convert.ToInt32(x);
    102             int i = 0;
    103             long a, b = 0;
    104             while (X > 0)
    105             {
    106                 a = X%10;
    107                 X = X/10;
    108                 b = b + a*Pow(2, i);
    109                 i++;
    110             }
    111             z = Convert.ToString(b);
    112             return z;
    113         }
    114 
    115         /// <summary>
    116         /// 二进制转换为十进制,定长转换
    117         /// </summary>
    118         /// <param name="x"></param>
    119         /// <param name="iLength"></param>
    120         /// <returns></returns>
    121         public static string BinToDec(string x, short iLength)
    122         {
    123             StringBuilder sb = new StringBuilder();
    124             int iCount = 0;
    125 
    126             iCount = x.Length/iLength;
    127 
    128             if (x.Length%iLength > 0)
    129             {
    130                 iCount += 1;
    131             }
    132 
    133             int X = 0;
    134 
    135             for (int i = 0; i < iCount; i++)
    136             {
    137                 if ((i + 1)*iLength > x.Length)
    138                 {
    139                     X = Convert.ToInt32(x.Substring(i*iLength, (x.Length - iLength)));
    140                 }
    141                 else
    142                 {
    143                     X = Convert.ToInt32(x.Substring(i*iLength, iLength));
    144                 }
    145                 int j = 0;
    146                 long a, b = 0;
    147                 while (X > 0)
    148                 {
    149                     a = X%10;
    150                     X = X/10;
    151                     b = b + a*Pow(2, j);
    152                     j++;
    153                 }
    154                 sb.AppendFormat("{0:D2}", b);
    155             }
    156             return sb.ToString();
    157         }
    158 
    159         /// <summary>
    160         /// 二进制转换为十六进制,定长转换
    161         /// </summary>
    162         /// <param name="x"></param>
    163         /// <param name="iLength"></param>
    164         /// <returns></returns>
    165         public static string BinToHex(string x, short iLength)
    166         {
    167             StringBuilder sb = new StringBuilder();
    168             int iCount = 0;
    169 
    170             iCount = x.Length/iLength;
    171 
    172             if (x.Length%iLength > 0)
    173             {
    174                 iCount += 1;
    175             }
    176 
    177             int X = 0;
    178 
    179             for (int i = 0; i < iCount; i++)
    180             {
    181                 if ((i + 1)*iLength > x.Length)
    182                 {
    183                     X = Convert.ToInt32(x.Substring(i*iLength, (x.Length - iLength)));
    184                 }
    185                 else
    186                 {
    187                     X = Convert.ToInt32(x.Substring(i*iLength, iLength));
    188                 }
    189                 int j = 0;
    190                 long a, b = 0;
    191                 while (X > 0)
    192                 {
    193                     a = X%10;
    194                     X = X/10;
    195                     b = b + a*Pow(2, j);
    196                     j++;
    197                 }
    198                 //前补0
    199                 sb.Append(DecToHex(b.ToString()));
    200             }
    201             return sb.ToString();
    202         }
    203 
    204         /// <summary>
    205         /// 八进制转换为十进制
    206         /// </summary>
    207         /// <param name="x"></param>
    208         /// <returns></returns>
    209         public static string OctToDec(string x)
    210         {
    211             string z = null;
    212             int X = Convert.ToInt32(x);
    213             int i = 0;
    214             long a, b = 0;
    215             while (X > 0)
    216             {
    217                 a = X%10;
    218                 X = X/10;
    219                 b = b + a*Pow(8, i);
    220                 i++;
    221             }
    222             z = Convert.ToString(b);
    223             return z;
    224         }
    225 
    226 
    227         /// <summary>
    228         /// 十六进制转换为十进制
    229         /// </summary>
    230         /// <param name="x"></param>
    231         /// <returns></returns>
    232         public static string HexToDec(string x)
    233         {
    234             if (string.IsNullOrEmpty(x))
    235             {
    236                 return "0";
    237             }
    238             string z = null;
    239             Stack a = new Stack();
    240             int i = 0, j = 0, l = x.Length;
    241             long Tong = 0;
    242             while (i < l)
    243             {
    244                 a.Push(ToDec(Convert.ToString(x[i])));
    245                 i++;
    246             }
    247             while (a.Count != 0)
    248             {
    249                 Tong = Tong + Convert.ToInt64(a.Pop())*Pow(16, j);
    250                 j++;
    251             }
    252             z = Convert.ToString(Tong);
    253             return z;
    254         }
    255 
    256         #endregion //Helperfunctions
    257 
    258         /// <summary>
    259         /// 
    260         /// </summary>
    261         /// <param name="x"></param>
    262         /// <param name="y"></param>
    263         /// <returns></returns>
    264         private static long Pow(long x, long y)
    265         {
    266             int i = 1;
    267             long X = x;
    268             if (y == 0)
    269                 return 1;
    270             while (i < y)
    271             {
    272                 x = x*X;
    273                 i++;
    274             }
    275             return x;
    276         }
    277 
    278         /// <summary>
    279         /// 
    280         /// </summary>
    281         /// <param name="x"></param>
    282         /// <returns></returns>
    283         private static string ToDec(string x)
    284         {
    285             switch (x)
    286             {
    287                 case "A":
    288                     return "10";
    289                 case "B":
    290                     return "11";
    291                 case "C":
    292                     return "12";
    293                 case "D":
    294                     return "13";
    295                 case "E":
    296                     return "14";
    297                 case "F":
    298                     return "15";
    299                 default:
    300                     return x;
    301             }
    302         }
    303 
    304         /// <summary>
    305         /// 
    306         /// </summary>
    307         /// <param name="x"></param>
    308         /// <returns></returns>
    309         private static string ToHex(string x)
    310         {
    311             switch (x)
    312             {
    313                 case "10":
    314                     return "A";
    315                 case "11":
    316                     return "B";
    317                 case "12":
    318                     return "C";
    319                 case "13":
    320                     return "D";
    321                 case "14":
    322                     return "E";
    323                 case "15":
    324                     return "F";
    325                 default:
    326                     return x;
    327             }
    328         }
    329 
    330         /// <summary>
    331         /// 将16进制BYTE数组转换成16进制字符串
    332         /// </summary>
    333         /// <param name="bytes"></param>
    334         /// <returns></returns>
    335         public static string ToHexString(byte[] bytes) // 0xae00cf => "AE00CF "
    336         {
    337             string hexString = string.Empty;
    338             if (bytes != null)
    339             {
    340                 StringBuilder strB = new StringBuilder();
    341 
    342                 for (int i = 0; i < bytes.Length; i++)
    343                 {
    344                     strB.Append(bytes[i].ToString("X2"));
    345                 }
    346                 hexString = strB.ToString();
    347             }
    348             return hexString;
    349         }
      1 /// <summary>
      2         /// 
      3         /// </summary>
      4         /// <param name="bytes"></param>
      5         /// <param name="iLength"></param>
      6         /// <returns></returns>
      7         public static string ToHexString(byte[] bytes, int iLength) // 0xae00cf => "AE00CF "
      8         {
      9             string hexString = string.Empty;
     10             if (bytes != null)
     11             {
     12                 StringBuilder strB = new StringBuilder();
     13 
     14                 if (bytes.Length < iLength)
     15                 {
     16                     iLength = bytes.Length;
     17                 }
     18 
     19                 for (int i = 0; i < iLength; i++)
     20                 {
     21                     strB.Append(bytes[i].ToString("X2"));
     22                 }
     23                 hexString = strB.ToString();
     24             }
     25             return hexString;
     26         }
     27 
     28         /// <summary>
     29         /// 将byte数组转换为16进制字符串
     30         /// </summary>
     31         /// <param name="bytes">要转换的数组</param>
     32         /// <param name="iStart">数组下标</param>
     33         /// <param name="iLength">长度</param>
     34         /// <returns></returns>
     35         public static string ToHexString(byte[] bytes, int iStart, int iLength) // 0xae00cf => "AE00CF "
     36         {
     37             string hexString = string.Empty;
     38             if (bytes != null)
     39             {
     40                 StringBuilder strB = new StringBuilder();
     41 
     42                 //缓冲区长度问题,需清空缓冲区
     43                 if (bytes.Length < (iLength + iStart))
     44                 {
     45                     iLength = bytes.Length;
     46                 }
     47 
     48                 for (int i = iStart; i < iLength + iStart; i++)
     49                 {
     50                     strB.Append(bytes[i].ToString("X2"));
     51                 }
     52                 hexString = strB.ToString();
     53             }
     54             return hexString;
     55         }
     56 
     57         /// <summary>
     58         /// 
     59         /// </summary>
     60         /// <param name="hexString"></param>
     61         /// <param name="discarded"></param>
     62         /// <returns></returns>
     63         public static byte[] GetBytes(string hexString, out int discarded)
     64         {
     65             discarded = 0;
     66             string newString = "";
     67             char c;
     68             // remove all none A-F, 0-9, characters
     69             for (int i = 0; i < hexString.Length; i++)
     70             {
     71                 c = hexString[i];
     72                 if (Uri.IsHexDigit(c))
     73                     newString += c;
     74                 else
     75                     discarded++;
     76             }
     77             // if odd number of characters, discard last character
     78             if (newString.Length%2 != 0)
     79             {
     80                 discarded++;
     81                 newString = newString.Substring(0, newString.Length - 1);
     82             }
     83 
     84             return HexToByte(newString);
     85         }
     86 
     87         /// <summary>
     88         /// Converts from binary coded decimal to integer
     89         /// </summary>
     90         /// <param name="num"></param>
     91         /// <returns></returns>
     92         public static uint BcdToDec(uint num)
     93         {
     94             return HornerScheme(num, 0x10, 10);
     95         }
     96 
     97         /// <summary>
     98         /// Converts from integer to binary coded decimal
     99         /// </summary>
    100         /// <param name="num"></param>
    101         /// <returns></returns>
    102         public static uint DecToBcd(uint num)
    103         {
    104             return HornerScheme(num, 10, 0x10);
    105         }
    106 
    107         private static uint HornerScheme(uint num, uint divider, uint factor)
    108         {
    109             uint remainder = 0, quotient = 0, result = 0;
    110             remainder = num%divider;
    111             quotient = num/divider;
    112             if (!(quotient == 0 && remainder == 0))
    113                 result += HornerScheme(quotient, divider, factor)*factor + remainder;
    114             return result;
    115         }
    116 
    117         /// <summary>
    118         /// byte数组尾部0截取函数
    119         /// </summary>
    120         /// <param name="buf">原始byte数组</param>
    121         /// <param name="iLength">要截取的长度</param>
    122         /// <returns>截取后的数组</returns>
    123         public static byte[] InterceptByte(byte[] buf, int iLength)
    124         {
    125             StringBuilder sb = new StringBuilder(iLength*2);
    126             sb = sb.Append(ToHexString(buf, (short) iLength));
    127             int discarded = 0;
    128             byte[] bReturn = GetBytes(sb.ToString(), out discarded);
    129 
    130             if (discarded > 0)
    131             {
    132                 throw new Exception("byte数组截取有数据丢失!");
    133             }
    134             return bReturn;
    135         }
    136 
    137         /// <summary>
    138         /// 
    139         /// </summary>
    140         /// <param name="hexString"></param>
    141         /// <returns></returns>
    142         public static byte[] HexToByte(string hexString)
    143         {
    144             if (string.IsNullOrEmpty(hexString))
    145             {
    146                 hexString = "00";
    147             }
    148             byte[] returnBytes = new byte[hexString.Length/2];
    149             for (int i = 0; i < returnBytes.Length; i++)
    150                 returnBytes[i] = Convert.ToByte(hexString.Substring(i*2, 2), 16);
    151             return returnBytes;
    152         }
    153 
    154         /// <summary>
    155         /// 日期转BCD数组
    156         /// </summary>
    157         /// <param name="dateTime"></param>
    158         /// <param name="type">4 6 7</param>
    159         /// <returns></returns>
    160         public static byte[] DateTimeToBCD(DateTime dateTime, ushort type)
    161         {
    162             string strServerTime = string.Format("{0:yyyyMMddHHmmss}", dateTime);
    163 
    164             byte[] bcd = new byte[type];
    165             if (type == 4)
    166             {
    167                 bcd[0] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(0, 2))).ToString("D2"));
    168                 bcd[1] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(2, 2))).ToString("D2"));
    169                 bcd[2] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(4, 2))).ToString("D2"));
    170                 bcd[3] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(6, 2))).ToString("D2"));
    171             }
    172             if (type == 6)
    173             {
    174                 bcd[0] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(2, 2))).ToString("D2"));
    175                 bcd[1] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(4, 2))).ToString("D2"));
    176                 bcd[2] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(6, 2))).ToString("D2"));
    177                 bcd[3] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(8, 2))).ToString("D2"));
    178                 bcd[4] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(10, 2))).ToString("D2"));
    179                 bcd[5] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(12, 2))).ToString("D2"));
    180             }
    181             if (type == 7)
    182             {
    183                 bcd[0] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(0, 2))).ToString("D2"));
    184                 bcd[1] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(2, 2))).ToString("D2"));
    185                 bcd[2] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(4, 2))).ToString("D2"));
    186                 bcd[3] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(6, 2))).ToString("D2"));
    187                 bcd[4] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(8, 2))).ToString("D2"));
    188                 bcd[5] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(10, 2))).ToString("D2"));
    189                 bcd[5] = byte.Parse(DecToBcd(uint.Parse(strServerTime.Substring(12, 2))).ToString("D2"));
    190             }
    191             return bcd;
    192         }
    193 
    194         /// <summary>
    195         /// BCD时间转日期时间
    196         /// </summary>
    197         /// <param name="bcdTime"></param>
    198         /// <param name="type"></param>
    199         /// <returns></returns>
    200         public static DateTime BCDToDateTime(byte[] bcdTime, ushort type)
    201         {
    202             StringBuilder sb = new StringBuilder();
    203             if (type == 4) //4位BCD码的日期
    204             {
    205                 sb.Append(BcdToDec(bcdTime[0]).ToString("D2"));
    206                 sb.Append(BcdToDec(bcdTime[1]).ToString("D2"));
    207                 sb.Append('-' + BcdToDec(bcdTime[2]).ToString("D2"));
    208                 sb.Append('-' + BcdToDec(bcdTime[3]).ToString("D2") + " ");
    209             }
    210             if (type == 6) //6位BCD码的时间
    211             {
    212                 sb.Append(DateTime.Now.ToString("yyyy").Substring(0, 2));
    213                 sb.Append(BcdToDec(bcdTime[0]).ToString("D2"));
    214                 sb.Append('-' + BcdToDec(bcdTime[1]).ToString("D2"));
    215                 sb.Append('-' + BcdToDec(bcdTime[2]).ToString("D2") + " ");
    216                 sb.Append(BcdToDec(bcdTime[3]).ToString("D2") + ":");
    217                 sb.Append(BcdToDec(bcdTime[4]).ToString("D2") + ":");
    218                 sb.Append(BcdToDec(bcdTime[5]));
    219             }
    220             if (type == 7) //7位BCD码的日期
    221             {
    222                 sb.Append(BcdToDec(bcdTime[0]).ToString("D2"));
    223                 sb.Append(BcdToDec(bcdTime[1]).ToString("D2"));
    224                 sb.Append('-' + BcdToDec(bcdTime[2]).ToString("D2"));
    225                 sb.Append('-' + BcdToDec(bcdTime[3]).ToString("D2") + " ");
    226                 sb.Append(BcdToDec(bcdTime[4]).ToString("D2") + ":");
    227                 sb.Append(BcdToDec(bcdTime[5]).ToString("D2") + ":");
    228                 sb.Append(BcdToDec(bcdTime[6]));
    229             }
    230 
    231             DateTime dt;
    232             //2011-3-26 当日期出错时的处理
    233             DateTime.TryParse(sb.ToString(), out dt);
    234 
    235             return dt;
    236         }
    237     }
    238 }

    http://www.cnblogs.com/jhabb/archive/2011/05/06/2038777.html[落冰]

  • 相关阅读:
    layui弹出层处理(获取、操作弹出层数据等)
    Unity3D判断鼠标向右或向左滑动,响应不同的事件
    (转载)李剑英的CSLight入门指南结合NGUI热更新
    Unity3D研究院之LZMA压缩文件与解压文件
    CSLight研究院之学习笔记结合NGUI(一)
    《暗黑世界GM管理后台系统》部署+功能说明文档
    Firefly卡牌手游《暗黑世界V1.5》服务器端源码+GM管理后台源码
    电信SDK Pay函数里面System.out.print 无输出消息
    WP8:在Unity中使用OpenXLive
    WP8:Unity3D之间的值传递
  • 原文地址:https://www.cnblogs.com/GeneralKING/p/2736818.html
Copyright © 2011-2022 走看看